globalize 5.0.1 → 5.1.0.beta1

data/Rakefile

@@ -20,3 +20,36 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :load_path do
+  %w(lib test).each do |path|
+    $LOAD_PATH.unshift(File.expand_path("../#{path}", __FILE__))
+  end
+end
+
+namespace :db do
+  desc 'Create the database'
+  task :create => :load_path do
+    require 'support/database'
+
+    Globalize::Test::Database.create!
+  end
+
+  desc "Drop the database"
+  task :drop => :load_path do
+    require 'support/database'
+
+    Globalize::Test::Database.drop!
+  end
+
+  desc "Set up the database schema"
+  task :migrate => :load_path do
+    require 'support/database'
+
+    Globalize::Test::Database.migrate!
+    # ActiveRecord::Schema.migrate :up
+  end
+
+  desc "Drop and recreate the database schema"
+  task :reset => [:drop, :create]
+end

data/lib/globalize.rb

@@ -1,11 +1,12 @@
+require 'request_store'
 require 'active_record'
 require 'patches/active_record/xml_attribute_serializer'
 require 'patches/active_record/query_method'
+require 'patches/active_record/relation'
 require 'patches/active_record/serialization'
 require 'patches/active_record/uniqueness_validator'
 require 'patches/active_record/persistence'
 
-
 module Globalize
   autoload :ActiveRecord, 'globalize/active_record'
   autoload :Interpolation,   'globalize/interpolation'
@@ -52,18 +53,23 @@ module Globalize
       i18n_fallbacks? ? I18n.fallbacks[for_locale] : [for_locale.to_sym]
     end
 
+    # Thread-safe global storage
+    def storage
+      RequestStore.store
+    end
+
   protected
 
     def read_locale
-      @globalize_locale
+      storage[:globalize_locale]
     end
 
     def set_locale(locale)
-      @globalize_locale = locale.try(:to_sym)
+      storage[:globalize_locale] = locale.try(:to_sym)
     end
 
     def read_fallbacks
-      @fallbacks || HashWithIndifferentAccess.new
+      storage[:globalize_fallbacks] || HashWithIndifferentAccess.new
     end
 
     def set_fallbacks(locales)
@@ -73,7 +79,7 @@ module Globalize
         fallback_hash[key] = value.presence || [key]
       end if locales.present?
 
-      @fallbacks = fallback_hash
+      storage[:globalize_fallbacks] = fallback_hash
     end
   end
 end

data/lib/globalize/active_record.rb

@@ -2,6 +2,7 @@ module Globalize
   module ActiveRecord
     autoload :ActMacro,        'globalize/active_record/act_macro'
     autoload :Adapter,         'globalize/active_record/adapter'
+    autoload :AdapterDirty,    'globalize/active_record/adapter_dirty'
     autoload :Attributes,      'globalize/active_record/attributes'
     autoload :ClassMethods,    'globalize/active_record/class_methods'
     autoload :Exceptions,      'globalize/active_record/exceptions'

data/lib/globalize/active_record/act_macro.rb

@@ -5,6 +5,7 @@ module Globalize
         options = attr_names.extract_options!
         # Bypass setup_translates! if the initial bootstrapping is done already.
         setup_translates!(options) unless translates?
+        check_columns!(attr_names)
 
         # Add any extra translatable attributes.
         attr_names = attr_names.map(&:to_sym)
@@ -38,6 +39,25 @@ module Globalize
           # Add attribute to the list.
           self.translated_attribute_names << attr_name
         end
+
+        if ::ActiveRecord::VERSION::STRING > "5.0" && table_exists? && translation_class.table_exists?
+          self.ignored_columns += translated_attribute_names.map(&:to_s)
+          reset_column_information
+        end
+      end
+
+      def check_columns!(attr_names)
+        # If tables do not exist, do not warn about conflicting columns
+        return unless table_exists? && translation_class.table_exists?
+
+        if (overlap = attr_names.map(&:to_s) & column_names).present?
+          ActiveSupport::Deprecation.warn(
+            ["You have defined one or more translated attributes with names that conflict with column(s) on the model table. ",
+             "Globalize does not support this configuration anymore, remove or rename column(s) on the model table.\n",
+             "Model name (table name): #{model_name} (#{table_name})\n",
+             "Attribute name(s): #{overlap.join(', ')}\n"].join
+          )
+        end
       end
 
       def apply_globalize_options(options)
@@ -74,10 +94,11 @@ module Globalize
                                 :foreign_key => options[:foreign_key],
                                 :dependent   => :destroy,
                                 :extend      => HasManyExtensions,
-                                :autosave    => false
+                                :autosave    => true,
+                                :inverse_of  => :globalized_model
 
-        after_create :save_translations!
-        after_update :save_translations!
+        before_create :save_translations!
+        before_update :save_translations!
       end
     end
 

data/lib/globalize/active_record/adapter.rb

@@ -3,7 +3,7 @@ module Globalize
     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_accessor :record, :stash, :translations
+      attr_accessor :record, :stash
       private :record=, :stash=
 
       delegate :translation_class, :to => :'record.class'
@@ -34,16 +34,15 @@ module Globalize
       end
 
       def save_translations!
-        stash.reject {|locale, attrs| attrs.empty?}.each do |locale, attrs|
+        stash.each do |locale, attrs|
+          next if attrs.empty?
+
           translation = record.translations_by_locale[locale] ||
                         record.translations.build(locale: locale.to_s)
-
           attrs.each do |name, value|
             value = value.val if value.is_a?(Arel::Nodes::Casted)
             translation[name] = value
           end
-          ensure_foreign_key_for(translation)
-          translation.save!
         end
 
         reset
@@ -55,11 +54,6 @@ module Globalize
 
       protected
 
-      # Sometimes the translation is initialised before a foreign key can be set.
-      def ensure_foreign_key_for(translation)
-        translation[translation.class.reflections["globalized_model"].foreign_key] = record.id
-      end
-
       def type_cast(name, value)
         return value.presence unless column = column_for_attribute(name)
 
@@ -76,7 +70,11 @@ module Globalize
 
       def fetch_attribute(locale, name)
         translation = record.translation_for(locale, false)
-        return translation && translation.send(name)
+        if translation
+          translation.send(name)
+        else
+          record.class.translation_class.new.send(name)
+        end
       end
 
       def set_metadata(object, metadata)
@@ -95,6 +93,7 @@ module Globalize
       end
 
       delegate :fallbacks_for_empty_translations?, :to => :record, :prefix => false
+      prepend AdapterDirty
     end
   end
 end

data/lib/globalize/active_record/adapter_dirty.rb

@@ -0,0 +1,54 @@
+module Globalize
+  module ActiveRecord
+    module AdapterDirty
+      def write locale, name, value
+        # Dirty tracking, paraphrased from
+        # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+        name = name.to_s
+        store_old_value name, locale
+        old_values = dirty[name]
+        old_value = old_values[locale]
+        is_changed = record.send :attribute_changed?, name
+        if is_changed && value == old_value
+          # If there's already a change, delete it if this undoes the change.
+          old_values.delete locale
+          if old_values.empty?
+            _reset_attribute name
+          end
+        elsif !is_changed
+          # If there's not a change yet, record it.
+          record.send(:attribute_will_change!, name) if old_value != value
+        end
+
+        super locale, name, value
+      end
+
+      attr_writer :dirty
+      def dirty
+        @dirty ||= {}
+      end
+
+      def store_old_value name, locale
+        dirty[name] ||= {}
+        unless dirty[name].key? locale
+          old = fetch(locale, name)
+          old = old.dup if old.duplicable?
+          dirty[name][locale] = old
+        end
+      end
+      def clear_dirty
+        self.dirty = {}
+      end
+
+      def _reset_attribute name
+        record.send("#{name}=", record.changed_attributes[name])
+        record.original_changed_attributes.except!(name)
+      end
+
+      def reset
+        clear_dirty
+        super
+      end
+    end
+  end
+end

data/lib/globalize/active_record/class_methods.rb

@@ -3,13 +3,21 @@ module Globalize
     module ClassMethods
       delegate :translated_locales, :set_translations_table_name, :to => :translation_class
 
+      if ::ActiveRecord::VERSION::STRING < "5.0.0"
+        def columns_hash
+          super.except(*translated_attribute_names.map(&:to_s))
+        end
+      end
+
       def with_locales(*locales)
         all.merge translation_class.with_locales(*locales)
       end
 
       def with_translations(*locales)
         locales = translated_locales if locales.empty?
-        preload(:translations).joins(:translations).readonly(false).with_locales(locales)
+        preload(:translations).joins(:translations).readonly(false).with_locales(locales).tap do |query|
+          query.distinct! unless locales.flatten.one?
+        end
       end
 
       def with_required_attributes
@@ -42,12 +50,13 @@ module Globalize
 
       def translation_class
         @translation_class ||= begin
-          klass = self.const_get(:Translation) rescue nil
-          if klass.nil? || klass.class_name != (self.class_name + "Translation")
+          if self.const_defined?(:Translation, false)
+            klass = self.const_get(:Translation, false)
+          else
             klass = self.const_set(:Translation, Class.new(Globalize::ActiveRecord::Translation))
           end
 
-          klass.belongs_to :globalized_model, :class_name => self.name, :foreign_key => translation_options[:foreign_key]
+          klass.belongs_to :globalized_model, :class_name => self.name, :foreign_key => translation_options[:foreign_key], inverse_of: :translations
           klass
         end
       end
@@ -100,8 +109,8 @@ module Globalize
 
       def define_translations_writer(name)
         define_method(:"#{name}_translations=") do |value|
-          value.each do |(locale, value)|
-            write_attribute name, value, :locale => locale
+          value.each do |(locale, _value)|
+            write_attribute name, _value, :locale => locale
           end
         end
       end

data/lib/globalize/active_record/exceptions.rb

@@ -8,12 +8,6 @@ module Globalize
           super("Missing translated field #{field.inspect}")
         end
       end
-
-      class BadFieldType < MigrationError
-        def initialize(name, type)
-          super("Bad field type for field #{name.inspect} (#{type.inspect}), should be :string or :text")
-        end
-      end
     end
   end
-end
+end

data/lib/globalize/active_record/instance_methods.rb

@@ -11,48 +11,46 @@ module Globalize
         super.merge(translated_attributes)
       end
 
-      def attributes=(attributes, *args)
-        with_given_locale(attributes) { super }
+      def attributes=(new_attributes, *options)
+        super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
+        attributes = new_attributes.stringify_keys
+        with_given_locale(attributes) { super(attributes.except("locale"), *options) }
       end
 
-      def assign_attributes(attributes, *args)
-        with_given_locale(attributes) { super }
+      def assign_attributes(new_attributes, *options)
+        super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
+        attributes = new_attributes.stringify_keys
+        with_given_locale(attributes) { super(attributes.except("locale"), *options) }
       end
 
-      def write_attribute(name, value, options = {})
-        return super(name, value) unless translated?(name)
+      def write_attribute(name, value, *args, &block)
+        return super(name, value, *args, &block) unless translated?(name)
 
-        options = {:locale => Globalize.locale}.merge(options)
+        options = {:locale => Globalize.locale}.merge(args.first || {})
 
-        # Dirty tracking, paraphrased from
-        # ActiveRecord::AttributeMethods::Dirty#write_attribute.
-        name_str = name.to_s
-        if attribute_changed?(name_str)
-          # If there's already a change, delete it if this undoes the change.
-          old = changed_attributes[name_str]
-          @changed_attributes.delete(name_str) if value == old
+        globalize.write(options[:locale], name, value)
+      end
+
+      def [](attr_name)
+        if translated?(attr_name)
+          read_attribute(attr_name)
         else
-          # If there's not a change yet, record it.
-          old = globalize.fetch(options[:locale], name)
-          old = old.dup if old.duplicable?
-          @changed_attributes[name_str] = old if value != old
+          read_attribute(attr_name) { |n| missing_attribute(n, caller) }
         end
-
-        globalize.write(options[:locale], name, value)
       end
 
-      def read_attribute(name, options = {})
+      def read_attribute(name, options = {}, &block)
         options = {:translated => true, :locale => nil}.merge(options)
-        return super(name) unless options[:translated]
+        return super(name, &block) unless options[:translated]
 
         if translated?(name)
-          if (value = globalize.fetch(options[:locale] || Globalize.locale, name))
+          if !(value = globalize.fetch(options[:locale] || Globalize.locale, name)).nil?
             value
           else
-            super(name)
+            super(name, &block)
           end
         else
-          super(name)
+          super(name, &block)
         end
       end
 
@@ -83,8 +81,9 @@ module Globalize
 
           options[locale].each do |key, value|
             translation.send :"#{key}=", value
+            translation.globalized_model.send :"#{key}=", value
           end
-          translation.save
+          translation.save if persisted?
         end
         globalize.reset
       end
@@ -143,14 +142,17 @@ module Globalize
         Globalize.fallbacks(locale)
       end
 
-      def rollback
-        translation_caches[::Globalize.locale] = translation.previous_version
-      end
-
       def save(*)
-        Globalize.with_locale(translation.locale || I18n.default_locale) do
-          super
+        result = Globalize.with_locale(translation.locale || I18n.default_locale) do
+          without_fallbacks do
+            super
+          end
         end
+        if result
+          globalize.clear_dirty
+        end
+
+        result
       end
 
       def column_for_attribute name
@@ -163,6 +165,16 @@ module Globalize
         [super, translation.cache_key].join("/")
       end
 
+      def changed?
+        changed_attributes.present? || translations.any?(&:changed?)
+      end
+
+      # need to access instance variable directly since changed_attributes
+      # is frozen as of Rails 4.2
+      def original_changed_attributes
+        @changed_attributes
+      end
+
     protected
 
       def each_locale_and_translated_attribute
@@ -184,15 +196,23 @@ module Globalize
         translation_caches.clear
       end
 
-      def with_given_locale(attributes, &block)
-        attributes.symbolize_keys! if attributes.respond_to?(:symbolize_keys!)
+      def with_given_locale(_attributes, &block)
+        attributes = _attributes.stringify_keys
 
-        if locale = attributes.try(:delete, :locale)
+        if locale = attributes.try(:delete, "locale")
           Globalize.with_locale(locale, &block)
         else
           yield
         end
       end
+
+      def without_fallbacks
+        before = self.fallbacks_for_empty_translations
+        self.fallbacks_for_empty_translations = false
+        yield
+      ensure
+        self.fallbacks_for_empty_translations = before
+      end
     end
   end
 end