Class: Utopia::Localization::Middleware

Inherits:
Object
  • Object
show all
Defined in:
lib/utopia/localization/middleware.rb

Constant Summary collapse

RESOURCE_NOT_FOUND = 
[400, {}, []].freeze
HTTP_ACCEPT_LANGUAGE = 
"HTTP_ACCEPT_LANGUAGE".freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app, locales:, default_locale: nil, default_locales: nil, hosts: {}, ignore: []) ⇒ Middleware

Returns a new instance of Middleware.

Parameters:

  • locales (Array<String>) —

    An array of all supported locales.

  • default_locale (String) (defaults to: nil) —

    The default locale if none is provided.

  • default_locales (String) (defaults to: nil) —

    The locales to try in order if none is provided.

  • hosts (Hash<Pattern, String>) (defaults to: {}) —

    Specify a mapping of the HTTP_HOST header to a given locale.

  • ignore (Array<Pattern>) (defaults to: []) —

    A list of patterns matched against PATH_INFO which will not be localized.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/utopia/localization/middleware.rb', line 20

def initialize(app, locales:, default_locale: nil, default_locales: nil, hosts: {}, ignore: [])
  @app = app
  
  @all_locales = HTTP::Accept::Languages::Locales.new(locales)
  
  # Locales here are represented as an array of strings, e.g. ['en', 'ja', 'cn', 'de'] and are used in order if no locale is specified by the user.
  unless @default_locales = default_locales
    if default_locale
      @default_locales = [default_locale, nil]
    else
      # We append nil, i.e. no localization.
      @default_locales = @all_locales.names + [nil]
    end
  end
  
  @default_locale = default_locale || @default_locales.first
  
  unless @default_locales.include? @default_locale
    @default_locales.unshift(@default_locale)
  end
  
  # Select a localization based on a request host name:
  @hosts = hosts
  
  @ignore = ignore || options[:nonlocalized]
  
  @methods = methods
end

Instance Attribute Details

#all_locales ⇒ Object (readonly)

Returns the value of attribute all_locales.



61
62
63
 
# File 'lib/utopia/localization/middleware.rb', line 61

def all_locales
  @all_locales
end

#default_locale ⇒ Object (readonly)

Returns the value of attribute default_locale.



62
63
64
 
# File 'lib/utopia/localization/middleware.rb', line 62

def default_locale
  @default_locale
end

Instance Method Details

#browser_preferred_locales(env) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/utopia/localization/middleware.rb', line 110

def browser_preferred_locales(env)
  accept_languages = env[HTTP_ACCEPT_LANGUAGE]
  
  # No user prefered languages:
  return [] unless accept_languages
  
  # Extract the ordered list of languages:
  languages = HTTP::Accept::Languages.parse(accept_languages)
  
  # Returns available languages based on the order languages:
  return @all_locales & languages
rescue HTTP::Accept::ParseError
  # If we fail to parse the browser Accept-Language header, we ignore it (silently).
  return []
end

#call(env) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/utopia/localization/middleware.rb', line 150

def call(env)
  # Pass the request through if it shouldn't be localized:
  return @app.call(env) unless localized?(env)
  
  env[LOCALIZATION_KEY] = self
  
  response = nil
  
  # We have a non-localized request, but there might be a localized resource. We return the best localization possible:
  preferred_locales(env) do |localized_env|
    # puts "Trying locale: #{localized_env[CURRENT_LOCALE_KEY]}: #{localized_env[Rack::PATH_INFO]}..."
    
    response = @app.call(localized_env)
    
    break unless response[0] >= 400
    
    response[2].close if response[2].respond_to?(:close)
  end
  
  return vary(env, response)
end

#freeze ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/utopia/localization/middleware.rb', line 49

def freeze
  return self if frozen?
  
  @all_locales.freeze
  @default_locales.freeze
  @default_locale.freeze
  @hosts.freeze
  @ignore.freeze
  
  super
end

#host_preferred_locales(env) ⇒ Object 



90
91
92
93
94
95
96
97
 
# File 'lib/utopia/localization/middleware.rb', line 90

def host_preferred_locales(env)
  http_host = env[Rack::HTTP_HOST]
  
  # Yield all hosts which match the incoming http_host:
  @hosts.each do |pattern, locale|
    yield locale if http_host[pattern]
  end
end

#localized?(env) ⇒ Boolean

Returns:

  • (Boolean) 


126
127
128
129
130
131
132
 
# File 'lib/utopia/localization/middleware.rb', line 126

def localized?(env)
  # Ignore requests which match the ignored paths:
  path_info = env[Rack::PATH_INFO]
  return false if @ignore.any?{|pattern| path_info[pattern] != nil}
  
  return true
end

#preferred_locales(env) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/utopia/localization/middleware.rb', line 64

def preferred_locales(env)
  return to_enum(:preferred_locales, env) unless block_given?
  
  # Keep track of what locales have been tried:
  locales = Set.new
  
  host_preferred_locales(env) do |locale|
    yield env.merge(CURRENT_LOCALE_KEY => locale) if locales.add? locale
  end
  
  request_preferred_locale(env) do |locale, path|
    # We have extracted a locale from the path, so from this point on we should use the updated path:
    env = env.merge(Rack::PATH_INFO => path.to_s)
    
    yield env.merge(CURRENT_LOCALE_KEY => locale) if locales.add? locale
  end
  
  browser_preferred_locales(env).each do |locale|
    yield env.merge(CURRENT_LOCALE_KEY => locale) if locales.add? locale
  end
  
  @default_locales.each do |locale|
    yield env.merge(CURRENT_LOCALE_KEY => locale) if locales.add? locale
  end
end

#request_preferred_locale(env) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
 
# File 'lib/utopia/localization/middleware.rb', line 99

def request_preferred_locale(env)
  path = Path[env[Rack::PATH_INFO]]
  
  if request_locale = @all_locales.patterns[path.first]
    # Remove the localization prefix:
    path.delete_at(0)
    
    yield request_locale, path
  end
end

#vary(env, response) ⇒ Object

Set the Vary: header on the response to indicate that this response should include the header in the cache key.



135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/utopia/localization/middleware.rb', line 135

def vary(env, response)
  headers = response[1].to_a
  
  # This response was based on the Accept-Language header:
  headers << ["Vary", "Accept-Language"]
  
  # Althought this header is generally not supported, we supply it anyway as it is useful for debugging:
  if locale = env[CURRENT_LOCALE_KEY]
    # Set the Content-Location to point to the localized URI as requested:
    headers["Content-Location"] = "/#{locale}" + env[Rack::PATH_INFO]
  end
  
  return response
end