globalize2 0.1.0 → 0.2.0

data/lib/globalize/active_record/adapter.rb

@@ -0,0 +1,80 @@
+module Globalize
+  module ActiveRecord
+    class Adapter
+      # The cache caches attributes that already were looked up for read access.
+      # The stash keeps track of new or changed values that need to be saved.
+      attr_reader :record, :cache, :stash
+
+      def initialize(record)
+        @record = record
+        @cache = Attributes.new
+        @stash = Attributes.new
+      end
+
+      def fetch(locale, attr_name)
+        cache.contains?(locale, attr_name) ?
+          cache.read(locale, attr_name) :
+          cache.write(locale, attr_name, fetch_attribute(locale, attr_name))
+      end
+
+      def write(locale, attr_name, value)
+        stash.write(locale, attr_name, value)
+        cache.write(locale, attr_name, value)
+      end
+
+      def save_translations!
+        stash.each do |locale, attrs|
+          translation = record.translations.find_or_initialize_by_locale(locale.to_s)
+          attrs.each { |attr_name, value| translation[attr_name] = value }
+          translation.save!
+        end
+        stash.clear
+      end
+
+      def reset
+        cache.clear
+        # stash.clear
+      end
+
+      protected
+
+        def fetch_translation(locale)
+          locale = locale.to_sym
+          record.translations.loaded? ? record.translations.detect { |t| t.locale == locale } :
+            record.translations.by_locale(locale)
+        end
+
+        def fetch_translations(locale)
+          # only query if not already included with :include => translations
+          record.translations.loaded? ? record.translations :
+            record.translations.by_locales(Globalize.fallbacks(locale))
+        end
+
+        def fetch_attribute(locale, attr_name)
+          translations = fetch_translations(locale)
+          value, requested_locale = nil, locale
+
+          Globalize.fallbacks(locale).each do |fallback|
+            translation = translations.detect { |t| t.locale == fallback }
+            value  = translation && translation.send(attr_name)
+            locale = fallback && break if value
+          end
+
+          set_metadata(value, :locale => locale, :requested_locale => requested_locale)
+          value
+        end
+
+        def set_metadata(object, metadata)
+          if object.respond_to?(:translation_metadata)
+            object.translation_metadata.merge!(meta_data)
+          end
+        end
+
+        def translation_metadata_accessor(object)
+          return if obj.respond_to?(:translation_metadata)
+          class << object; attr_accessor :translation_metadata end
+          object.translation_metadata ||= {}
+        end
+    end
+  end
+end

data/lib/globalize/active_record/attributes.rb

@@ -0,0 +1,25 @@
+# Helper class for storing values per locale. Used by Globalize::Adapter
+# to stash and cache attribute values.
+module Globalize
+  module ActiveRecord
+    class Attributes < Hash
+      def [](locale)
+        locale = locale.to_sym
+        self[locale] = {} unless has_key?(locale)
+        self.fetch(locale)
+      end
+
+      def contains?(locale, attr_name)
+        self[locale].has_key?(attr_name)
+      end
+
+      def read(locale, attr_name)
+        self[locale][attr_name]
+      end
+
+      def write(locale, attr_name, value)
+        self[locale][attr_name] = value
+      end
+    end
+  end
+end

data/lib/globalize/active_record/migration.rb

@@ -0,0 +1,40 @@
+module Globalize
+  module ActiveRecord
+    module Migration
+      def create_translation_table!(fields)
+        translated_attribute_names.each do |f|
+          raise MigrationMissingTranslatedField, "Missing translated field #{f}" unless fields[f]
+        end
+
+        fields.each do |name, type|
+          if translated_attribute_names.include?(name) && ![:string, :text].include?(type)
+            raise BadMigrationFieldType, "Bad field type for #{name}, should be :string or :text"
+          end
+        end
+
+        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", :name => translation_index_name)
+      end
+
+      def translation_index_name
+        require 'digest/sha1'
+        # FIXME what's the max size of an index name?
+        index_name = "index_#{translation_table_name}_on_#{self.table_name.singularize}_id"
+        index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
+      end
+
+      def drop_translation_table!
+        self.connection.remove_index(translation_table_name, :name => translation_index_name) rescue nil
+        self.connection.drop_table(translation_table_name)
+      end
+    end
+  end
+end

data/lib/{globalize/i18n → i18n}/missing_translations_log_handler.rb

@@ -2,10 +2,10 @@
 # but additionally logs missing translations to a given log.
 #
 # Useful for identifying missing translations during testing.
-# 
-# E.g. 
 #
-#   require 'globalize/i18n/missing_translations_log_handler
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_log_handler'
 #   I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
 #   I18n.exception_handler = :missing_translations_log_handler
 #
@@ -16,7 +16,7 @@
 
 module I18n
   @@missing_translations_logger = nil
-  
+
   class << self
     def missing_translations_logger
       @@missing_translations_logger ||= begin
@@ -24,18 +24,18 @@ module I18n
         Logger.new(STDOUT)
       end
     end
-  
+
     def missing_translations_logger=(logger)
       @@missing_translations_logger = logger
     end
-  
+
     def missing_translations_log_handler(exception, locale, key, options)
       if MissingTranslationData === exception
         missing_translations_logger.warn(exception.message)
-        return exception.message 
+        return exception.message
       else
         raise exception
       end
     end
   end
-end
+end

data/lib/{globalize/i18n → i18n}/missing_translations_raise_handler.rb

@@ -2,10 +2,10 @@
 # but also raises on missing translations.
 #
 # Useful for identifying missing translations during testing.
-# 
-# E.g. 
 #
-#   require 'globalize/i18n/missing_translations_raise_handler
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_raise_handler'
 #   I18n.exception_handler = :missing_translations_raise_handler
 module I18n
   class << self
@@ -13,8 +13,6 @@ module I18n
       raise exception
     end
   end
-  
-#  self.exception_handler = :missing_translations_raise_handler
 end
 
 I18n.exception_handler = :missing_translations_raise_handler

data/test/active_record/fallbacks_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
+
+if I18n.respond_to?(:fallbacks)
+  class TranslatedTest < ActiveSupport::TestCase
+    def setup
+      I18n.locale = :'en-US'
+      I18n.fallbacks.clear
+      reset_db!
+      ActiveRecord::Base.locale = nil
+    end
+
+    def teardown
+      I18n.fallbacks.clear
+    end
+
+    test "keeping one field in new locale when other field is changed" do
+      I18n.fallbacks.map 'de-DE' => [ 'en-US' ]
+      post = Post.create :subject => 'foo'
+      I18n.locale = 'de-DE'
+      post.content = 'bar'
+      assert_equal 'foo', post.subject
+    end
+
+    test "modifying non-required field in a new locale" do
+      I18n.fallbacks.map 'de-DE' => [ 'en-US' ]
+      post = Post.create :subject => 'foo'
+      I18n.locale = 'de-DE'
+      post.content = 'bar'
+      assert post.save
+    end
+
+    test "resolves a simple fallback" do
+      I18n.locale = 'de-DE'
+      post = Post.create :subject => 'foo'
+      I18n.locale = 'de'
+      post.subject = 'baz'
+      post.content = 'bar'
+      post.save
+      I18n.locale = 'de-DE'
+      assert_equal 'foo', post.subject
+      assert_equal 'bar', post.content
+    end
+
+    test "resolves a simple fallback without reloading" do
+      I18n.locale = 'de-DE'
+      post = Post.new :subject => 'foo'
+      I18n.locale = 'de'
+      post.subject = 'baz'
+      post.content = 'bar'
+      I18n.locale = 'de-DE'
+      assert_equal 'foo', post.subject
+      assert_equal 'bar', post.content
+    end
+
+    test "resolves a complex fallback without reloading" do
+      I18n.fallbacks.map 'de' => %w(en he)
+      I18n.locale = 'de'
+      post = Post.new
+      I18n.locale = 'en'
+      post.subject = 'foo'
+      I18n.locale = 'he'
+      post.subject = 'baz'
+      post.content = 'bar'
+      I18n.locale = 'de'
+      assert_equal 'foo', post.subject
+      assert_equal 'bar', post.content
+    end
+
+    test 'fallbacks with lots of locale switching' do
+      I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+      post = Post.create :subject => 'foo'
+
+      I18n.locale = :'de-DE'
+      assert_equal 'foo', post.subject
+
+      I18n.locale = :'en-US'
+      post.update_attribute :subject, 'bar'
+
+      I18n.locale = :'de-DE'
+      assert_equal 'bar', post.subject
+    end
+
+    test 'fallbacks with lots of locale switching' do
+      I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
+      child = Child.create :content => 'foo'
+
+      I18n.locale = :'de-DE'
+      assert_equal 'foo', child.content
+
+      I18n.locale = :'en-US'
+      child.update_attribute :content, 'bar'
+
+      I18n.locale = :'de-DE'
+      assert_equal 'bar', child.content
+    end
+  end
+end
+
+# TODO should validate_presence_of take fallbacks into account? maybe we need
+#   an extra validation call, or more options for validate_presence_of.
+

data/test/{model/active_record → active_record}/migration_test.rb

@@ -1,36 +1,32 @@
-require File.join( File.dirname(__FILE__), '..', '..', 'test_helper' )
-require 'active_record'
-require 'globalize/model/active_record'
-
-# Hook up model translation
-ActiveRecord::Base.send(:include, Globalize::Model::ActiveRecord::Translated)
-
-# Load Post model
-require File.join( File.dirname(__FILE__), '..', '..', 'data', 'models' )
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
 
 class MigrationTest < ActiveSupport::TestCase
   def setup
-    reset_db! File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'no_globalize_schema.rb'))
+    reset_db!
+    Post.drop_translation_table!
   end
 
   test 'globalize table added' do
-    assert !Post.connection.table_exists?( :post_translations )
-    assert !Post.connection.index_exists?( :post_translations, :post_id )
-    Post.create_translation_table! :subject => :string, :content => :text
-    assert Post.connection.table_exists?( :post_translations )
-    assert Post.connection.index_exists?( :post_translations, :post_id )
-    columns = Post.connection.columns( :post_translations )
-    assert locale = columns.detect {|c| c.name == 'locale' }
+    assert !Post.connection.table_exists?(:post_translations)
+    assert !Post.connection.index_exists?(:post_translations, :post_id)
+
+    Post.create_translation_table!(:subject => :string, :content => :text)
+    assert Post.connection.table_exists?(:post_translations)
+    assert Post.connection.index_exists?(:post_translations, :post_id)
+
+    columns = Post.connection.columns(:post_translations)
+    assert locale = columns.detect { |c| c.name == 'locale' }
     assert_equal :string, locale.type
-    assert subject = columns.detect {|c| c.name == 'subject' }
+    assert subject = columns.detect { |c| c.name == 'subject' }
     assert_equal :string, subject.type
-    assert content = columns.detect {|c| c.name == 'content' }
+    assert content = columns.detect { |c| c.name == 'content' }
     assert_equal :text, content.type
-    assert post_id = columns.detect {|c| c.name == 'post_id' }
+    assert post_id = columns.detect { |c| c.name == 'post_id' }
     assert_equal :integer, post_id.type
-    assert created_at = columns.detect {|c| c.name == 'created_at' }
+    assert created_at = columns.detect { |c| c.name == 'created_at' }
     assert_equal :datetime, created_at.type
-    assert updated_at = columns.detect {|c| c.name == 'updated_at' }
+    assert updated_at = columns.detect { |c| c.name == 'updated_at' }
     assert_equal :datetime, updated_at.type
   end
 
@@ -46,13 +42,13 @@ class MigrationTest < ActiveSupport::TestCase
   end
 
   test 'exception on missing field inputs' do
-    assert_raise Globalize::Model::MigrationMissingTranslatedField do
+    assert_raise Globalize::MigrationMissingTranslatedField do
       Post.create_translation_table! :content => :text
     end
   end
 
   test 'exception on bad input type' do
-    assert_raise Globalize::Model::BadMigrationFieldType do
+    assert_raise Globalize::BadMigrationFieldType do
       Post.create_translation_table! :subject => :string, :content => :integer
     end
   end
@@ -104,16 +100,15 @@ class MigrationTest < ActiveSupport::TestCase
   end
 
   test 'globalize table dropped when table has long name' do
+    UltraLongModelNameWithoutProper.drop_translation_table!
     UltraLongModelNameWithoutProper.create_translation_table!(
       :subject => :string, :content => :text
     )
-
     UltraLongModelNameWithoutProper.drop_translation_table!
 
     assert !UltraLongModelNameWithoutProper.connection.table_exists?(
       :ultra_long_model_name_without_proper_translations
     )
-
     assert !UltraLongModelNameWithoutProper.connection.index_exists?(
       :ultra_long_model_name_without_proper_translations,
       :ultra_long_model_name_without_proper_id

data/test/{model/active_record → active_record}/sti_translated_test.rb

@@ -1,22 +1,10 @@
-require File.join( File.dirname(__FILE__), '..', '..', 'test_helper' )
-require 'active_record'
-require 'globalize/model/active_record'
-
-# Hook up model translation
-ActiveRecord::Base.send(:include, Globalize::Model::ActiveRecord::Translated)
-
-# Load Post model
-require File.join( File.dirname(__FILE__), '..', '..', 'data', 'models' )
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../data/models')
 
 class StiTranslatedTest < ActiveSupport::TestCase
   def setup
     I18n.locale = :'en-US'
-    I18n.fallbacks.clear
-    reset_db! File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'schema.rb'))
-  end
-
-  def teardown
-    I18n.fallbacks.clear
+    reset_db!
   end
 
   test "works with simple dynamic finders" do
@@ -43,20 +31,6 @@ class StiTranslatedTest < ActiveSupport::TestCase
     assert_equal [ 'content' ], child.changed
   end
 
-  test 'fallbacks with lots of locale switching' do
-    I18n.fallbacks.map :'de-DE' => [ :'en-US' ]
-    child = Child.create :content => 'foo'
-
-    I18n.locale = :'de-DE'
-    assert_equal 'foo', child.content
-
-    I18n.locale = :'en-US'
-    child.update_attribute :content, 'bar'
-
-    I18n.locale = :'de-DE'
-    assert_equal 'bar', child.content
-  end
-
   test "saves all locales, even after locale switching" do
     child = Child.new :content => 'foo'
     I18n.locale = 'de-DE'
@@ -72,4 +46,4 @@ class StiTranslatedTest < ActiveSupport::TestCase
     I18n.locale = 'he-IL'
     assert_equal 'baz', child.content
   end
-end
+end