simonmenke-globalize2 0.0.1

data/lib/globalize/translation.rb

@@ -0,0 +1,32 @@
+module Globalize
+  # Translations are simple value objects that carry some context information
+  # alongside the actual translation string.
+
+  class Translation < String
+    class Attribute < Translation
+      attr_accessor :requested_locale, :locale, :key
+    end
+    
+    class Static < Translation
+      attr_accessor :requested_locale, :locale, :key, :options, :plural_key, :original
+      
+      def initialize(string, meta = nil)
+        self.original = string
+        super
+      end
+    end
+    
+    def initialize(string, meta = nil)
+      set_meta meta
+      super string
+    end
+  
+    def fallback?
+      locale.to_sym != requested_locale.to_sym
+    end
+    
+    def set_meta(meta)
+      meta.each {|name, value| send :"#{name}=", value } if meta
+    end
+  end
+end

data/lib/locale/root.yml

@@ -0,0 +1,3 @@
+root:
+  bidi:
+    direction: left-to-right

data/lib/rails_edge_load_path_patch.rb

@@ -0,0 +1,40 @@
+module I18n
+  @@load_path = nil
+  @@default_locale = :'en-US'
+  
+  class << self
+    def load_path
+      @@load_path ||= []
+    end
+    
+    def load_path=(load_path)
+      @@load_path = load_path
+    end
+  end
+end
+
+I18n::Backend::Simple.module_eval do
+  def initialized?
+    @initialized ||= false
+  end
+  
+  protected
+
+    def init_translations
+      load_translations(*I18n.load_path)
+      @initialized = true
+    end
+    
+    def lookup(locale, key, scope = [])
+      return unless key
+      init_translations unless initialized?
+      keys = I18n.send :normalize_translation_keys, locale, key, scope
+      keys.inject(translations){|result, k| result[k.to_sym] or return nil }
+    end
+end
+
+rails_dir = File.expand_path "#{File.dirname(__FILE__)}/../../../rails/"
+paths = %w(actionpack/lib/action_view/locale/en-US.yml 
+           activerecord/lib/active_record/locale/en-US.yml
+           activesupport/lib/active_support/locale/en-US.yml)
+paths.each{|path| I18n.load_path << "#{rails_dir}/#{path}" }

data/notes.textile

@@ -0,0 +1,51 @@
+Stopped DB Backend in the middle, here's where we left off:
+
+h1. Some Notes
+
+* Started doing the migration generator in generators/db_backend.rb
+* Translation keys will be in dotted string format
+* Question: Do we need a plural_key column, or can we build it in to the dotted key?
+* We will probably have to code the following methods from scratch, to optimize db calls:
+** translate
+** localize
+** pluralize
+* We should refactor @interpolation@ code so that it can be included into backend code without inheriting SimpleBackend
+** Rationale: interpolation is something done entirely after a string is fetched from the data store
+** Alternately, it could be done from within the I18n module
+
+h1. Schema
+
+There will be two db tables. 
+
+# globalize_translations will have: locale, key, translation, created_at, updated_at.
+# globalize_translations_map will have: key, translation_id.
+
+globalize_translations_map will let us easily fetch entire sub-trees of namespaces. 
+However, this table may not be necessary, as it may be feasible to just use key LIKE "some.namespace.%".
+
+h1. Caching
+
+We'll almost certainly want to implement caching in the backend. Should probably be a customized
+implementation based on the Rails caching mechanism, to support memcached, etc.
+
+h1. Queries
+
+We'll want to pull in lots of stuff at once and return a single translation based on some
+quick Ruby selection. The query will look something like this:
+
+<pre>
+<code>
+SELECT * FROM globalize_translations
+WHERE locale in (<fallbacks>) AND
+key IN (key, default_key)
+</code>
+</pre>
+
+The Ruby code would then pick the first translation that satisfies a fallback, in fallback order. 
+Of course, the records with the supplied key would take precedence of those with the default key.
+
+h1. Misc
+
+We should revisit the :zero plural code. On the one hand it's certainly useful for 
+many apps in many languages. On the other hand it's not mentioned in CLDR, and not a real
+concept in language pluralization. Right now, I'm feeling it's still a good idea to keep it in. 

data/rails/init.rb

@@ -0,0 +1,9 @@
+require 'rails_edge_load_path_patch.rb' unless I18n.respond_to?(:load_path)
+
+ActiveRecord::Base.send :include, Globalize::Model::ActiveRecord::Translated
+
+I18n.backend = Globalize::Backend::Static.new
+
+I18n.load_path = Globalize::LoadPath.new I18n.load_path
+I18n.load_path << "#{File.dirname(__FILE__)}/lib/locale"
+I18n.load_path << "#{RAILS_ROOT}/lib/locale"

data/test/backends/chained_test.rb

@@ -0,0 +1,175 @@
+require File.join( File.dirname(__FILE__), '..', 'test_helper' )
+require 'globalize/backend/chain'
+
+module Globalize
+  module Backend
+    class Dummy
+      def translate(locale, key, options = {})
+      end
+    end
+  end
+end
+
+class ChainedTest < ActiveSupport::TestCase
+  
+  test "instantiates a chained backend and sets test as backend" do
+    assert_nothing_raised { I18n.chain_backends }
+    assert_instance_of Globalize::Backend::Chain, I18n.backend
+  end
+  
+  test "passes all given arguments to the chained backends #initialize method" do
+    Globalize::Backend::Chain.expects(:new).with(:spec, :simple)
+    I18n.chain_backends :spec, :simple
+  end
+
+  test "passes all given arguments to #add assuming that they are backends" do
+    # no idea how to spec that
+  end
+end
+
+class AddChainedTest < ActiveSupport::TestCase
+  def setup
+    I18n.backend = Globalize::Backend::Chain.new  
+  end
+  
+  test "accepts an instance of a backend" do
+    assert_nothing_raised { I18n.backend.add Globalize::Backend::Dummy.new }
+    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
+  end
+
+  test "accepts a class and instantiates the backend" do
+    assert_nothing_raised { I18n.backend.add Globalize::Backend::Dummy }
+    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
+  end
+
+  test "accepts a symbol, constantizes test as a backend class and instantiates the backend" do
+    assert_nothing_raised { I18n.backend.add :dummy }
+    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
+  end
+
+  test "accepts any number of backend instances, classes or symbols" do
+    assert_nothing_raised { I18n.backend.add Globalize::Backend::Dummy.new, Globalize::Backend::Dummy, :dummy }
+    assert_instance_of Globalize::Backend::Dummy, I18n.backend.send(:backends).first
+    assert_equal [ Globalize::Backend::Dummy, Globalize::Backend::Dummy, Globalize::Backend::Dummy ], 
+      I18n.backend.send(:backends).map{|backend| backend.class }
+  end
+  
+end
+
+class TranslateChainedTest < ActiveSupport::TestCase
+  def setup
+    I18n.locale = :en
+    I18n.backend = Globalize::Backend::Chain.new
+    @first_backend = I18n::Backend::Simple.new
+    @last_backend = I18n::Backend::Simple.new
+    I18n.backend.add @first_backend
+    I18n.backend.add @last_backend
+  end
+
+  test "delegates #translate to all backends in the order they were added" do
+    @first_backend.expects(:translate).with(:en, :foo, {})
+    @last_backend.expects(:translate).with(:en, :foo, {})
+    I18n.translate :foo
+  end
+
+  test "returns the result from #translate from the first backend if test's not nil" do
+    @first_backend.store_translations :en, {:foo => 'foo from first backend'}
+    @last_backend.store_translations :en, {:foo => 'foo from last backend'}
+    result = I18n.translate :foo
+    assert_equal 'foo from first backend', result
+  end
+
+  test "returns the result from #translate from the second backend if the first one returned nil" do
+    @first_backend.store_translations :en, {}
+    @last_backend.store_translations :en, {:foo => 'foo from last backend'}
+    result = I18n.translate :foo
+    assert_equal 'foo from last backend', result
+  end
+
+  test "looks up a namespace from all backends and merges them (if a result is a hash and no count option is present)" do
+    @first_backend.store_translations :en, {:foo => {:bar => 'bar from first backend'}}
+    @last_backend.store_translations :en, {:foo => {:baz => 'baz from last backend'}}
+    result = I18n.translate :foo
+    assert_equal( {:bar => 'bar from first backend', :baz => 'baz from last backend'}, result )
+  end
+
+  test "raises a MissingTranslationData exception if no translation was found" do
+    assert_raise( I18n::MissingTranslationData ) { I18n.translate :not_here, :raise => true }
+  end
+
+  test "raises an InvalidLocale exception if the locale is nil" do
+    assert_raise( I18n::InvalidLocale ) { Globalize::Backend::Chain.new.translate nil, :foo }
+  end
+
+  test "bulk translates a number of keys from different backends" do
+    @first_backend.store_translations :en, {:foo => 'foo from first backend'}
+    @last_backend.store_translations :en, {:bar => 'bar from last backend'}
+    result = I18n.translate [:foo, :bar]
+    assert_equal( ['foo from first backend', 'bar from last backend'], result )
+  end
+
+  test "still calls #translate on all the backends" do
+    @last_backend.expects :translate
+    I18n.translate :not_here, :default => 'default'
+  end
+
+  test "returns a given default string when no backend returns a translation" do
+    result = I18n.translate :not_here, :default => 'default'
+    assert_equal 'default', result
+  end
+
+end
+
+class CustomLocalizeBackend < I18n::Backend::Simple
+  def localize(locale, object, format = :default)
+    "result from custom localize backend" if locale == 'custom'
+  end
+end
+
+class LocalizeChainedTest < ActiveSupport::TestCase
+  def setup
+    I18n.locale = :en
+    I18n.backend = Globalize::Backend::Chain.new
+    @first_backend = CustomLocalizeBackend.new
+    @last_backend = I18n::Backend::Simple.new
+    I18n.backend.add @first_backend
+    I18n.backend.add @last_backend
+    @time = Time.now
+  end
+
+  test "delegates #localize to all backends in the order they were added" do
+    @first_backend.expects(:localize).with(:en, @time, :default)
+    @last_backend.expects(:localize).with(:en, @time, :default)
+    I18n.localize @time
+  end
+
+  test "returns the result from #localize from the first backend if test's not nil" do
+    @last_backend.expects(:localize).never
+    result = I18n.localize @time, :locale => 'custom'
+    assert_equal 'result from custom localize backend', result
+  end
+
+  test "returns the result from #localize from the second backend if the first one returned nil" do
+    @last_backend.expects(:localize).returns "value from last backend"
+    result = I18n.localize @time
+    assert_equal 'value from last backend', result
+  end
+end
+
+class NamespaceChainedTest < ActiveSupport::TestCase
+  def setup
+    @backend = Globalize::Backend::Chain.new
+  end
+  
+  test "returns false if the given result is not a Hash" do
+    assert !@backend.send(:namespace_lookup?, 'foo', {})
+  end
+
+  test "returns false if a count option is present" do
+    assert !@backend.send(:namespace_lookup?, {:foo => 'foo'}, {:count => 1})
+  end
+
+  test "returns true if the given result is a Hash AND no count option is present" do
+    assert @backend.send(:namespace_lookup?, {:foo => 'foo'}, {})
+  end  
+end

data/test/backends/pluralizing_test.rb

@@ -0,0 +1,63 @@
+require File.join( File.dirname(__FILE__), '..', 'test_helper' )
+require 'globalize/backend/pluralizing'
+
+class PluralizingTest < ActiveSupport::TestCase
+  def setup
+    @backend = Globalize::Backend::Pluralizing.new
+    @cz_pluralizer = lambda{|c| c == 1 ? :one : (2..4).include?(c) ? :few : :other }
+  end
+
+  test "#pluralizer returns the pluralizer for a given locale if defined" do
+    assert_instance_of Proc, @backend.pluralizer(:en)
+  end
+  
+  test "#pluralizer returns the default pluralizer if no pluralizer is defined for the given locale" do
+    assert_equal @backend.pluralizer(:en), @backend.pluralizer(:de) 
+  end
+  
+  test "#add_pluralizer allows to store a pluralizer per locale" do
+    assert_nothing_raised { @backend.add_pluralizer(:cz, @cz_pluralizer) }
+    assert_equal @cz_pluralizer, @backend.pluralizer(:cz) 
+  end
+
+end
+
+class PluralizePluralizingTest < ActiveSupport::TestCase
+  def setup
+    @backend = Globalize::Backend::Pluralizing.new
+    @cz_pluralizer = lambda{|c| c == 1 ? :one : (2..4).include?(c) ? :few : :other }
+    @backend.store_translations :en, :foo => {:one => 'one en foo', :other => 'many en foos'}
+    @backend.store_translations :cz, :foo => {:one => 'one cz foo', :few => 'few cz foos', :other => 'many cz foos'}
+  end
+
+  test "looks up the :one translation when count is 1" do
+    assert_equal 'one en foo', @backend.translate(:en, :foo, :count => 1) 
+  end
+
+  test "looks up the :other translation when count is 2" do
+    assert_equal 'many en foos', @backend.translate(:en, :foo, :count => 2) 
+  end
+end
+
+class CzPluralizingTest < ActiveSupport::TestCase
+  def setup
+    @backend = Globalize::Backend::Pluralizing.new
+    @cz_pluralizer = lambda{|c| c == 1 ? :one : (2..4).include?(c) ? :few : :other }
+    @backend.store_translations :en, :foo => {:one => 'one en foo', :other => 'many en foos'}
+    @backend.store_translations :cz, :foo => {:one => 'one cz foo', :few => 'few cz foos', :other => 'many cz foos'}
+    @backend.add_pluralizer(:cz, @cz_pluralizer)
+  end
+
+  test "looks up the :one translation when count is 1 (:cz)" do
+    assert_equal 'one cz foo', @backend.translate(:cz, :foo, :count => 1) 
+  end
+
+  test "looks up the :few translation when count is 2 (:cz)" do
+    assert_equal 'few cz foos', @backend.translate(:cz, :foo, :count => 2)
+  end
+
+  test "looks up the :other translation when count is 5 (:cz)" do
+    assert_equal 'many cz foos', @backend.translate(:cz, :foo, :count => 5)
+  end
+
+end

data/test/backends/static_test.rb

@@ -0,0 +1,143 @@
+require File.join( File.dirname(__FILE__), '..', 'test_helper' )
+require 'globalize/backend/static'
+require 'globalize/translation'
+require 'action_view'
+include ActionView::Helpers::NumberHelper
+
+I18n.locale = :'en-US'    # Need to set this, since I18n defaults to 'en'
+
+class StaticTest < ActiveSupport::TestCase
+  def setup
+    I18n.backend = Globalize::Backend::Static.new
+    translations = {:"en-US" => {:foo => "foo in en-US", :boz => 'boz', :buz => {:bum => 'bum'}},
+                    :"en"    => {:bar => "bar in en"},
+                    :"de-DE" => {:baz => "baz in de-DE"},
+                    :"de"    => {:boo => "boo in de", :number => { :currency => { :format => { :unit => '€', :format => '%n %u'}}}}}
+    translations.each do |locale, data| 
+      I18n.backend.store_translations locale, data 
+    end
+    I18n.fallbacks.map :"de-DE" => :"en-US", :he => :en
+  end
+  
+  test "returns an instance of Translation:Static" do
+    translation = I18n.translate :foo
+    assert_instance_of Globalize::Translation::Static, translation
+  end
+    
+  test "returns the translation in en-US if present" do
+    assert_equal "foo in en-US", I18n.translate(:foo, :locale => :"en-US") 
+  end
+
+  test "returns the translation in en if en-US is not present" do
+    assert_equal "bar in en", I18n.translate(:bar, :locale => :"en-US") 
+  end
+  
+  test "returns the translation in de-DE if present" do
+    assert_equal "baz in de-DE", I18n.translate(:baz, :locale => :"de-DE") 
+  end
+  
+  test "returns the translation in de if de-DE is not present" do
+    assert_equal "boo in de", I18n.translate(:boo, :locale => :"de-DE") 
+  end
+  
+  test "returns the translation in en-US if none of de-DE and de are present" do
+    assert_equal "foo in en-US", I18n.translate(:foo, :locale => :"de-DE") 
+  end
+
+  test "returns the translation in en if none of de-DE, de and en-US are present" do
+    assert_equal "bar in en", I18n.translate(:bar, :locale => :"de-DE") 
+  end
+  
+  test "returns the translation in en if none in he is present" do
+    assert_equal "bar in en", I18n.translate(:bar, :locale => :he) 
+  end
+  
+  test "returns the given default String when the key is not present for any locale" do
+    assert_equal "default", I18n.translate(:missing, :default => "default") 
+  end
+
+  test "returns the fallback translation for the key if present for a fallback locale" do
+    I18n.backend.store_translations :de, :non_default => "non_default in de"
+    assert_equal "non_default in de", I18n.translate(:non_default, :default => "default", :locale => :"de-DE") 
+  end  
+
+  test "returns an array of translations" do
+    assert_instance_of Array, I18n.translate([:foo, :boz])
+  end
+  
+  test "returns an array of instances of Translation::Static" do
+    assert_equal [Globalize::Translation::Static], I18n.translate([:foo, :boz]).map(&:class).uniq
+  end
+  
+  test "returns a hash of translations" do
+    assert_instance_of Hash, I18n.translate(:"buz")
+  end
+  
+  test "returns an array of translations 2" do
+    assert_equal [Globalize::Translation::Static], I18n.translate(:"buz").values.map(&:class) 
+  end
+
+  test "returns currency properly formated" do
+    currency = number_to_currency(10)
+    assert_equal "$10.00", currency
+  end
+
+  test "returns currency properly formated for locale" do
+    currency = number_to_currency(10, :locale => :'de')
+    assert_equal "10.000 €", currency
+  end
+
+  test "returns currency properly formated from parameters" do
+    currency = number_to_currency(10, :format => "%n %u", :unit => '€')
+    assert_equal "10.00 €", currency
+  end
+
+  test "makes sure interpolation does not break even with False as string" do
+    assert_equal "translation missing: en, support, array, skip_last_comma", I18n.translate(:"support.array.skip_last_comma")
+  end
+end
+
+class TranslationStaticTest < ActiveSupport::TestCase
+  def setup
+    I18n.backend = Globalize::Backend::Static.new 
+    translations = {
+      :greeting => "Hi {{name}}",
+      :messages => { :one => "You have one message.", :other => "You have {{count}} messages."}
+    }
+    I18n.backend.store_translations :"en", translations
+  end
+
+  def greeting
+    I18n.translate :greeting, :locale => :"en-US", :name => "Joshua"
+  end
+  
+  test "stores the actual locale" do
+    assert_equal :en, greeting.locale
+  end
+  
+  test "stores the requested locale" do
+    assert_equal :'en-US', greeting.requested_locale
+  end
+  
+  test "stores the requested key" do
+    assert_equal :greeting, greeting.key
+  end
+  
+  test "stores the options given to #translate" do
+    assert_equal( {:name => "Joshua"}, greeting.options ) 
+  end
+  
+  test "stores the original translation before test was interpolated" do
+    assert_equal "Hi {{name}}", greeting.original 
+  end
+  
+  test "stores the plural_key :one if pluralized as such" do
+    message = I18n.translate :messages, :locale => :"en-US", :count => 1
+    assert_equal :one, message.plural_key
+  end
+  
+  test "stores the plural_key :other if pluralized as such" do
+    messages = I18n.translate :messages, :locale => :"en-US", :count => 2
+    assert_equal :other, messages.plural_key
+  end
+end