locale_setter 0.1.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2177a5b71ff691ac29241b327d2deaef3456e08e
+  data.tar.gz: 0fbf15da496596204083077d5c622441cd5dcf9c
+SHA512:
+  metadata.gz: ed37ab8f9b5ec6ac8527c8a53ed535d1a4f6ac05b9fa9283c4d9ad67e02da60696fa32c7d3d968578d24523d9fb92ef97bd3c3f04cc6a173949786216efa4763
+  data.tar.gz: da77e1502788c59d1eb1713f0bdf53366795ef5a0f020057364b9383eb4f1be3b40470f407d7cd24a7a37e539c533bd5414fd3e10e007ead9fc161f75fc117cd

data/README.md

@@ -18,7 +18,7 @@ Then execute:
 $ bundle
 ```
 
-### Application Configuration
+### Rails Application Configuration
 
 Include the module in your `app/controllers/application_controller.rb`:
 
@@ -26,11 +26,31 @@ Include the module in your `app/controllers/application_controller.rb`:
 class ApplicationController < ActionController::Base
   protect_from_forgery
 
-  include LocaleSetter
+  include LocaleSetter::Rails
 end
 ```
 
-*Note:* If you have before filters or a module that handles user authentication, have that _above_ the `include LocaleSetter` so it happens first.
+*Note:* If you have before filters or a module that handles user authentication, have that _above_ this new `include` so it happens first.
+
+### Non-Rails Applications
+
+The library can be used outside of Rails by accessing `LocaleSetter::Generic` directly. You need to pass in your I18n class and the data sources, like this:
+
+```
+# Example Input Data
+request = {'HTTP_ACCEPT_LANGUAGE' = 'en,es;0.6'}
+params  = {:locale = 'en'}
+user    = User.first
+i18n    = I18n 
+
+# Set the .locale of I18n
+LocaleSetter::Generic.set_locale(i18n,
+                                {:env => request,
+                                 :params => params,
+                                 :user => user})
+```
+
+The `i18n.locale=` will be called with the local selected from the passed data. `:env`, `:params`, and `:user` are all optional.
 
 ## How It Works
 
@@ -93,8 +113,6 @@ Note that care has been taken to prevent a symbol-table-overflow denial of servi
 
 If your system has authentication, then you likely use have a `current_user` helper method available. `LocaleSetter` will call `locale` on current user, expecting to get back a string response.
 
-It's up to you to compute / store this data.
-
 #### Storing a User Preference
 
 The easiest solution is to add a column to your users table:
@@ -114,6 +132,18 @@ Then, allow them to edit this preference wherever they edit other profile items
 
 Remember that you may need to modify the `user.rb` if you're filtering mass-assignment parameters.
 
+#### Using a Different Method / Column
+
+`LocaleSetter::User` can be configured to call a method other than `.locale` on the user.
+
+Anytime after the library is loaded, like in a Rails initializer, use the `locale_method=` method:
+
+```ruby
+LocaleSetter::User.locale_method = :my_locale
+```
+
+Subsequent calls to `LocaleSetter::User.for` will use the specified method.
+
 ### HTTP Headers
 
 Every request coming into your web server includes a ton of header information. One key/value pair looks like this:

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/locale_setter/generic.rb

@@ -0,0 +1,34 @@
+module LocaleSetter
+  module Generic
+
+    def self.set_locale(i18n, options = {:params => nil,
+                                         :user   => nil,
+                                         :env    => nil})
+
+      i18n.locale = from_params(options[:params], available(i18n))    ||
+                    from_user(options[:user], available(i18n))        ||
+                    from_http(options[:env], available(i18n)) ||
+                    i18n.default_locale
+    end
+
+    def self.available(i18n)
+      i18n.available_locales.map(&:to_s)
+    end
+
+    def self.from_user(user, available)
+      LocaleSetter::User.for(user, available)
+    end
+
+    def self.from_http(env, available)
+      if env && env[HTTP_HEADER]
+        LocaleSetter::HTTP.for(env[HTTP_HEADER], available)
+      end
+    end
+
+    def self.from_params(params, available)
+      if params && params[URL_PARAM]
+        LocaleSetter::Param.for(params[URL_PARAM], available)
+      end
+    end
+  end
+end

data/lib/locale_setter/http.rb

@@ -1,7 +1,7 @@
 module LocaleSetter
   module HTTP
-    def self.for(accept_language)
-      LocaleSetter::Matcher.match(AcceptLanguageParser.parse(accept_language))
+    def self.for(accept_language, available)
+      LocaleSetter::Matcher.match(AcceptLanguageParser.parse(accept_language), available)
     end
 
     module AcceptLanguageParser

data/lib/locale_setter/matcher.rb

@@ -1,8 +1,11 @@
 module LocaleSetter
   module Matcher
-    def self.match(requested, against = available)
-      matched = (sanitize(requested) & against).first
-      matched.to_sym if matched
+    def self.match(requested, against)
+      table = generate_lookup_table(against)
+      matched = (sanitize(requested) & table.keys).first
+      if matched
+        table[matched].to_sym
+      end
     end
 
     def self.sanitize(input)
@@ -17,8 +20,10 @@ module LocaleSetter
       locale.to_s.downcase.strip
     end
 
-    def self.available
-      I18n.available_locales.map(&:to_s)
+    def self.generate_lookup_table(locales)
+      table = {}
+      locales.each { |l| table[sanitize_one(l)] = l}
+      table
     end
   end
 end

data/lib/locale_setter/param.rb

@@ -1,7 +1,7 @@
 module LocaleSetter
   module Param
-    def self.for(param)
-      LocaleSetter::Matcher.match([param])
+    def self.for(param, available)
+      LocaleSetter::Matcher.match([param], available)
     end
   end
 end

data/lib/locale_setter/rails.rb

@@ -1,17 +1,34 @@
 module LocaleSetter
   module Rails
-    attr_accessor :i18n
+    def self.included(controller)
+      controller.before_filter :set_locale
+    end
 
     def default_url_options(options = {})
       if i18n.locale == i18n.default_locale
         options
       else
-        {:locale => i18n.locale}.merge(options)
+        {URL_PARAM => i18n.locale}.merge(options)
+      end
+    end
+
+    def set_locale
+      Generic.set_locale(
+        i18n,
+        {:params => params,
+         :user   => locale_user,
+         :env    => request.env}
+      )
+    end
+
+    def locale_user
+      if respond_to?(:current_user) && current_user
+        current_user
       end
     end
 
     def i18n
-      @i18n ||= I18n
+      I18n
     end
   end
 end

data/lib/locale_setter/user.rb

@@ -1,9 +1,20 @@
 module LocaleSetter
   module User
-    def self.for(user)
-      if user && user.respond_to?(:locale) && user.locale && !user.locale.empty?
-        LocaleSetter::Matcher.match(user.locale)
+    @@user_locale_method = :locale
+
+    def self.for(user, available)
+      if user && user.respond_to?(locale_method) && 
+         user.send(locale_method) && !user.send(locale_method).empty?
+        LocaleSetter::Matcher.match user.send(locale_method), available
       end
     end
+
+    def self.locale_method
+      @@user_locale_method
+    end
+
+    def self.locale_method=(method_name)
+      @@user_locale_method = method_name
+    end
   end
 end

data/lib/locale_setter/version.rb

@@ -1,3 +1,3 @@
 module LocaleSetter
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/locale_setter.rb

@@ -4,38 +4,10 @@ require "locale_setter/rails"
 require "locale_setter/http"
 require "locale_setter/user"
 require "locale_setter/param"
+require "locale_setter/generic"
 
 module LocaleSetter
-  include LocaleSetter::Rails
-
-  def self.included(controller)
-    if controller.respond_to?(:before_filter)
-      controller.before_filter :set_locale
-    end
-  end
-
-  def set_locale
-    i18n.locale = from_params ||
-                  from_user   ||
-                  from_http   ||
-                  i18n.default_locale
-  end
-
-  def from_user
-    if respond_to?(:current_user) && current_user
-      LocaleSetter::User.for(current_user)
-    end
-  end
-
-  def from_http
-    if respond_to?(:request) && request.env && request.env['HTTP_ACCEPT_LANGUAGE']
-      LocaleSetter::HTTP.for(request.env['HTTP_ACCEPT_LANGUAGE'])
-    end
-  end
-
-  def from_params
-    if respond_to?(:params) && params[:locale]
-      LocaleSetter::Param.for(params[:locale])
-    end
-  end
+  HTTP_HEADER = 'HTTP_ACCEPT_LANGUAGE'
+  URL_PARAM   = :locale
+  USER_METHOD = :locale
 end

data/locale_setter.gemspec

@@ -16,4 +16,7 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake", "~>10.0.3"
+  gem.add_development_dependency "rspec", "~>2.13.0"
 end

data/spec/locale/generic_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe LocaleSetter::Generic do
+  let(:setter){ LocaleSetter::Generic }
+  let(:i18n){ I18n }
+
+  describe "#set_locale" do
+    context "with nothing" do
+      it "uses the default" do
+        setter.set_locale(i18n)
+        i18n.locale.should == i18n.default_locale
+      end
+    end
+
+    context "with HTTP headers" do
+      let(:request){ {'HTTP_ACCEPT_LANGUAGE' => "es,en"} }
+
+      it "makes use of the HTTP headers" do
+        i18n.available_locales = [:en, :es]
+        setter.set_locale(i18n, {:env => request})
+        i18n.locale.should == :es
+      end
+
+      it "only sets an available locale" do
+        i18n.available_locales = [:arr, :en]
+        setter.set_locale(i18n, {:env => request})
+        i18n.locale.should == :en
+      end
+
+      it "does nothing when HTTP_ACCEPT_LANGUAGE is missing" do
+        setter.set_locale(i18n, {:env => {}})
+        i18n.locale.should == i18n.default_locale
+      end
+    end
+
+    context "with a current_user who has a locale" do
+      it "uses the stored locale" do
+        i18n.available_locales = [:en, :user_specified]
+        user = OpenStruct.new( {:locale => :user_specified} )
+        setter.set_locale(i18n, {:user => user} )
+        i18n.locale.should == :user_specified
+      end
+    end
+
+    context "with url parameters" do
+      before(:each) do
+        i18n.available_locales = [:en, :param_specified]
+      end
+
+      let(:params){ {:locale => "param_specified"} }
+
+      it "uses the URL parameter" do
+        setter.set_locale(i18n, {:params => params} )
+        i18n.locale.should == :param_specified
+      end
+
+      it "only allows supported locales" do
+        i18n.available_locales = [:en]
+        setter.set_locale(i18n, {:params => params} )
+        i18n.locale.should == i18n.default_locale
+      end
+
+      it "does not pollute the symbol table when given an unsuported locale" do
+        expect { setter.set_locale(i18n, { :params => {:locale => "bad_param"} }) }.
+               to_not change{ Symbol.all_symbols.count }
+      end
+    end
+  end
+end

data/spec/locale/http_spec.rb

@@ -2,41 +2,37 @@ require 'spec_helper'
 
 describe "LocaleSetter::HTTP" do
   describe ".for" do
+    let(:available){ ['en', 'es'] }
+
     context "when the first choice is supported" do
-      before(:each){ I18n.available_locales = [:en, :es] }
-      
       context "given 'en'" do
         it "returns :en" do
-          LocaleSetter::HTTP.for("en").should == :en
+          LocaleSetter::HTTP.for("en", available).should == :en
         end
       end
 
       context "given two acceptable locales" do
         it "returns :en" do
-          LocaleSetter::HTTP.for("en,es").should == :en
+          LocaleSetter::HTTP.for("en,es", available).should == :en
         end
       end
     end
 
     context "when the first choice is not supported" do
-      before(:each){ I18n.available_locales = [:es] }
-      
       context "given 'en,es'" do
         it "returns :es" do
-          LocaleSetter::HTTP.for("en,es").should == :es
+          LocaleSetter::HTTP.for("de,es", available).should == :es
         end
       end
     end
 
     context "when using preference weightings" do
-      before(:each){ I18n.available_locales = [:en, :es] }
-
       it "returns :en" do
-        LocaleSetter::HTTP.for("en;1,es;0.8").should == :en
+        LocaleSetter::HTTP.for("en;1,es;0.8", available).should == :en
       end
 
       it "handles misordered preferences" do
-        LocaleSetter::HTTP.for("es;0.8,en;1").should == :en
+        LocaleSetter::HTTP.for("es;0.8,en;1", available).should == :en
       end
     end
   end

data/spec/locale/matcher_spec.rb

@@ -5,6 +5,10 @@ describe "LocaleSetter::Matcher" do
     LocaleSetter::Matcher.match(['EN-US'],['en-us']).should == :'en-us'
   end
 
+  it "can properly match when the available locales are not all lower case" do
+    LocaleSetter::Matcher.match(['es-CL'],['es-CL']).should == :'es-CL'
+  end
+
   it "can match using a single string" do
     LocaleSetter::Matcher.match('en', ['en']).should == :en
   end

data/spec/locale/rails_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe LocaleSetter::Rails do
+  it "exists" do
+    expect{ LocaleSetter::Rails }.to_not raise_error
+  end
+
+  class BareController
+    def self.before_filter(name); end
+  end
+
+  describe ".included" do
+    it "sets a before filter" do
+      BareController.should_receive(:before_filter).with(:set_locale)
+      BareController.send(:include, LocaleSetter::Rails)
+    end
+
+    it "skips setting the before_filter if not supported" do
+      expect{ BareController.send(:include, LocaleSetter::Rails) }.to_not raise_error
+    end
+  end
+
+  class Controller < BareController
+    include LocaleSetter::Rails
+  end
+
+  let(:controller){ Controller.new }
+
+  before(:each) do
+    controller.i18n.locale = :es
+  end
+
+  describe "#default_url_options" do
+    it "adds a :locale key" do
+      controller.default_url_options({})[:locale].should be
+    end
+
+    it "does not require a parameter" do
+      expect{ controller.default_url_options }.to_not raise_error
+    end
+
+    it "builds on passed in options" do
+      result = controller.default_url_options({:test => true})
+      result[:test].should be
+      result[:locale].should be
+    end
+
+    it "defers to a passed in locale" do
+      result = controller.default_url_options({:locale => 'abc'})
+      result[:locale].should == 'abc'
+    end
+
+    it "doesn't appent a locale if it's the default" do
+      controller.i18n.locale = controller.i18n.default_locale
+      controller.default_url_options({})[:locale].should_not be
+    end
+
+    it "appends a locale when not the default" do
+      controller.i18n.locale = :sample
+      controller.default_url_options({})[:locale].should == :sample
+    end
+  end
+end

data/spec/locale/user_spec.rb

@@ -4,17 +4,30 @@ describe 'LocaleSetter::User' do
   describe '#for' do
     it "ignores a blank stored locale" do
       blank = OpenStruct.new({:locale => ""})
-      LocaleSetter::User.for(blank).should_not be
+      LocaleSetter::User.for(blank, ["default"]).should_not be
     end
 
     it "ignores a stored locale that is not available" do
       invalid = OpenStruct.new({:locale => "woof"})
-      LocaleSetter::User.for(invalid).should_not be
+      LocaleSetter::User.for(invalid, ["default"]).should_not be
     end
 
     it "only tries current_user if it offers a locale" do
       class NoLocaleUser; end
-      LocaleSetter::User.for(NoLocaleUser.new).should_not be
+      LocaleSetter::User.for(NoLocaleUser.new, ["default"]).should_not be
+    end
+
+    it "uses a configurable field name" do
+      class MyLocaleUser
+        def my_locale
+          "arr"
+        end
+      end
+
+      LocaleSetter::User.locale_method = :my_locale
+
+      user = MyLocaleUser.new
+      LocaleSetter::User.for(user, ["arr"]).should == :arr
     end
   end
 end

metadata

@@ -1,16 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: locale_setter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Jeff Casimir
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-20 00:00:00.000000000 Z
-dependencies: []
+date: 2013-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
 description: Automatically set per-request locale in Rails applications
 email:
 - jeff@casimircreative.com
@@ -25,6 +52,7 @@ files:
 - README.md
 - Rakefile
 - lib/locale_setter.rb
+- lib/locale_setter/generic.rb
 - lib/locale_setter/http.rb
 - lib/locale_setter/matcher.rb
 - lib/locale_setter/param.rb
@@ -32,40 +60,41 @@ files:
 - lib/locale_setter/user.rb
 - lib/locale_setter/version.rb
 - locale_setter.gemspec
+- spec/locale/generic_spec.rb
 - spec/locale/http_spec.rb
 - spec/locale/matcher_spec.rb
+- spec/locale/rails_spec.rb
 - spec/locale/user_spec.rb
-- spec/locale_setter_spec.rb
 - spec/spec_helper.rb
 - spec/support/i18n.rb
 homepage: http://github.com/jcasimir/locale_setter
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Automatically set per-request locale in Rails applications
 test_files:
+- spec/locale/generic_spec.rb
 - spec/locale/http_spec.rb
 - spec/locale/matcher_spec.rb
+- spec/locale/rails_spec.rb
 - spec/locale/user_spec.rb
-- spec/locale_setter_spec.rb
 - spec/spec_helper.rb
 - spec/support/i18n.rb

data/spec/locale_setter_spec.rb

@@ -1,172 +0,0 @@
-require 'spec_helper'
-
-describe LocaleSetter do
-  it "exists" do
-    expect{ LocaleSetter }.to_not raise_error
-  end
-
-  class BareController; end
-
-  describe ".included" do
-    it "sets a before filter" do
-      BareController.should_receive(:before_filter).with(:set_locale)
-      BareController.send(:include, LocaleSetter)
-    end
-
-    it "skips setting the before_filter if not supported" do
-      expect{ BareController.send(:include, LocaleSetter) }.to_not raise_error
-    end
-  end
-
-  class Controller
-    include LocaleSetter
-  end
-
-  let(:controller){ Controller.new }
-
-  describe "#default_url_options" do
-    it "adds a :locale key" do
-      controller.default_url_options({})[:locale].should be
-    end
-
-    it "does not require a parameter" do
-      expect{ controller.default_url_options }.to_not raise_error
-    end
-
-    it "builds on passed in options" do
-      result = controller.default_url_options({:test => true})
-      result[:test].should be
-      result[:locale].should be
-    end
-
-    it "defers to a passed in locale" do
-      result = controller.default_url_options({:locale => 'abc'})
-      result[:locale].should == 'abc'
-    end
-
-    it "doesn't appent a locale if it's the default" do
-      controller.i18n.locale = controller.i18n.default_locale
-      controller.default_url_options({})[:locale].should_not be
-    end
-
-    it "appends a locale when not the default" do
-      controller.i18n.locale = :sample
-      controller.default_url_options({})[:locale].should == :sample
-    end
-  end
-
-  describe "#set_locale" do
-    context "with nothing" do
-      let(:controller){ Controller.new }
-
-      it "uses the default" do
-        controller.set_locale
-        controller.i18n.locale.should == controller.i18n.default_locale
-      end
-    end
-
-    context "with HTTP headers" do
-      let(:controller){ HTTPController.new }
-
-      class HTTPController < Controller
-        def request
-          OpenStruct.new(:env => {'HTTP_ACCEPT_LANGUAGE' => "es,en"})
-        end
-      end
-
-      it "makes use of the HTTP headers" do
-        controller.set_locale
-        controller.i18n.locale.should == :es
-      end
-
-      it "only sets an available locale" do
-        I18n.available_locales = [:arr, :en]
-        controller.set_locale
-        controller.i18n.locale.should == :en
-      end
-
-      it "does nothing when HTTP_ACCEPT_LANGUAGE is missing" do
-        class BlankHTTPController < Controller
-          def request
-            OpenStruct.new(:env => {})
-          end
-        end
-        
-        blank = BlankHTTPController.new
-        blank.set_locale.should == blank.i18n.default_locale
-      end
-    end
-
-    context "with a current_user who has a locale" do
-      let(:controller){ UserController.new }  
-
-      before(:each) do
-        controller.i18n.available_locales = [:en, :user_specified]
-      end
-
-      class UserController < HTTPController
-        def current_user
-          OpenStruct.new({:locale => :user_specified})
-        end
-      end
-
-      it "prioritizes the current_user preference over HTTP" do
-        LocaleSetter::HTTP.should_not_receive(:for)
-        controller.set_locale
-      end
-
-      it "uses the stored locale" do
-        controller.set_locale
-        controller.i18n.locale.should == :user_specified
-      end
-    end
-
-    context "with url parameters" do
-      let(:controller){ ParamController.new }
-
-      before(:each) do
-        controller.i18n.available_locales = [:en, :param_specified]
-      end
-
-      class ParamController < Controller
-        def params
-          {:locale => "param_specified"}
-        end
-      end
-
-      it "uses the URL parameter" do
-        controller.set_locale
-        controller.i18n.locale.should == :param_specified
-      end
-
-      it "only allows supported locales" do
-        controller.i18n.available_locales = [:en]
-        controller.set_locale
-        controller.i18n.locale.should == controller.i18n.default_locale
-      end
-
-      it "does not pollute the symbol table when given an unsuported locale" do
-        class BadParamController < Controller
-          def params
-            {:locale => "bad_param"}
-          end
-        end
-        expect { BadParamController.new.set_locale }.to_not change{ Symbol.all_symbols.count }
-      end
-    end
-  end
-
-  describe "#i18n" do
-    it "uses the pre-set i18n library" do
-      stand_in = OpenStruct
-      controller.i18n = stand_in
-      controller.i18n.should == stand_in
-    end
-
-    class I18n; end
-
-    it "uses the default I18n library when not overridden" do
-      controller.i18n.should == I18n
-    end
-  end
-end