globalize 5.0.1 → 5.2.0

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,40 +155,34 @@ 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
 
         def column_type(name)
-          columns.detect { |c| c.name == name.to_s }.try(:type)
+          columns.detect { |c| c.name == name.to_s }.try(:type) || :string
         end
 
         def valid_field_name?(name)
           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/translated_attributes_query.rb

@@ -0,0 +1,181 @@
+module Globalize
+  module ActiveRecord
+    module TranslatedAttributesQuery
+      class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
+        def not(opts, *rest)
+          if parsed = @scope.clone.parse_translated_conditions(opts)
+            @scope.join_translations.where.not(parsed, *rest)
+          else
+            super
+          end
+        end
+      end
+
+      def where(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif parsed = parse_translated_conditions(opts)
+          join_translations(super(parsed, *rest))
+        else
+          super
+        end
+      end
+
+      def having(opts, *rest)
+        if parsed = parse_translated_conditions(opts)
+          join_translations(super(parsed, *rest))
+        else
+          super
+        end
+      end
+
+      def order(opts, *rest)
+        if respond_to?(:translated_attribute_names) && parsed = parse_translated_order(opts)
+          join_translations super(parsed)
+        else
+          super
+        end
+      end
+
+      def reorder(opts, *rest)
+        if respond_to?(:translated_attribute_names) && parsed = parse_translated_order(opts)
+          join_translations super(parsed)
+        else
+          super
+        end
+      end
+
+      def group(*columns)
+        if respond_to?(:translated_attribute_names) && parsed = parse_translated_columns(columns)
+          join_translations super(parsed)
+        else
+          super
+        end
+      end
+
+      def select(*columns)
+        if respond_to?(:translated_attribute_names) && parsed = parse_translated_columns(columns)
+          join_translations super(parsed)
+        else
+          super
+        end
+      end
+
+      def exists?(conditions = :none)
+        if parsed = parse_translated_conditions(conditions)
+          with_translations_in_fallbacks.exists?(parsed)
+        else
+          super
+        end
+      end
+
+      def calculate(*args)
+        column_name = args[1]
+        if respond_to?(:translated_attribute_names) && translated_column?(column_name)
+          args[1] = translated_column_name(column_name)
+          join_translations.calculate(*args)
+        else
+          super
+        end
+      end
+
+      def pluck(*column_names)
+        if respond_to?(:translated_attribute_names) && parsed = parse_translated_columns(column_names)
+          join_translations.pluck(*parsed)
+        else
+          super
+        end
+      end
+
+      def with_translations_in_fallbacks
+        with_translations(Globalize.fallbacks)
+      end
+
+      def parse_translated_conditions(opts)
+        if opts.is_a?(Hash) && respond_to?(:translated_attribute_names) && (keys = opts.symbolize_keys.keys & translated_attribute_names).present?
+          opts = opts.dup
+          keys.each { |key| opts[translated_column_name(key)] = opts.delete(key) || opts.delete(key.to_s) }
+          opts
+        end
+      end
+
+      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] }]
+
+          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)
+        if relation.joins_values.include?(:translations)
+          relation
+        else
+          relation.with_translations_in_fallbacks
+        end
+      end
+
+      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|
+            arel_translated_order_node(column, direction)
+          end
+
+          order(ordering).order_values
+        when Symbol
+          parse_translated_order({ opts => :asc })
+        when Array
+          parse_translated_order(Hash[opts.collect { |opt| [opt, :asc] } ])
+        else # failsafe returns nothing
+          nil
+        end
+      end
+
+      def parse_translated_columns(columns)
+        if columns.is_a?(Array) && (columns.flatten & translated_attribute_names).present?
+          columns.flatten.map { |column| translated_column?(column) ? translated_column_name(column) : column }
+        end
+      end
+
+      def translated_column?(column)
+        translated_attribute_names.include?(column)
+      end
+    end
+  end
+end

data/lib/globalize/active_record.rb

@@ -1,13 +1,14 @@
 module Globalize
   module ActiveRecord
-    autoload :ActMacro,        'globalize/active_record/act_macro'
-    autoload :Adapter,         'globalize/active_record/adapter'
-    autoload :Attributes,      'globalize/active_record/attributes'
-    autoload :ClassMethods,    'globalize/active_record/class_methods'
-    autoload :Exceptions,      'globalize/active_record/exceptions'
-    autoload :InstanceMethods, 'globalize/active_record/instance_methods'
-    autoload :Migration,       'globalize/active_record/migration'
-    autoload :Translation,     'globalize/active_record/translation'
-    autoload :QueryMethods,    'globalize/active_record/query_methods'
+    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'
+    autoload :InstanceMethods,              'globalize/active_record/instance_methods'
+    autoload :Migration,                    'globalize/active_record/migration'
+    autoload :Translation,                  'globalize/active_record/translation'
+    autoload :TranslatedAttributesQuery,    'globalize/active_record/translated_attributes_query'
   end
 end

data/lib/globalize/version.rb

@@ -1,3 +1,3 @@
 module Globalize
-  Version = '5.0.1'
+  Version = '5.2.0'
 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,31 @@ module Globalize
       i18n_fallbacks? ? I18n.fallbacks[for_locale] : [for_locale.to_sym]
     end
 
+    # Thread-safe global storage
+    def storage
+      RequestStore.store
+    end
+
+    def rails_5?
+      ::ActiveRecord.version >= Gem::Version.new('5.1.0')
+    end
+
+    def rails_52?
+      ::ActiveRecord.version >= Gem::Version.new('5.2.0')
+    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,12 +87,12 @@ module Globalize
         fallback_hash[key] = value.presence || [key]
       end if locales.present?
 
-      @fallbacks = fallback_hash
+      storage[:globalize_fallbacks] = fallback_hash
     end
   end
 end
 
-ActiveRecord::Base.mattr_accessor :globalize_serialized_attributes, instance_writer: false
+ActiveRecord::Base.class_attribute :globalize_serialized_attributes, instance_writer: false
 ActiveRecord::Base.globalize_serialized_attributes = {}
 
 ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)

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/serialization.rb

@@ -0,0 +1,22 @@
+module Globalize
+  module AttributeMethods
+    module Serialization
+      def serialize(attr_name, class_name_or_coder = Object)
+        super(attr_name, class_name_or_coder)
+
+        coder = if class_name_or_coder == ::JSON
+                  ::ActiveRecord::Coders::JSON
+                elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                  class_name_or_coder
+                else
+                  ::ActiveRecord::Coders::YAMLColumn.new(class_name_or_coder)
+                end
+
+        self.globalize_serialized_attributes = globalize_serialized_attributes.dup
+        self.globalize_serialized_attributes[attr_name] = coder
+      end
+    end
+  end
+end
+
+ActiveRecord::AttributeMethods::Serialization::ClassMethods.send(:prepend, Globalize::AttributeMethods::Serialization)

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