kriss-gettext_i18n 0.2.0

data/vendor/globalize2/lib/globalize/locale/language_tag.rb

@@ -0,0 +1,81 @@
+# for specifications see http://en.wikipedia.org/wiki/IETF_language_tag
+#
+# SimpleParser does not implement advanced usages such as grandfathered tags
+
+module Globalize
+  module Locale
+    module Rfc4646
+      SUBTAGS = [:language, :script, :region, :variant, :extension, :privateuse, :grandfathered]
+      FORMATS = {:language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase}
+    end
+    
+    class LanguageTag < Struct.new(*Rfc4646::SUBTAGS)
+      class << self
+        def parser
+          @@parser ||= SimpleParser
+        end
+    
+        def parser=(parser)
+          @@parser = parser
+        end
+    
+        def tag(tag)
+          matches = parser.match(tag)
+          new *matches if matches
+        end
+      end
+  
+      Rfc4646::FORMATS.each do |name, format|
+        define_method(name) { self[name].send(format) unless self[name].nil? }
+      end
+      
+      def to_sym
+        to_s.to_sym
+      end
+      
+      def to_s
+        @tag ||= to_a.compact.join("-")
+      end
+  
+      def to_a
+        members.collect {|attr| self.send(attr) }
+      end
+  
+      def parent
+        segs = to_a.compact
+        segs.length < 2 ? nil : LanguageTag.tag(segs[0..(segs.length-2)].join('-'))
+      end
+      
+      def parents(include_self = true)
+        result, parent = [], self.dup
+        result << parent if include_self
+        while parent = parent.parent
+          result << parent
+        end
+        result
+      end
+  
+      module SimpleParser
+        PATTERN = %r{\A(?:
+          ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
+          (?:-([a-z]{4}))?                                        # script
+          (?:-([a-z]{2}|\d{3}))?                                  # region
+          (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
+          (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
+          (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
+          (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
+          /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
+          )\z}xi 
+
+        class << self
+          def match(tag)
+            c = PATTERN.match(tag.to_s).captures
+            c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
+          rescue
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/globalize2/lib/globalize/model/active_record/adapter.rb

@@ -0,0 +1,96 @@
+module Globalize
+  module Model
+    class AttributeStash < Hash
+      def contains?(locale, attr_name)
+        locale = locale.to_sym
+        self[locale] ||= {}
+        self[locale].has_key? attr_name        
+      end
+      
+      def read(locale, attr_name)
+        locale = locale.to_sym
+        self[locale] ||= {}
+        self[locale][attr_name]
+      end
+      
+      def write(locale, attr_name, value)
+        locale = locale.to_sym
+        self[locale] ||= {}
+        self[locale][attr_name] = value
+      end
+    end
+    
+    class Adapter
+      def initialize(record)
+        @record = record
+        
+        # TODO what exactly are the roles of cache and stash
+        @cache = AttributeStash.new
+        @stash = AttributeStash.new
+      end
+      
+      def fetch(locale, attr_name)
+        # locale = I18n.locale
+        is_cached = @cache.contains?(locale, attr_name)
+        is_cached ? @cache.read(locale, attr_name) : begin
+          value = fetch_attribute locale, attr_name
+          @cache.write locale, attr_name, value if value && value.locale == locale
+          value
+        end
+      end
+      
+      def stash(locale, attr_name, value)
+        @stash.write locale, attr_name, value
+        @cache.write locale, attr_name, value
+      end
+      
+      def update_translations!
+        @stash.each do |locale, attrs|
+          translation = @record.globalize_translations.find_or_initialize_by_locale(locale.to_s)
+          attrs.each{|attr_name, value| translation[attr_name] = value }
+          translation.save!
+        end
+        @stash.clear
+      end
+      
+      # Clears the cache
+      def clear
+        @cache.clear
+        @stash.clear
+      end
+      
+      private
+      
+      def fetch_attribute(locale, attr_name)
+        fallbacks = I18n.fallbacks[locale].map{|tag| tag.to_s}.map(&:to_sym)
+        
+        # If the translations were included with 
+        # :include => globalize_translations
+        # there is no need to query them again.
+        unless @record.globalize_translations.loaded?
+          translations = @record.globalize_translations.by_locales(fallbacks) 
+        else
+          translations = @record.globalize_translations
+        end
+        result, requested_locale = nil, locale
+
+        # Walk through the fallbacks, starting with the current locale itself, and moving
+        # to the next best choice, until we find a match.
+        # Check the @globalize_set_translations cache first to see if we've just changed the 
+        # attribute and not saved yet.
+        fallbacks.each do |fallback|
+          # TODO should we be checking stash or just cache?
+          result = @stash.read(fallback, attr_name) || begin
+            translation = translations.detect {|tr| tr.locale == fallback }
+            translation && translation.send(attr_name)
+          end
+          if result
+            locale = fallback
+            break
+          end
+        end
+        result && Translation::Attribute.new(result, :locale => locale, :requested_locale => requested_locale)
+      end
+    end
+  end
+end

data/vendor/globalize2/lib/globalize/model/active_record/translated.rb

@@ -0,0 +1,161 @@
+module Globalize
+  module Model
+  
+    class MigrationError < StandardError; end
+    class UntranslatedMigrationField < MigrationError; end
+    class MigrationMissingTranslatedField < MigrationError; end
+    class BadMigrationFieldType < MigrationError; end
+  
+    module ActiveRecord
+      module Translated
+        def self.included(base)
+          base.extend ActMethods
+        end
+
+        module ActMethods
+          def translates(*attr_names)
+            options = attr_names.extract_options!
+            options[:translated_attributes] = attr_names
+
+            # Only set up once per class
+            unless included_modules.include? InstanceMethods
+              class_inheritable_accessor :globalize_options, :globalize_proxy
+              
+              include InstanceMethods
+              extend  ClassMethods
+              
+              self.globalize_proxy = Globalize::Model::ActiveRecord.create_proxy_class(self)
+              has_many(
+                :globalize_translations,
+                :class_name   => globalize_proxy.name,
+                :extend       => Extensions,
+                :dependent    => :delete_all,
+                :foreign_key  => class_name.foreign_key
+              )
+
+              after_save :update_globalize_record              
+            end
+
+            self.globalize_options = options
+            Globalize::Model::ActiveRecord.define_accessors(self, attr_names)
+            
+            # Import any callbacks that have been defined by extensions to Globalize2
+            # and run them.
+            extend Callbacks
+            Callbacks.instance_methods.each {|cb| send cb }
+          end
+
+          def locale=(locale)
+            @@locale = locale
+          end
+          
+          def locale
+            (defined?(@@locale) && @@locale) || I18n.locale
+          end          
+        end
+
+        # Dummy Callbacks module. Extensions to Globalize2 can insert methods into here
+        # and they'll be called at the end of the translates class method.
+        module Callbacks
+        end
+        
+        # Extension to the has_many :globalize_translations association
+        module Extensions
+          def by_locales(locales)
+            find :all, :conditions => { :locale => locales.map(&:to_s) }
+          end
+        end
+        
+        module ClassMethods          
+          def method_missing(method, *args)
+            if method.to_s =~ /^find_by_(\w+)$/ && globalize_options[:translated_attributes].include?($1.to_sym)
+              find(:first, :joins => :globalize_translations,
+                   :conditions => [ "#{i18n_attr($1)} = ? AND #{i18n_attr('locale')} IN (?)",
+                                   args.first,I18n.fallbacks[I18n.locale].map{|tag| tag.to_s}])
+            else
+              super
+            end
+          end
+                    
+          def create_translation_table!(fields)
+            translated_fields = self.globalize_options[:translated_attributes]
+            translated_fields.each do |f|
+              raise MigrationMissingTranslatedField, "Missing translated field #{f}" unless fields[f]
+            end
+            fields.each do |name, type|
+              unless translated_fields.member? name 
+                raise UntranslatedMigrationField, "Can't migrate untranslated field: #{name}"
+              end              
+              unless [ :string, :text ].member? type
+                raise BadMigrationFieldType, "Bad field type for #{name}, should be :string or :text"
+              end 
+            end
+            translation_table_name = self.name.underscore + '_translations'
+            self.connection.create_table(translation_table_name) do |t|
+              t.references self.table_name.singularize
+              t.string :locale
+              fields.each do |name, type|
+                t.column name, type
+              end
+              t.timestamps              
+            end
+            
+            self.connection.add_index(
+              translation_table_name, "#{self.table_name.singularize}_id"
+            )
+          end
+
+          def drop_translation_table!
+            translation_table_name = self.name.underscore + '_translations'
+            self.connection.remove_index(
+              translation_table_name, "#{self.table_name.singularize}_id"
+            )
+            self.connection.drop_table translation_table_name
+          end
+          
+          private
+          
+          def i18n_attr(attribute_name)
+            self.base_class.name.underscore + "_translations.#{attribute_name}"
+          end          
+        end
+        
+        module InstanceMethods
+          def reload(options = nil)
+            globalize.clear
+            
+            # clear all globalized attributes
+            # TODO what's the best way to handle this?
+            self.class.globalize_options[:translated_attributes].each do |attr|
+              @attributes.delete attr.to_s
+            end
+            
+            super options
+          end
+          
+          def globalize
+            @globalize ||= Adapter.new self
+          end
+          
+          def update_globalize_record
+            globalize.update_translations!
+          end
+          
+          def translated_locales
+            globalize_translations.scoped(:select => 'DISTINCT locale').map {|gt| gt.locale.to_sym }
+          end
+          
+          def set_translations options
+            options.keys.each do |key|
+
+              translation = globalize_translations.find_by_locale(key.to_s) ||
+                globalize_translations.build(:locale => key.to_s)
+              translation.update_attributes!(options[key])
+            end
+          end
+          
+        end
+      end
+    end
+  end
+end

data/vendor/globalize2/lib/globalize/model/active_record.rb

@@ -0,0 +1,38 @@
+require 'globalize/translation'
+require 'globalize/locale/fallbacks'
+require 'globalize/model/active_record/adapter'
+require 'globalize/model/active_record/translated'
+
+module Globalize
+  module Model
+    module ActiveRecord
+      class << self                
+        def create_proxy_class(klass)
+          Object.const_set "#{klass.name}Translation", Class.new(::ActiveRecord::Base){
+            belongs_to "#{klass.name.underscore}".intern
+            
+            def locale
+              read_attribute(:locale).to_sym
+            end
+            
+            def locale=(locale)
+              write_attribute(:locale, locale.to_s)
+            end
+          }
+        end
+
+        def define_accessors(klass, attr_names)
+          attr_names.each do |attr_name|
+            klass.send :define_method, attr_name, lambda {
+              globalize.fetch self.class.locale, attr_name
+            }
+            klass.send :define_method, "#{attr_name}=", lambda {|val|
+              globalize.stash self.class.locale, attr_name, val
+              self[attr_name] = val
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/globalize2/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/vendor/globalize2/lib/locale/root.yml

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

data/vendor/globalize2/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/vendor/globalize2/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/vendor/globalize2/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