globalize 5.0.1 → 5.1.0.beta1

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]
@@ -62,13 +67,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 +91,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 +104,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 +120,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 +142,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 +150,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 +168,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 +188,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 = [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/version.rb

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

data/lib/patches/active_record/persistence.rb

@@ -1,26 +1,17 @@
-module ActiveRecord
+module Globalize
   module Persistence
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
     def _update_record(attribute_names = self.attribute_names)
       attribute_names_without_translated = attribute_names.select{ |k| not respond_to?('translated?') or not translated?(k) }
-      attributes_values = arel_attributes_with_values_for_update(attribute_names_without_translated)
-      if attributes_values.empty?
-        0
-      else
-        self.class.unscoped._update_record attributes_values, id, id_was
-      end
+      super(attribute_names_without_translated)
     end
 
     def _create_record(attribute_names = self.attribute_names)
       attribute_names_without_translated = attribute_names.select{ |k| not respond_to?('translated?') or not translated?(k) }
-      attributes_values = arel_attributes_with_values_for_create(attribute_names_without_translated)
-
-      new_id = self.class.unscoped.insert attributes_values
-      self.id ||= new_id if self.class.primary_key
-
-      @new_record = false
-      id
+      super(attribute_names_without_translated)
     end
   end
-end
+end
+
+ActiveRecord::Persistence.send(:prepend, Globalize::Persistence)

data/lib/patches/active_record/query_method.rb

@@ -1,35 +1,3 @@
-require 'active_record/attribute_methods/query'
-
-module ActiveRecord
-  module AttributeMethods
-    module Query
-      def query_attribute(attr_name)
-        unless value = read_attribute(attr_name)
-          false
-        else
-          column = self.class.columns_hash[attr_name]
-          if column.nil?
-            
-            # TODO submit a rails patch
-
-            # not sure what active_record tests say but i guess this should mean:
-            # call to_i and check zero? if the value is a Numeric or starts with
-            # a digit, so it can meaningfully be typecasted by to_i
-
-            # if Numeric === value || value !~ /[^0-9]/
-            if Numeric === value || value.to_s =~ /^[0-9]/
-              !value.to_i.zero?
-            else
-              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
-              !value.blank?
-            end
-          elsif column.number?
-            !value.zero?
-          else
-            !value.blank?
-          end
-        end
-      end
-    end
-  end
+if ::ActiveRecord::VERSION::STRING < "5.0.0"
+  require_relative 'rails4/query_method'
 end

data/lib/patches/active_record/rails4/query_method.rb

@@ -0,0 +1,35 @@
+require 'active_record/attribute_methods/query'
+
+module ActiveRecord
+  module AttributeMethods
+    module Query
+      def query_attribute(attr_name)
+        unless value = read_attribute(attr_name)
+          false
+        else
+          column = self.class.columns_hash[attr_name]
+          if column.nil?
+
+            # TODO submit a rails patch
+
+            # not sure what active_record tests say but i guess this should mean:
+            # call to_i and check zero? if the value is a Numeric or starts with
+            # a digit, so it can meaningfully be typecasted by to_i
+
+            # if Numeric === value || value !~ /[^0-9]/
+            if Numeric === value || value.to_s =~ /^[0-9]/
+              !value.to_i.zero?
+            else
+              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif column.number?
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/patches/active_record/rails4/uniqueness_validator.rb

@@ -0,0 +1,42 @@
+require 'active_record/validations/uniqueness.rb'
+
+module Globalize
+  module UniquenessValidatorOverride
+    def validate_each(record, attribute, value)
+      klass = record.class
+      if klass.translates? && klass.translated?(attribute)
+        finder_class = klass.translation_class
+        table = finder_class.arel_table
+
+        relation = build_relation(finder_class, table, attribute, value).and(table[:locale].eq(Globalize.locale))
+        relation = relation.and(table[klass.reflect_on_association(:translations).foreign_key].not_eq(record.send(:id))) if record.persisted?
+
+        translated_scopes = Array(options[:scope]) & klass.translated_attribute_names
+        untranslated_scopes = Array(options[:scope]) - translated_scopes
+
+        untranslated_scopes.each do |scope_item|
+          scope_value = record.send(scope_item)
+          reflection = klass.reflect_on_association(scope_item)
+          if reflection
+            scope_value = record.send(reflection.foreign_key)
+            scope_item = reflection.foreign_key
+          end
+          relation = relation.and(find_finder_class_for(record).arel_table[scope_item].eq(scope_value))
+        end
+
+        translated_scopes.each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.and(table[scope_item].eq(scope_value))
+        end
+
+        if klass.unscoped.with_translations.where(relation).exists?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      else
+        super
+      end
+    end
+  end
+end
+
+ActiveRecord::Validations::UniquenessValidator.send :prepend, Globalize::UniquenessValidatorOverride