globalize 5.0.1 → 5.2.0

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/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,30 @@ module Globalize
           # Add attribute to the list.
           self.translated_attribute_names << attr_name
         end
+
+        begin
+          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
+        rescue ::ActiveRecord::NoDatabaseError
+          warn 'Unable to connect to a database. Globalize skipped ignoring columns of translated attributes.'
+        end
+      end
+
+      def check_columns!(attr_names)
+        # If tables do not exist or Rails version is greater than 5, do not warn about conflicting columns
+        return unless ::ActiveRecord::VERSION::STRING < "5.0" && 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
+      rescue ::ActiveRecord::NoDatabaseError
+        warn 'Unable to connect to a database. Globalize skipped checking attributes with conflicting column names.'
       end
 
       def apply_globalize_options(options)
@@ -74,7 +99,8 @@ module Globalize
                                 :foreign_key => options[:foreign_key],
                                 :dependent   => :destroy,
                                 :extend      => HasManyExtensions,
-                                :autosave    => false
+                                :autosave    => false,
+                                :inverse_of  => :globalized_model
 
         after_create :save_translations!
         after_update :save_translations!

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,14 +34,16 @@ 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
@@ -57,7 +59,8 @@ module Globalize
 
       # 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
+        # AR >= 4.1 reflections renamed to _reflections
+        translation[translation.class.reflections.stringify_keys["globalized_model"].foreign_key] = record.id
       end
 
       def type_cast(name, value)
@@ -76,7 +79,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 +102,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,56 @@
+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.send(:clear_attribute_changes, [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,17 @@ 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,
+            touch: translation_options.fetch(:touch, false)
           klass
         end
       end
@@ -63,10 +76,10 @@ module Globalize
       private
 
       # Override the default relation method in order to return a subclass
-      # of ActiveRecord::Relation with custom finder methods for translated
-      # attributes.
+      # of ActiveRecord::Relation with custom finder and calculation methods
+      # for translated attributes.
       def relation
-        super.extending!(QueryMethods)
+        super.extending!(TranslatedAttributesQuery)
       end
 
       protected
@@ -85,6 +98,7 @@ module Globalize
       end
 
       def define_translated_attr_accessor(name)
+        attribute(name, ::ActiveRecord::Type::Value.new)
         define_translated_attr_reader(name)
         define_translated_attr_writer(name)
       end
@@ -100,8 +114,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,51 +11,65 @@ 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 }
-      end
+      if Globalize.rails_52?
 
-      def write_attribute(name, value, options = {})
-        return super(name, value) unless translated?(name)
+        # In Rails 5.2 we need to override *_assign_attributes* as it's called earlier
+        # in the stack (before *assign_attributes*)
+        # See https://github.com/rails/rails/blob/master/activerecord/lib/active_record/attribute_assignment.rb#L11
+        def _assign_attributes(new_attributes)
+          attributes = new_attributes.stringify_keys
+          with_given_locale(attributes) { super(attributes.except("locale")) }
+        end
 
-        options = {:locale => Globalize.locale}.merge(options)
+      else
 
-        # 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
-        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
+        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
 
-        globalize.write(options[:locale], name, value)
       end
 
-      def read_attribute(name, options = {})
-        options = {:translated => true, :locale => nil}.merge(options)
-        return super(name) unless options[:translated]
+      def write_attribute(name, value, *args, &block)
+        return super(name, value, *args, &block) unless translated?(name)
 
-        if translated?(name)
-          if (value = globalize.fetch(options[:locale] || Globalize.locale, name))
-            value
-          else
-            super(name)
-          end
+        options = {:locale => Globalize.locale}.merge(args.first || {})
+
+        globalize.write(options[:locale], name, value)
+      end
+
+      def [](attr_name)
+        if translated?(attr_name)
+          read_attribute(attr_name)
         else
-          super(name)
+          read_attribute(attr_name) { |n| missing_attribute(n, caller) }
         end
       end
 
+      def read_attribute(attr_name, options = {}, &block)
+        name = if self.class.attribute_alias?(attr_name)
+                 self.class.attribute_alias(attr_name).to_s
+               else
+                 attr_name.to_s
+               end
+
+        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
+
+        _read_attribute(name, options, &block)
+      end
+
+      def _read_attribute(attr_name, options = {}, &block)
+        translated_value = read_translated_attribute(attr_name, options, &block)
+        translated_value.nil? ? super(attr_name, &block) : translated_value
+      end
+
       def attribute_names
         translated_attribute_names.map(&:to_s) + super
       end
@@ -83,8 +97,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 +158,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 +181,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 +212,35 @@ 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
+
+      # nil or value
+      def read_translated_attribute(name, options)
+        options = {:translated => true, :locale => nil}.merge(options)
+        return nil unless options[:translated]
+        return nil unless translated?(name)
+
+        value = globalize.fetch(options[:locale] || Globalize.locale, name)
+        return nil if value.nil?
+
+        block_given? ? yield(value) : value
+      end
     end
   end
 end