rack-i18n_best_langs 0.2

data/.yardopts

@@ -0,0 +1,4 @@
+-m markdown
+--no-private
+-
+COPYING

data/COPYING

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

data/README.md

@@ -0,0 +1,176 @@
+rack-i8n_best_langs: guess best language for content served over Rack
+=====================================================================
+
+rack-i18n_best_langs is a Rack middleware component that takes care of
+understanding what are the best languages for a site visitor.
+
+If you manage a site that has content many languages and also localized URLs,
+you will find `rack-i18n_best_langs` very useful, especially when used in
+conjunction with `rack-i18n_routes`.
+
+
+Features
+--------
+
+Language discovery is done using three clues:
+
+* the presences of language tags in paths (e.g. `/service/warranty/ita`),
+* the content of the HTTP `Accept-Language` header,
+* the content of the `rack.i18n_best_langs` cookie when set.
+
+All these clues are taken into account and evaluated against the list
+of languages available and their preferred order. It is possible to configure
+which of these clues is the most important.
+
+An additional clue is available when `AliasMapping` is used as the mapping
+function: the language in which the path is written. For
+example, `/articles/the-victory` is English, `/artículos/la-victoria`, is
+Spanish, `/articles/la-victoire` is French.
+
+
+Examples
+--------
+
+rack-i18n_best_langs works like any other Rack middleware component.
+
+    # in your server.ru rackup file
+    require 'rack/i18n_best_langs'
+
+    FAVORITE_LANGUAGES = %w(eng spa deu fra)
+
+    use Rack::I18nBestLangs, FAVORITE_LANGUAGES
+    run MyApp
+
+In your application you will find the list of languages that should be used to
+serve the content, arranged from the most favorite to the least in the
+`rack.i18n_best_langs` Rack variable. It is then up to downstream application
+to use this information in the best way.
+
+### See the guessed languages
+
+This small application
+
+    # in your server.ru rackup file
+    require 'rack/i18n_best_langs'
+
+    FAVORITE_LANGUAGES = %w(eng spa deu)
+
+    use Rack::I18nBestLangs, FAVORITE_LANGUAGES
+
+    app = Proc.new do |env|
+        langs = env['rack.i18n_best_langs']
+        [200, {"Content-Type" => "text/plain"}, [langs.inspect] ]
+    end
+
+    run app
+
+will produce the following results for these URLs.
+
+    # /foo =>
+    #    [#<LocaleCode 'eng'>, #<LocaleCode 'spa'>, #<LocaleCode 'deu'>]
+
+    # /foo/spa =>
+    #    [#<LocaleCode 'spa'>, #<LocaleCode 'eng'>, #<LocaleCode 'deu'>]
+
+    # /foo (with Accept-Language = it-IT, es-ES, fr-FR) =>
+    #    [#<LocaleCode 'spa'>, #<LocaleCode 'eng'>, #<LocaleCode 'deu'>]
+
+    # /foo/deu (with Accept-Language = it-IT, es-ES) =>
+    #    [#<LocaleCode 'deu'>, #<LocaleCode 'spa'>, #<LocaleCode 'eng'>]
+
+    # /foo (with cookie set to 'deu') =>
+    #    [#<LocaleCode 'deu'>, #<LocaleCode 'eng'>, #<LocaleCode 'spa'>]
+
+    # /foo/spa (with cookie set to 'deu') =>
+    #    [#<LocaleCode 'deu'>, #<LocaleCode 'spa'>, #<LocaleCode 'eng'>]
+
+
+### Changing the clues' weights
+
+You can tune the weights of the clues to set which clue is the most important.
+
+The default order of importance and weights are
+
+* language set in cookie (`:cookie`): 3
+* language present in tag (`:path`): 2
+* language is in `Accept-Language` header (`:header`): 1
+
+You can change these weight with the `:weights` option.
+
+    FAVORITE_LANGUAGES = %w(eng spa deu)
+    WEIGHTS = { :path => 3, :header => 2, :cookie = 1 }
+
+    use Rack::I18nBestLangs, FAVORITE_LANGUAGES, :weights => WEIGHTS
+
+
+### Using `AliasMapping`
+
+If you want to use the content of the URI path as an additional clue to guess
+the best languages, use an `AliasMapping` function as path mapping function.
+
+    # in your server.ru rackup file
+    require 'rack/i18n_best_langs'
+    require 'rack/i18n_routes/alias_mapping'
+
+    FAVORITE_LANGUAGES = %w(eng spa deu fra)
+
+    aliases = {
+        'articles' => {
+            'fra' => 'articles',
+            'spa' => ['artículos', 'articulos']
+
+            :children => {
+                'the-victory' => {
+                    'fra' => 'la-victoire',
+                    'spa' => 'la-victoria'
+                }
+                'the-block' => {
+                    'fra' => 'le-bloc',
+                    'spa' => 'el-bloque'
+                }
+            }
+        }
+    }
+    MAPPING = Rack::I18nRoutes::AliasMapping.new(paths, :default => 'eng')
+
+    use Rack::I18nBestLangs, FAVORITE_LANGUAGES, :path_mapping_fn => MAPPING
+    run MyApp
+
+
+Requirements
+------------
+
+No requirements outside Ruby >= 1.8.7 and Rack.
+
+
+Install
+-------
+
+    gem install rack-i18n_best_langs
+
+
+Author
+------
+
+* Gioele Barabucci <http://svario.it/gioele> (initial author)
+
+Development
+-----------
+
+Code
+: <https://github.com/gioele/rack-i18n_best_langs>
+
+Report issues
+: <https://github.com/gioele/rack-i18n_best_langs/issues>
+
+Documentation
+: <http://rubydoc.info/gems/rack-i18n_best_langs>
+
+
+License
+-------
+
+This is free software released into the public domain (CC0 license).
+
+See the `COPYING` file or <http://creativecommons.org/publicdomain/zero/1.0/>
+for more details.

data/Rakefile

@@ -0,0 +1,30 @@
+# This is free software released into the public domain (CC0 license).
+#
+# See the `COPYING` file or <http://creativecommons.org/publicdomain/zero/1.0/>
+# for more details.
+
+
+begin
+	require 'bones'
+rescue LoadError
+	abort '### Please install the "bones" gem ###'
+end
+
+Bones {
+	name     'rack-i18n_best_langs'
+	authors  'Gioele Barabucci'
+	email    'gioele@svario.it'
+	url      'https://github.com/gioele/rack-i18n_best_langs'
+
+	version  '0.2'
+
+	ignore_file  '.gitignore'
+
+	depend_on 'rack'
+	depend_on 'rack-test', :development => true
+	depend_on 'rack-i18n_routes', :development => true
+	depend_on 'bones-rspec', :development => true
+}
+
+task :default => 'spec:run'
+task 'gem:release' => 'spec:run'

data/lib/rack/i18n_best_langs.rb

@@ -0,0 +1,213 @@
+# This is free software released into the public domain (CC0 license).
+#
+# See the `COPYING` file or <http://creativecommons.org/publicdomain/zero/1.0/>
+# for more details.
+
+
+require 'rack/language_tag.rb'
+
+module Rack
+
+class I18nBestLangs
+	RACK_VARIABLE = 'rack.i18n_best_langs'
+
+	# Create a new I18nBestLangs middleware component.
+	#
+	# @param [[String]] avail_languages
+	#
+	# @param [Hash] opts
+	# @option opts [Hash{Symbol => Integer}] :weights Weights for clues
+	#                                                 (the higher, the most
+	#                                                 important): `:header`,
+	#                                                 `:path`, `:cookie`, `:aliases_path`.
+	# @option opts [#map_with_langs] :path_mapping_fn A function that maps
+	#                                                 localized URI paths
+	#                                                 into normalized paths,
+	#                                                 should be a
+	#                                                 Rack::I18nRoutes::AliasMapping.
+
+	def initialize(app, avail_languages, opts = {})
+		@app = app
+
+		score_base = avail_languages.length
+
+		weights = opts[:weights] || {}
+		weight_header       = weights[:header]       || 1
+		weight_aliases_path = weights[:aliases_path] || 2
+		weight_path         = weights[:path]         || 3
+		weight_cookie       = weights[:cookie]       || 4
+
+		@score_for_header       = score_base * (10 ** weight_header)
+		@score_for_aliases_path = score_base * (10 ** weight_aliases_path)
+		@score_for_path         = score_base * (10 ** weight_path)
+		@score_for_cookie       = score_base * (10 ** weight_cookie)
+
+		@avail_languages = {}
+		avail_languages.each_with_index do |lang, i|
+			code = LanguageTag.new(lang).freeze
+			score = score_base - i
+
+			@avail_languages[code] = score
+		end
+
+		@language_path_regex = regex_for_languages_in_path
+
+		@path_mapping_fn = opts[:path_mapping_fn]
+	end
+
+	def call(env)
+		lang_info = find_best_languages(env)
+		env[I18nBestLangs::RACK_VARIABLE] = lang_info[:languages]
+		env['PATH_INFO'] = lang_info[:path_info]
+
+		return @app.call(env)
+	end
+
+	def find_best_languages(env)
+		path = env['PATH_INFO']
+		accept_language_header = extract_language_header(env)
+		cookies = extract_language_cookie(env)
+
+		clean_path_info = remove_language_from_path(path)
+
+		langs = @avail_languages.dup
+		add_score_for_path(path, langs)
+		add_score_for_accept_language_header(accept_language_header, langs)
+		add_score_for_cookie(cookies, langs)
+		add_score_for_aliases_path(path, langs)
+
+		sorted_langs = langs.to_a.sort_by { |lang_info| -(lang_info[1]) }.map(&:first)
+
+		info = {
+			:languages => sorted_langs,
+			:path_info => clean_path_info,
+		}
+
+		return info
+	end
+
+	def extract_language_header(env)
+		header = env['HTTP_ACCEPT_LANGUAGE']
+
+		if (header =~ HEADER_FORMAT)
+			return header
+		else
+			# FIXME: env.warn
+			return ""
+		end
+	end
+
+	def extract_language_cookie(env)
+		return Rack::Request.new(env).cookies[I18nBestLangs::RACK_VARIABLE]
+	end
+
+	def remove_language_from_path(path)
+		return path.sub(@language_path_regex, '')
+	end
+
+	def add_score_for_path(path, langs)
+		path_match = path.match(@language_path_regex)
+
+		path_include_language = !path_match.nil?
+		if !path_include_language
+			return
+		end
+
+		lang_code = LanguageTag.new(path_match[1])
+		langs[lang_code] += @score_for_path
+	end
+
+	def add_score_for_accept_language_header(accept_language_header, langs)
+		if accept_language_header.nil? || !valid_language_header(accept_language_header)
+			return
+		end
+
+		header_langs = languages_in_accept_language(accept_language_header)
+
+		header_langs.each do |lang, q|
+			if !langs.include?(lang)
+				next
+			end
+
+			langs[lang] += @score_for_header * q
+		end
+	end
+
+	def add_score_for_cookie(cookie, langs)
+		if cookie.nil?
+			return
+		end
+
+		cookie_langs = cookie.split(',').map { |tag| LanguageTag.parse(tag) }
+
+		cookie_langs.reverse.each_with_index do |lang, idx|
+			if !langs.include?(lang)
+				next
+			end
+
+			importance = idx + 1
+			langs[lang] += @score_for_cookie * importance
+		end
+	end
+
+	def add_score_for_aliases_path(path, langs)
+		if !@path_mapping_fn.respond_to?(:map_with_langs)
+			return
+		end
+
+		ph, aliases_langs = @path_mapping_fn.map_with_langs(path)
+		aliases_langs.map! { |tag| LanguageTag.parse(tag) }
+
+		lang_uses = aliases_langs.inject(Hash.new(0)) {|freq, lang| freq[lang] += 1; freq }
+		lang_uses.sort_by { |lang, freq| -freq }.each do |lang, freq|
+			if !langs.include?(lang)
+				next
+			end
+
+			langs[lang] += @score_for_aliases_path * freq
+		end
+	end
+
+	def valid_language_header(accept_language_header)
+		return true # FIXME: check with regex
+	end
+
+	def languages_in_accept_language(accept_language_header)
+		raw_langs = accept_language_header.split(',')
+
+		langs = raw_langs.map { |l| l.sub('q=', '')}.
+		                      map { |l| l.split(';') }
+
+		langs.each_with_index do |l, i|
+			l[0] = LanguageTag.parse(l[0])
+			l[1] = (l[1] || 1).to_f
+
+			sorting_epsilon = (langs.size - i).to_f / 100
+			l[1] += sorting_epsilon # keep the original order when sorting
+		end
+
+		return langs
+	end
+
+	def regex_for_languages_in_path
+		all_languages = @avail_languages.keys.map(&:alpha3)
+
+		preamble = "/"
+		body = "(" + all_languages.join("|") + ")"
+		trail = "/?$"
+
+		return Regexp.new(preamble + body + trail)
+	end
+
+
+	def self.accept_language_format
+		lang = '[-_a-zA-Z]+'
+		qvalue = '(; ?q=[01]+(\.[0-9]{1,3})?)'
+
+		return Regexp.new("\\A#{lang}#{qvalue}?(, ?#{lang}#{qvalue}?)*\\Z")
+	end
+
+	HEADER_FORMAT = self.accept_language_format
+end
+
+end

data/lib/rack/language_tag.rb

@@ -0,0 +1,84 @@
+# This is free software released into the public domain (CC0 license).
+#
+# See the `COPYING` file or <http://creativecommons.org/publicdomain/zero/1.0/>
+# for more details.
+
+
+# BCP 47
+
+class LanguageTag
+	VERSION = "5646.0.1"
+
+	A3_TO_A2 = {
+		'ara' => 'ar',
+		'deu' => 'de',
+		'eng' => 'en',
+		'fra' => 'fr',
+		'ita' => 'it',
+	}
+
+	def self.parse(raw_code)
+		iso_code = raw_code.split('-').flatten.first
+
+		if iso_code.nil?
+			raise "Unparseable language tag"
+		end
+
+		if !(A3_TO_A2.keys + A3_TO_A2.values).include?(iso_code)
+			raise "Unknown language tag #{iso_code}" #FIXME
+		end
+
+		return LanguageTag.new(iso_code)
+	end
+
+	def initialize(iso_code, extlang = nil, script = nil, region = nil, variant = [], extension = [], privateuse = nil)
+		case iso_code.length
+		when 3
+			@alpha3 = iso_code
+		when 2
+			@alpha2 = iso_code
+		end
+	end
+
+	def alpha2
+		@alpha2 ||= a3_to_a2(@alpha3)
+	end
+
+	def alpha3
+		@alpha3 ||= a2_to_a3(@alpha2)
+	end
+
+	def a3_to_a2(alpha3)
+		return A3_TO_A2[alpha3]
+	end
+
+	def a2_to_a3(alpha2)
+		return A3_TO_A2.invert[alpha2]
+	end
+
+	def complete
+		alpha3
+	end
+
+	def ==(other_code)
+		return self.complete == LanguageTag.new(other_code).complete
+	end
+
+	def hash
+		self.complete.hash
+	end
+
+	def eql?(other)
+		if self.equal?(other)
+			return true
+		elsif self.class != other.class
+			return false
+		end
+
+		return self.alpha3 == other.alpha3
+	end
+
+	def inspect
+		return "#<LocaleCode '#{complete}'>"
+	end
+end

data/spec/i18n-best-langs_spec.rb

@@ -0,0 +1,132 @@
+# This is free software released into the public domain (CC0 license).
+#
+# See the `COPYING` file or <http://creativecommons.org/publicdomain/zero/1.0/>
+# for more details.
+
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Rack::I18nBestLangs do
+	AVAIL_LANGUAGES = ['ita', 'fra', 'eng', 'ara']
+
+	def app(*opts)
+		builder = Rack::Builder.new do
+			use Rack::Lint
+			use Rack::I18nBestLangs, *opts
+			use Rack::Lint
+
+			run lambda { |env| [200, {"Content-Type" => "text/plain"}, [""]] }
+		end
+
+		return builder.to_app
+	end
+
+	def request_with(path, env_opts = {}, *i18n_opts)
+		if i18n_opts.empty?
+			extra_opts = {}
+
+			i18n_opts << AVAIL_LANGUAGES # known_languages
+			i18n_opts << extra_opts
+		end
+
+		session = Rack::Test::Session.new(Rack::MockSession.new(app(*i18n_opts)))
+	        session.request(path, env_opts)
+
+        	return session.last_request
+	end
+
+	def http_langs(*langs)
+		{ 'HTTP_ACCEPT_LANGUAGE' => langs.flatten.join(', ') }
+	end
+
+	def cookie_langs(*langs)
+		{ 'HTTP_COOKIE' => Rack::I18nBestLangs::RACK_VARIABLE + "=" + langs.flatten.join(',') }
+	end
+
+	def aliases_mapping(aliases, default)
+		mapping = Rack::I18nRoutes::AliasMapping.new(aliases, :default => default)
+
+		return { :path_mapping_fn => mapping }
+	end
+
+	context "with no external information" do
+		it "suggests exactly the list of languages" do
+			env = request_with('/').env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.should be_an Array
+			languages.should == AVAIL_LANGUAGES
+		end
+
+		it "is not confused by paths that look like languages" do
+			env = request_with('/francesca').env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.should == AVAIL_LANGUAGES
+		end
+	end
+
+	context "with language in path" do
+		it "places that language as best language when available" do
+			env = request_with('/fra/').env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.first.should eq('fra')
+			languages.should include(*AVAIL_LANGUAGES)
+		end
+
+		it "ignores that language when not available" do
+			env = request_with('/lat/').env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.should == AVAIL_LANGUAGES
+		end
+
+		it "selects the first path component" do
+			env = request_with('http://italia.example.org/foo/fra').env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.first.should eq('fra')
+			languages.should include(*AVAIL_LANGUAGES)
+		end
+
+		it "removes the language from the path" do
+			env = request_with('/foo/fra').env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.first.should eq('fra')
+			env['PATH_INFO'].should eq('/foo')
+		end
+	end
+
+	context "with language in headers" do
+		it "places that language as best language when available" do
+			env = request_with('/hello', http_langs('fr-FR')).env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.first.should == 'fra'
+		end
+	end
+
+	context "with language in cookie" do
+		it "places that language as best language when available" do
+			env = request_with('/hello', cookie_langs('eng')).env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.first.should == 'eng'
+		end
+	end
+
+	context "with language implied in path and AliasMapper" do
+		let(:aliases) { Hash['house' => { 'ita' =>  'casa', 'fra' => 'maison' }] }
+		let(:default_lang) { 'unk' }
+
+		it "places the most common non-default language as best language" do
+			env = request_with('/maison', {}, AVAIL_LANGUAGES, aliases_mapping(aliases, default_lang)).env
+			languages = env[Rack::I18nBestLangs::RACK_VARIABLE]
+
+			languages.first.should == 'fra'
+		end
+	end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# This is free software released into the public domain (CC0 license).
+#
+# See the `COPYING` file or <http://creativecommons.org/publicdomain/zero/1.0/>
+# for more details.
+
+
+LIB_DIR = File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+$LOAD_PATH.unshift(LIB_DIR) unless $LOAD_PATH.include?(LIB_DIR)
+
+require 'rack/i18n_best_langs'
+require 'rack/i18n_routes'
+require 'rack/test'
+
+include Rack::Test::Methods
+
+RSpec.configure do |config|
+end
+

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: rack-i18n_best_langs
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
+platform: ruby
+authors: 
+- Gioele Barabucci
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack-i18n_routes
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 959707343
+        segments: 
+        - 0
+        - 3
+        - dev
+        version: 0.3.dev
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bones-rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 39
+        segments: 
+        - 3
+        - 8
+        - 0
+        version: 3.8.0
+  type: :development
+  version_requirements: *id005
+description: |-
+  rack-i18n_best_langs is a Rack middleware component that takes care of
+  understanding what are the best languages for a site visitor.
+email: gioele@svario.it
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .yardopts
+- COPYING
+- README.md
+- Rakefile
+- lib/rack/i18n_best_langs.rb
+- lib/rack/language_tag.rb
+- spec/i18n-best-langs_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gioele/rack-i18n_best_langs
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rack-i18n_best_langs
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: rack-i18n_best_langs is a Rack middleware component that takes care of understanding what are the best languages for a site visitor.
+test_files: []
+