http_accept_language 1.0.2 → 2.0.0.pre

data/.gitignore

@@ -3,3 +3,5 @@
 Gemfile.lock
 pkg/*
 .rvmrc
+log/*.log
+tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -1,4 +1,3 @@
-source "http://rubygems.org"
+source :rubygems
 
-# Specify your gem's dependencies in http_accept_language.gemspec
 gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+guard 'rspec', :cli => "-fd", :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,101 @@
+# HttpAcceptLanguage
+
+A small effort in making a plugin which helps you detect the users preferred language, as sent by the HTTP header.
+
+Since version 2.0, this gem is Rack middleware.
+
+## Features
+
+* Splits the http-header into languages specified by the user
+* Returns empty array if header is illformed.
+* Corrects case to xx-XX
+* Sorted by priority given, as much as possible.
+* Gives you the most important language
+* Gives compatible languages
+
+See also: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+
+## Example
+
+When using in Rails:
+
+``` ruby
+class SomeController < ApplicationController
+
+  def some_action
+
+    http_accept_language.user_preferred_languages # => [ 'nl-NL', 'nl-BE', 'nl', 'en-US', 'en' ]
+    available = %w{en en-US nl-BE}
+    http_accept_language.preferred_language_from(available) # => 'nl-BE'
+
+    http_accept_language.user_preferred_languages # => [ 'en-GB']
+    available = %w{en-US}
+    http_accept_language.compatible_language_from(available) # => 'en-US'
+
+  end
+
+end
+```
+
+Older versions of Rails (pre 3.0) might need to include the middleware manually.
+
+Usage in any Rack application, simple add the middleware:
+
+``` ruby
+require 'http_accept_language'
+use HttpAcceptLanguage::Middleware
+run YourAwesomeApp
+```
+
+Then you can access it:
+
+``` ruby
+class YourAwesomeApp
+
+  def self.call(env)
+    available = %w(en en-US nl-BE)
+    language = env.http_accept_language.preferred_language_from(available)
+    [ 200, {}, ["Oh, you speak #{language}!"]]
+  end
+
+end
+```
+
+## Available methods
+
+* **user_preferred_languages**:
+  Returns a sorted array based on user preference in HTTP_ACCEPT_LANGUAGE, sanitized and all.
+* **preferred_language_from**:
+  Finds the locale specifically requested by the browser
+* **compatible_language_from**:
+  Returns the first of the user_preferred_languages that is compatible with the available locales.
+  Ignores region.
+* **sanitize_available_locales**:
+  Returns a supplied list of available locals without any extra application info
+  that may be attached to the locale for storage in the application.
+* **language_region_compatible_from**:
+  Returns the first of the user preferred languages that is
+  also found in available languages.  Finds best fit by matching on
+  primary language first and secondarily on region.  If no matching region is
+  found, return the first language in the group matching that primary language.
+
+## Installation
+
+
+### Without Bundler
+
+Install the gem `http_accept_language`
+
+### With Bundler
+
+Add the gem to your Gemfile:
+
+``` ruby
+gem 'http_accept_language'
+```
+
+Run `bundle install` to install it.
+
+---
+
+Released under the MIT license

data/Rakefile

@@ -1,22 +1,13 @@
 require "bundler/gem_tasks"
 
-require 'rake/testtask'
-desc 'Test the http_accept_language plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
-desc 'Default: run unit tests.'
-task :default => :test
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:cucumber)
 
-require 'rake/rdoctask'
-desc 'Generate documentation for the http_accept_language plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'HttpAcceptLanguage'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+Cucumber::Rake::Task.new(:wip, "Run features tagged with @wip") do |t|
+  t.profile = "wip"
 end
+
+task :default => [:spec, :cucumber, :wip]

data/cucumber.yml

@@ -0,0 +1,2 @@
+default: --format progress --strict --tags ~@wip
+wip: --format pretty --wip --tags @wip

data/features/rails_integration.feature

@@ -0,0 +1,29 @@
+@rails
+Feature: Rails Integration
+
+  To use http_accept_language inside a Rails application, just add it to your
+  Gemfile and run `bundle install`.
+
+  It is automatically added to your middleware.
+
+  Scenario: Installing
+    When I generate a new Rails app
+    And I add http_accept_language to my Gemfile
+    And I run `rake middleware`
+    Then the output should contain "use HttpAcceptLanguage::Middleware"
+
+  Scenario: Using
+    Given I have installed http_accept_language
+    When I generate the following controller:
+    """
+    class LanguagesController < ApplicationController
+
+      def index
+        languages = http_accept_language.user_preferred_languages
+        render :text => "Languages: #{languages.join(' : ')}"
+      end
+
+    end
+    """
+    When I access that action with the HTTP_ACCEPT_LANGUAGE header "en-us,en-gb;q=0.8,en;q=0.6,es-419"
+    Then the response should contain "Languages: en-US : es-419 : en-GB : en"

data/features/steps/rails.rb

@@ -0,0 +1,37 @@
+Before "@rails" do
+  @rails = RailsDriver.new
+end
+
+When /^I generate a new Rails app$/ do
+  @rails.generate_rails
+end
+
+When /^I add http_accept_language to my Gemfile$/ do
+  @rails.append_gemfile
+end
+
+Given /^I have installed http_accept_language$/ do
+  @rails.install_gem
+end
+
+When /^I generate the following controller:$/ do |string|
+  @rails.generate_controller "languages", string
+end
+
+When /^I access that action with the HTTP_ACCEPT_LANGUAGE header "(.*?)"$/ do |header|
+  @rails.with_rails_running do
+    @rails.request_with_http_accept_language_header(header, "/languages")
+  end
+end
+
+Then /^the response should contain "(.*?)"$/ do |output|
+  @rails.output_should_contain(output)
+end
+
+When /^I run `rake middleware`$/ do
+  @rails.bundle_exec("rake middleware")
+end
+
+Then /^the output should contain "(.*?)"$/ do |expected|
+  @rails.assert_partial_output(expected, @rails.all_output)
+end

data/features/support/rails_driver.rb

@@ -0,0 +1,93 @@
+require 'aruba/api'
+
+class RailsDriver
+  include Aruba::Api
+
+  def initialize
+    @aruba_io_wait_seconds = 10
+    # @announce_stdout = true
+    # @announce_stderr = true
+    # @announce_cmd = true
+    # @announce_dir = true
+    # @announce_env = true
+  end
+
+  def app_name
+    "foobar"
+  end
+
+  def install_gem
+    if app_exists?
+      cd app_name
+    else
+      generate_rails
+      append_gemfile
+    end
+  end
+
+  def app_exists?
+    in_current_dir do
+      File.exist?("#{app_name}/Gemfile")
+    end
+  end
+
+  def bundle_exec(cmd)
+    run_simple "bundle exec #{cmd}"
+  end
+
+  def generate_rails
+    # install rails with as few things as possible, for speed!
+    bundle_exec "rails new #{app_name} --force --skip-git --skip-active-record --skip-sprockets --skip-javascript --skip-test-unit --old-style-hash"
+    cd app_name
+  end
+
+  def append_gemfile
+    # Specifiy a path so cucumber will use the unreleased version of the gem
+    append_to_file "Gemfile", "gem 'http_accept_language', :path => '#{gem_path}'"
+  end
+
+  def gem_path
+    File.expand_path('../../../', __FILE__)
+  end
+
+  def generate_controller(name, content)
+    bundle_exec "rails generate resource #{name} --force"
+    write_file "app/controllers/#{name}_controller.rb", content
+  end
+
+  def request_with_http_accept_language_header(header, path)
+    run_simple "curl  --retry 10 -H 'Accept-language: #{header}' #{File.join(host, path)} -o #{response}"
+    run_simple "cat out.html"
+  end
+
+  def host
+    "http://localhost:13000"
+  end
+
+  def with_rails_running
+    start_rails
+    yield
+  ensure
+    stop_rails
+  end
+
+  def start_rails
+    bundle_exec "rails server -p 13000 -d"
+  end
+
+  def stop_rails
+    in_current_dir do
+      `cat tmp/pids/server.pid | xargs kill -9`
+    end
+  end
+
+  def response
+    File.expand_path(File.join(current_dir, 'out.html'))
+  end
+
+  def output_should_contain(expected)
+    actual = File.open(response, 'r:utf-8').read
+    actual.should include expected
+  end
+
+end

data/http_accept_language.gemspec

@@ -1,7 +1,9 @@
 # -*- encoding: utf-8 -*-
+require File.expand_path('../lib/http_accept_language/version', __FILE__)
+
 Gem::Specification.new do |s|
   s.name        = "http_accept_language"
-  s.version     = '1.0.2'
+  s.version     = HttpAcceptLanguage::VERSION
   s.authors     = ["iain"]
   s.email       = ["iain@iain.nl"]
   s.homepage    = "https://github.com/iain/http_accept_language"
@@ -14,4 +16,12 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'rails', '>= 3.2.6'
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'aruba'
 end

data/lib/http_accept_language.rb

@@ -1,65 +1,4 @@
-module HttpAcceptLanguage
-
-  # Returns a sorted array based on user preference in HTTP_ACCEPT_LANGUAGE.
-  # Browsers send this HTTP header, so don't think this is holy.
-  #
-  # Example:
-  #
-  #   request.user_preferred_languages
-  #   # => [ 'nl-NL', 'nl-BE', 'nl', 'en-US', 'en' ]
-  #
-  def user_preferred_languages
-    @user_preferred_languages ||= env['HTTP_ACCEPT_LANGUAGE'].split(/\s*,\s*/).collect do |l|
-      l += ';q=1.0' unless l =~ /;q=\d+\.\d+$/
-      l.split(';q=')
-    end.sort do |x,y|
-      raise "Not correctly formatted" unless x.first =~ /^[a-z\-]+$/i
-      y.last.to_f <=> x.last.to_f
-    end.collect do |l|
-      l.first.downcase.gsub(/-[a-z]+$/i) { |x| x.upcase }
-    end
-  rescue # Just rescue anything if the browser messed up badly.
-    []
-  end
-
-  # Sets the user languages preference, overiding the browser
-  #
-  def user_preferred_languages=(languages)
-    @user_preferred_languages = languages
-  end
-
-  # Finds the locale specifically requested by the browser.
-  #
-  # Example:
-  #
-  #   request.preferred_language_from I18n.available_locales
-  #   # => 'nl'
-  #
-  def preferred_language_from(array)
-    (user_preferred_languages & array.collect { |i| i.to_s }).first
-  end
-
-  # Returns the first of the user_preferred_languages that is compatible
-  # with the available locales. Ignores region.
-  #
-  # Example:
-  #
-  #   request.compatible_language_from I18n.available_locales
-  #
-  def compatible_language_from(available_languages)
-    user_preferred_languages.map do |x| #en-US
-      available_languages.find do |y| # en
-        y = y.to_s
-        x == y || x.split('-', 2).first == y.split('-', 2).first
-      end
-    end.compact.first
-  end
-
-end
-if defined?(ActionDispatch::Request)
-  ActionDispatch::Request.send :include, HttpAcceptLanguage
-elsif defined?(ActionDispatch::AbstractRequest)
-  ActionDispatch::AbstractRequest.send :include, HttpAcceptLanguage
-elsif defined?(ActionDispatch::CgiRequest)
-  ActionDispatch::CgiRequest.send :include, HttpAcceptLanguage
-end
+require 'http_accept_language/version'
+require 'http_accept_language/parser'
+require 'http_accept_language/middleware'
+require 'http_accept_language/railtie' if defined?(Rails::Railtie)

data/lib/http_accept_language/middleware.rb

@@ -0,0 +1,16 @@
+module HttpAcceptLanguage
+  class Middleware
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      def env.http_accept_language
+        @http_accept_language ||= Parser.new(self['HTTP_ACCEPT_LANGUAGE'])
+      end
+      @app.call(env)
+    end
+
+  end
+end

data/lib/http_accept_language/parser.rb

@@ -0,0 +1,104 @@
+module HttpAcceptLanguage
+
+  class Parser
+
+    attr_accessor :header
+
+    def initialize(header)
+      @header = header
+    end
+
+    # Returns a sorted array based on user preference in HTTP_ACCEPT_LANGUAGE.
+    # Browsers send this HTTP header, so don't think this is holy.
+    #
+    # Example:
+    #
+    #   request.user_preferred_languages
+    #   # => [ 'nl-NL', 'nl-BE', 'nl', 'en-US', 'en' ]
+    #
+    def user_preferred_languages
+      @user_preferred_languages ||= header.split(/\s*,\s*/).collect do |l|
+        l += ';q=1.0' unless l =~ /;q=\d+\.\d+$/
+          l.split(';q=')
+      end.sort do |x,y|
+        raise "Not correctly formatted" unless x.first =~ /^[a-z\-0-9]+$/i
+        y.last.to_f <=> x.last.to_f
+      end.collect do |l|
+        l.first.downcase.gsub(/-[a-z0-9]+$/i) { |x| x.upcase }
+      end
+    rescue # Just rescue anything if the browser messed up badly.
+      []
+    end
+
+    # Sets the user languages preference, overiding the browser
+    #
+    def user_preferred_languages=(languages)
+      @user_preferred_languages = languages
+    end
+
+    # Finds the locale specifically requested by the browser.
+    #
+    # Example:
+    #
+    #   request.preferred_language_from I18n.available_locales
+    #   # => 'nl'
+    #
+    def preferred_language_from(array)
+      (user_preferred_languages & array.collect { |i| i.to_s }).first
+    end
+
+    # Returns the first of the user_preferred_languages that is compatible
+    # with the available locales. Ignores region.
+    #
+    # Example:
+    #
+    #   request.compatible_language_from I18n.available_locales
+    #
+    def compatible_language_from(available_languages)
+      user_preferred_languages.map do |x| #en-US
+        available_languages.find do |y| # en
+          y = y.to_s
+          x == y || x.split('-', 2).first == y.split('-', 2).first
+        end
+      end.compact.first
+    end
+
+    # Returns a supplied list of available locals without any extra application info
+    # that may be attached to the locale for storage in the application.
+    #
+    # Example:
+    # [ja_JP-x1, en-US-x4, en_UK-x5, fr-FR-x3] => [ja-JP, en-US, en-UK, fr-FR]
+    #
+    def sanitize_available_locales(available_languages)
+      available_languages.map do |avail|
+        split_locale = avail.split(/[_-]/)
+
+        split_locale.map do |e|
+          e unless e.match(/x|[0-9*]/)
+        end.compact.join("-")
+      end
+    end
+
+    # Returns the first of the user preferred languages that is
+    # also found in available languages.  Finds best fit by matching on
+    # primary language first and secondarily on region.  If no matching region is
+    # found, return the first language in the group matching that primary language.
+    #
+    # Example:
+    #
+    #   request.language_region_compatible(available_languages)
+    #
+    def language_region_compatible_from(available_languages)
+      available_languages = sanitize_available_locales(available_languages)
+      user_preferred_languages.map do |x| #en-US
+        lang_group = available_languages.select do |y| # en
+          y = y.to_s
+          x.split('-', 2).first == y.split('-', 2).first
+        end
+        lang_group.find{|l| l == x} || lang_group.first #en-US, en-UK
+      end.compact.first
+    end
+
+  end
+
+end

data/lib/http_accept_language/railtie.rb

@@ -0,0 +1,17 @@
+module HttpAcceptLanguage
+  class Railtie < ::Rails::Railtie
+
+    initializer "http_accept_language.add_middleware" do |app|
+      app.middleware.use Middleware
+      ApplicationController.send :include, EasyAccess
+    end
+
+  end
+
+  module EasyAccess
+    def http_accept_language
+      env.http_accept_language
+    end
+  end
+
+end

data/lib/http_accept_language/version.rb

@@ -0,0 +1,3 @@
+module HttpAcceptLanguage
+  VERSION = '2.0.0.pre'
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,49 @@
+require 'http_accept_language'
+require 'rack/test'
+require 'json'
+
+class TestRackApp
+
+  def call(env)
+    request = Rack::Request.new(env)
+    http_accept_language = env.http_accept_language
+    result = {
+      :user_preferred_languages => http_accept_language.user_preferred_languages,
+    }
+    if request.params['preferred']
+      result[:preferred_language_from] = http_accept_language.preferred_language_from(request.params['preferred'])
+    end
+    [ 200, {}, [ JSON.generate(result) ]]
+  end
+
+end
+
+describe "Rack integration" do
+  include Rack::Test::Methods
+
+  def app
+    Rack::Builder.new do
+      use HttpAcceptLanguage::Middleware
+      run TestRackApp.new
+    end.to_app
+  end
+
+  it "decodes the HTTP_ACCEPT_LANGUAGE header" do
+    request_with_header 'en-us,en-gb;q=0.8,en;q=0.6,es-419'
+    r['user_preferred_languages'].should eq %w{en-US es-419 en-GB en}
+  end
+
+  it "finds the first available language" do
+    request_with_header 'en-us,en-gb;q=0.8,en;q=0.6,es-419', :preferred => %w(en en-GB)
+    r['preferred_language_from'].should eq 'en-GB'
+  end
+
+  def request_with_header(header, params = {})
+    get "/", params, 'HTTP_ACCEPT_LANGUAGE' => header
+  end
+
+  def r
+    JSON.parse(last_response.body)
+  end
+
+end

data/spec/parser_spec.rb

@@ -0,0 +1,51 @@
+require 'http_accept_language/parser'
+
+describe HttpAcceptLanguage::Parser do
+
+  def parser
+    @parser ||= HttpAcceptLanguage::Parser.new('en-us,en-gb;q=0.8,en;q=0.6,es-419')
+  end
+
+  it "should return empty array" do
+    parser.header = nil
+    parser.user_preferred_languages.should eq []
+  end
+
+  it "should properly split" do
+    parser.user_preferred_languages.should eq %w{en-US es-419 en-GB en}
+  end
+
+  it "should ignore jambled header" do
+    parser.header = 'odkhjf89fioma098jq .,.,'
+    parser.user_preferred_languages.should eq []
+  end
+
+  it "should find first available language" do
+    parser.preferred_language_from(%w{en en-GB}).should eq "en-GB"
+  end
+
+  it "should find first compatible language" do
+    parser.compatible_language_from(%w{en-hk}).should eq "en-hk"
+    parser.compatible_language_from(%w{en}).should eq "en"
+  end
+
+  it "should find first compatible from user preferred" do
+    parser.header = 'en-us,de-de'
+    parser.compatible_language_from(%w{de en}).should eq 'en'
+  end
+
+  it "should accept symbols as available languages" do
+    parser.header = 'en-us'
+    parser.compatible_language_from([:"en-HK"]).should eq :"en-HK"
+  end
+
+  it "should sanitize available language names" do
+    parser.sanitize_available_locales(%w{en_UK-x3 en-US-x1 ja_JP-x2 pt-BR-x5}).should eq ["en-UK", "en-US", "ja-JP", "pt-BR"]
+  end
+
+  it "should find most compatible language from user preferred" do
+    parser.header = 'ja,en-gb,en-us,fr-fr'
+    parser.language_region_compatible_from(%w{en-UK en-US ja-JP}).should eq "ja-JP"
+  end
+
+end

metadata

@@ -1,16 +1,128 @@
 --- !ruby/object:Gem::Specification
 name: http_accept_language
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 2.0.0.pre
+  prerelease: 6
 platform: ruby
 authors:
 - iain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-11 00:00:00.000000000Z
-dependencies: []
+date: 2012-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Find out which locale the user preferes by reading the languages they
   specified in their browser
 email:
@@ -20,13 +132,23 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
-- README.rdoc
+- Guardfile
+- README.md
 - Rakefile
+- cucumber.yml
+- features/rails_integration.feature
+- features/steps/rails.rb
+- features/support/rails_driver.rb
 - http_accept_language.gemspec
 - lib/http_accept_language.rb
-- rails/init.rb
-- test/http_accept_language_test.rb
+- lib/http_accept_language/middleware.rb
+- lib/http_accept_language/parser.rb
+- lib/http_accept_language/railtie.rb
+- lib/http_accept_language/version.rb
+- spec/middleware_spec.rb
+- spec/parser_spec.rb
 homepage: https://github.com/iain/http_accept_language
 licenses: []
 post_install_message: 
@@ -42,15 +164,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: http_accept_language
-rubygems_version: 1.8.6
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Find out which locale the user preferes by reading the languages they specified
   in their browser
 test_files:
-- test/http_accept_language_test.rb
+- features/rails_integration.feature
+- features/steps/rails.rb
+- features/support/rails_driver.rb
+- spec/middleware_spec.rb
+- spec/parser_spec.rb

data/README.rdoc

@@ -1,45 +0,0 @@
-= HttpAcceptLanguage
-
-A small effort in making a plugin which helps you detect the users preferred language, as sent by the HTTP header.
-
-== Features
-
-* Splits the http-header into languages specified by the user
-* Returns empty array if header is illformed.
-* Corrects case to xx-XX
-* Sorted by priority given, as much as possible.
-* Gives you the most important language
-* Gives compatible languages
-See also: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
-
-== Example
-
-  class SomeController < ApplicationController
-    def some_action
-
-      request.user_preferred_languages
-      # => [ 'nl-NL', 'nl-BE', 'nl', 'en-US', 'en' ]
-
-      available = %w{en en-US nl-BE}
-      request.preferred_language_from(available)
-      # => 'nl-BE'
-
-      request.user_preferred_languages
-      # => [ 'en-GB']
-      available = %w{en-US}
-      request.compatible_language_from(available)
-      # => 'en-US'
-    end
-  end
-
-== Installation
-
-Install the gem +http_accept_language+, require it in your Rails app.
-
-== Changelog
-
-* 2011-09-11: 1.0.2 release, still works appearantly
-* 2010-01-05: Gem release
-* 2009-03-12: Rails 2.3 compatible
-
-Copyright (c) 2008-2011 Iain Hecker, released under the MIT license

data/rails/init.rb

@@ -1 +0,0 @@
-require "http_accept_language"

data/test/http_accept_language_test.rb

@@ -1,50 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'http_accept_language'
-require 'test/unit'
-
-class MockedCgiRequest
-  include HttpAcceptLanguage
-  def env
-    @env ||= {'HTTP_ACCEPT_LANGUAGE' => 'en-us,en-gb;q=0.8,en;q=0.6'}
-  end
-end
-
-class HttpAcceptLanguageTest < Test::Unit::TestCase
-  def test_should_return_empty_array
-    request.env['HTTP_ACCEPT_LANGUAGE'] = nil
-    assert_equal [], request.user_preferred_languages
-  end
-
-  def test_should_properly_split
-    assert_equal %w{en-US en-GB en}, request.user_preferred_languages
-  end
-
-  def test_should_ignore_jambled_header
-    request.env['HTTP_ACCEPT_LANGUAGE'] = 'odkhjf89fioma098jq .,.,'
-    assert_equal [], request.user_preferred_languages
-  end
-
-  def test_should_find_first_available_language
-    assert_equal 'en-GB', request.preferred_language_from(%w{en en-GB})
-  end
-
-  def test_should_find_first_compatible_language
-    assert_equal 'en-hk', request.compatible_language_from(%w{en-hk})
-    assert_equal 'en', request.compatible_language_from(%w{en})
-  end
-
-  def test_should_find_first_compatible_from_user_preferred
-    request.env['HTTP_ACCEPT_LANGUAGE'] = 'en-us,de-de'
-    assert_equal 'en', request.compatible_language_from(%w{de en})
-  end
-  
-  def test_should_accept_symbols_as_available_languages
-    request.env['HTTP_ACCEPT_LANGUAGE'] = 'en-us'
-    assert_equal :"en-HK", request.compatible_language_from([:"en-HK"])
-  end
-
-  private
-  def request
-    @request ||= MockedCgiRequest.new
-  end
-end