globalize 5.0.1 → 5.1.0

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,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
@@ -100,8 +113,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

data/lib/globalize/active_record/migration.rb

@@ -3,20 +3,18 @@ require 'digest/sha1'
 module Globalize
   module ActiveRecord
     module Migration
-      attr_reader :globalize_migrator
-
       def globalize_migrator
         @globalize_migrator ||= Migrator.new(self)
       end
 
-      delegate :create_translation_table!, :add_translation_fields!, :drop_translation_table!,
-        :translation_index_name, :translation_locale_index_name,
-        :to => :globalize_migrator
+      delegate :create_translation_table!, :add_translation_fields!,
+        :drop_translation_table!, :translation_index_name,
+        :translation_locale_index_name, :to => :globalize_migrator
 
       class Migrator
         include Globalize::ActiveRecord::Exceptions
 
-        attr_reader :model, :fields
+        attr_reader :model
         delegate :translated_attribute_names, :connection, :table_name,
           :table_name_prefix, :translations_table_name, :columns, :to => :model
 
@@ -24,7 +22,15 @@ module Globalize
           @model = model
         end
 
+        def fields
+          @fields ||= complete_translated_fields
+        end
+
         def create_translation_table!(fields = {}, options = {})
+          extra = options.keys - [:migrate_data, :remove_source_columns, :unique_index]
+          if extra.any?
+            raise ArgumentError, "Unknown migration #{'option'.pluralize(extra.size)}: #{extra}"
+          end
           @fields = fields
           # If we have fields we only want to create the translation table with those fields
           complete_translated_fields if fields.blank?
@@ -32,14 +38,13 @@ module Globalize
 
           create_translation_table
           add_translation_fields!(fields, options)
-          create_translations_index
+          create_translations_index(options)
           clear_schema_cache!
         end
 
         def add_translation_fields!(fields, options = {})
           @fields = fields
           validate_translated_fields
-
           add_translation_fields
           clear_schema_cache!
           move_data_to_translation_table if options[:migrate_data]
@@ -48,7 +53,12 @@ module Globalize
         end
 
         def remove_source_columns
-          connection.remove_columns(table_name, *fields.keys)
+          column_names = *fields.keys
+          column_names.each do |column|
+            if connection.column_exists?(table_name, column)
+              connection.remove_column(table_name, column)
+            end
+          end
         end
 
         def drop_translation_table!(options = {})
@@ -62,13 +72,13 @@ module Globalize
         # It's a problem because in early migrations would add all the translated attributes
         def complete_translated_fields
           translated_attribute_names.each do |name|
-            fields[name] ||= column_type(name)
+            @fields[name] ||= column_type(name)
           end
         end
 
         def create_translation_table
           connection.create_table(translations_table_name) do |t|
-            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize, :null => false
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize, :null => false, :index => false, :type => column_type(model.primary_key).to_sym
             t.string :locale, :null => false
             t.timestamps :null => false
           end
@@ -86,10 +96,11 @@ module Globalize
           end
         end
 
-        def create_translations_index
+        def create_translations_index(options)
+          foreign_key = "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id".to_sym
           connection.add_index(
             translations_table_name,
-            "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
+            foreign_key,
             :name => translation_index_name
           )
           # index for select('DISTINCT locale') call in translation.rb
@@ -98,6 +109,15 @@ module Globalize
             :locale,
             :name => translation_locale_index_name
           )
+
+          if options[:unique_index]
+            connection.add_index(
+              translations_table_name,
+              [foreign_key, :locale],
+              :name => translation_unique_index_name,
+              unique: true
+            )
+          end
         end
 
         def drop_translation_table
@@ -105,12 +125,17 @@ module Globalize
         end
 
         def drop_translations_index
-          connection.remove_index(translations_table_name, :name => translation_index_name)
+          if connection.indexes(translations_table_name).map(&:name).include?(translation_index_name)
+            connection.remove_index(translations_table_name, :name => translation_index_name)
+          end
+          if connection.indexes(translations_table_name).map(&:name).include?(translation_locale_index_name)
+            connection.remove_index(translations_table_name, :name => translation_locale_index_name)
+          end
         end
 
         def move_data_to_translation_table
           model.find_each do |record|
-            translation = record.translation_for(I18n.default_locale) || record.translations.build(:locale => I18n.default_locale)
+            translation = record.translation_for(I18n.locale) || record.translations.build(:locale => I18n.locale)
             fields.each do |attribute_name, attribute_type|
               translation[attribute_name] = record.read_attribute(attribute_name, {:translated => false})
             end
@@ -122,7 +147,7 @@ module Globalize
           add_missing_columns
 
           # Find all of the translated attributes for all records in the model.
-          all_translated_attributes = @model.all.collect{|m| m.attributes}
+          all_translated_attributes = model.all.collect{|m| m.attributes}
           all_translated_attributes.each do |translated_record|
             # Create a hash containing the translated column names and their values.
             translated_attribute_names.inject(fields_to_update={}) do |f, name|
@@ -130,15 +155,13 @@ module Globalize
             end
 
             # Now, update the actual model's record with the hash.
-            @model.where(:id => translated_record['id']).update_all(fields_to_update)
+            model.where(model.primary_key.to_sym => translated_record[model.primary_key]).update_all(fields_to_update)
           end
         end
 
         def validate_translated_fields
           fields.each do |name, options|
             raise BadFieldName.new(name) unless valid_field_name?(name)
-            type = (options.is_a? Hash) ? options[:type] : options
-            raise BadFieldType.new(name, type) unless valid_field_type?(name, type)
           end
         end
 
@@ -150,20 +173,16 @@ module Globalize
           translated_attribute_names.include?(name)
         end
 
-        def valid_field_type?(name, type)
-          !translated_attribute_names.include?(name) || [:string, :text].include?(type)
-        end
-
         def translation_index_name
-          index_name = "index_#{translations_table_name}_on_#{table_name.singularize}_id"
-          index_name.size < connection.index_name_length ? index_name :
-            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+          truncate_index_name "index_#{translations_table_name}_on_#{table_name.singularize}_id"
         end
 
         def translation_locale_index_name
-          index_name = "index_#{translations_table_name}_on_locale"
-          index_name.size < connection.index_name_length ? index_name :
-            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+          truncate_index_name "index_#{translations_table_name}_on_locale"
+        end
+
+        def translation_unique_index_name
+          truncate_index_name "index_#{translations_table_name}_on_#{table_name.singularize}_id_and_locale"
         end
 
         def clear_schema_cache!
@@ -174,14 +193,22 @@ module Globalize
 
         private
 
+        def truncate_index_name(index_name)
+          if index_name.size < connection.index_name_length
+            index_name
+          else
+            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+          end
+        end
+
         def add_missing_columns
+          clear_schema_cache!
           translated_attribute_names.map(&:to_s).each do |attribute|
             unless model.column_names.include?(attribute)
               connection.add_column(table_name, attribute, model::Translation.columns_hash[attribute].type)
             end
           end
         end
-
       end
     end
   end

data/lib/globalize/active_record/query_methods.rb

@@ -1,10 +1,9 @@
 module Globalize
   module ActiveRecord
     module QueryMethods
-
       class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
         def not(opts, *rest)
-          if parsed = @scope.parse_translated_conditions(opts)
+          if parsed = @scope.clone.parse_translated_conditions(opts)
             @scope.join_translations.where.not(parsed, *rest)
           else
             super
@@ -24,7 +23,7 @@ module Globalize
 
       def order(opts, *rest)
         if respond_to?(:translated_attribute_names) && parsed = parse_translated_order(opts)
-          super(parsed)
+          join_translations super(parsed)
         else
           super
         end
@@ -50,19 +49,21 @@ module Globalize
         end
       end
 
-      def where_values_hash(*args)
-        return super unless respond_to?(:translations_table_name)
-        equalities = respond_to?(:with_default_scope) ? with_default_scope.where_values : where_values
-        equalities = equalities.grep(Arel::Nodes::Equality).find_all { |node|
-          node.left.relation.name == translations_table_name
-        }
+      if ::ActiveRecord::VERSION::STRING < "5.0.0"
+        def where_values_hash(*args)
+          return super unless respond_to?(:translations_table_name)
+          equalities = respond_to?(:with_default_scope) ? with_default_scope.where_values : where_values
+          equalities = equalities.grep(Arel::Nodes::Equality).find_all { |node|
+            node.left.relation.name == translations_table_name
+          }
 
-        binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
+          binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
 
-        super.merge(Hash[equalities.map { |where|
-          name = where.left.name
-          [name, binds.fetch(name.to_s) { right = where.right; right.is_a?(Arel::Nodes::Casted) ? right.val : right }]
-        }])
+          super.merge(Hash[equalities.map { |where|
+            name = where.left.name
+            [name, binds.fetch(name.to_s) { right = where.right; right.is_a?(Arel::Nodes::Casted) ? right.val : right }]
+          }])
+        end
       end
 
       def join_translations(relation = self)
@@ -75,16 +76,40 @@ module Globalize
 
       private
 
+      def arel_translated_order_node(column, direction)
+        unless translated_column?(column)
+          return self.arel_table[column].send(direction)
+        end
+
+        full_column = translated_column_name(column)
+
+        # Inject `full_column` to the select values to avoid
+        # PG::InvalidColumnReference errors with distinct queries on Postgres
+        if select_values.empty?
+          self.select_values = [self.arel_table[Arel.star], full_column]
+        else
+          self.select_values << full_column
+        end
+
+        translation_class.arel_table[column].send(direction)
+      end
+
       def parse_translated_order(opts)
         case opts
         when Hash
+          # Do not process nothing unless there is at least a translated column
+          # so that the `order` statement will be processed by the original
+          # ActiveRecord method
+          return nil unless opts.find { |col, dir| translated_column?(col) }
+
+          # Build order arel nodes for translateds and untranslateds statements
           ordering = opts.map do |column, direction|
-            klass = translated_column?(column) ? translation_class : self
-            klass.arel_table[column].send(direction)
+            arel_translated_order_node(column, direction)
           end
+
           order(ordering).order_values
         when Symbol
-          translated_column_name(opts) if translated_attribute_names.include?(opts)
+          parse_translated_order({ opts => :asc })
         else # failsafe returns nothing
           nil
         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/version.rb

@@ -1,3 +1,3 @@
 module Globalize
-  Version = '5.0.1'
+  Version = '5.1.0'
 end