globalize 5.1.0.beta1 → 5.3.1

data/lib/globalize/active_record/instance_methods.rb

@@ -17,10 +17,24 @@ module Globalize
         with_given_locale(attributes) { super(attributes.except("locale"), *options) }
       end
 
-      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) }
+      if Globalize.rails_52?
+
+        # 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
+
+      else
+
+        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
+
       end
 
       def write_attribute(name, value, *args, &block)
@@ -39,19 +53,21 @@ module Globalize
         end
       end
 
-      def read_attribute(name, options = {}, &block)
-        options = {:translated => true, :locale => nil}.merge(options)
-        return super(name, &block) unless options[:translated]
+      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
 
-        if translated?(name)
-          if !(value = globalize.fetch(options[:locale] || Globalize.locale, name)).nil?
-            value
-          else
-            super(name, &block)
-          end
-        else
-          super(name, &block)
-        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)
+        translated_value.nil? ? super(attr_name, &block) : translated_value
       end
 
       def attribute_names
@@ -213,6 +229,15 @@ module Globalize
       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)
+
+        globalize.fetch(options[:locale] || Globalize.locale, name)
+      end
     end
   end
 end

data/lib/globalize/active_record/migration.rb

@@ -53,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 = {})
@@ -73,7 +78,11 @@ module Globalize
 
         def create_translation_table
           connection.create_table(translations_table_name) do |t|
-            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize, :null => false, :index => false, :type => column_type(model.primary_key).to_sym
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize,
+                         :null => false,
+                         :index => false,
+                         :type => column_type(model.primary_key).try(:to_sym),
+                         :limit => model.columns.detect { |c| c.name == model.primary_key }.try(:limit)
             t.string :locale, :null => false
             t.timestamps :null => false
           end
@@ -161,7 +170,7 @@ module Globalize
         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)

data/lib/globalize/active_record/{query_methods.rb → translated_attributes_query.rb}

@@ -1,6 +1,6 @@
 module Globalize
   module ActiveRecord
-    module QueryMethods
+    module TranslatedAttributesQuery
       class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
         def not(opts, *rest)
           if parsed = @scope.clone.parse_translated_conditions(opts)
@@ -21,6 +21,14 @@ module Globalize
         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)
@@ -29,6 +37,30 @@ module Globalize
         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)
@@ -37,6 +69,24 @@ module Globalize
         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
@@ -86,7 +136,7 @@ module Globalize
         # 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]
+          self.select_values = [self.arel_table[Arel.star], full_column]
         else
           self.select_values << full_column
         end
@@ -110,11 +160,19 @@ module Globalize
           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

data/lib/globalize/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Globalize
-  Version = '5.1.0.beta1'
+  Version = '5.3.1'
 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/rails5_1/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(attr_name, 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/rails5_1/uniqueness_validator.rb

@@ -0,0 +1,45 @@
+module Globalize
+  module Validations
+    module UniquenessValidator
+      def validate_each(record, attribute, value)
+        klass = record.class
+        if klass.translates? && klass.translated?(attribute)
+          finder_class = klass.translation_class
+          relation = build_relation(finder_class, attribute, value).where(locale: Globalize.locale)
+          relation = relation.where.not(klass.reflect_on_association(:translations).foreign_key => record.send(:id)) if record.persisted?
+
+
+          translated_scopes = Array(options[:scope]) & klass.translated_attribute_names
+          untranslated_scopes = Array(options[:scope]) - translated_scopes
+
+          relation = relation.joins(:globalized_model) if untranslated_scopes.present?
+          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.where(find_finder_class_for(record).table_name => { scope_item => scope_value })
+          end
+
+          translated_scopes.each do |scope_item|
+            scope_value = record.send(scope_item)
+            relation = relation.where(scope_item => scope_value)
+          end
+          relation = relation.merge(options[:conditions]) if options[:conditions]
+
+          if relation.exists?
+            error_options = options.except(:case_sensitive, :scope, :conditions)
+            error_options[:value] = value
+            record.errors.add(attribute, :taken, error_options)
+          end
+        else
+          super(record, attribute, value)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Validations::UniquenessValidator.prepend Globalize::Validations::UniquenessValidator

data/lib/patches/active_record/serialization.rb

@@ -1,21 +1,5 @@
-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[attr_name] = coder
-      end
-    end
-  end
-end
-
-ActiveRecord::AttributeMethods::Serialization::ClassMethods.send(:prepend, Globalize::AttributeMethods::Serialization)
+if ::ActiveRecord::VERSION::STRING < "5.1.0"
+  require_relative 'rails4/serialization'
+else
+  require_relative 'rails5_1/serialization'
+end

data/lib/patches/active_record/uniqueness_validator.rb

@@ -1,5 +1,7 @@
 if ::ActiveRecord::VERSION::STRING < "5.0.0"
   require_relative 'rails4/uniqueness_validator'
-else
+elsif ::ActiveRecord::VERSION::STRING < "5.1.0"
   require_relative 'rails5/uniqueness_validator'
+else
+  require_relative 'rails5_1/uniqueness_validator'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: globalize
 version: !ruby/object:Gem::Version
-  version: 5.1.0.beta1
+  version: 5.3.1
 platform: ruby
 authors:
 - Sven Fuchs
@@ -11,10 +11,10 @@ authors:
 - Tomasz Stachewicz
 - Philip Arndt
 - Chris Salzberg
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2021-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -25,7 +25,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -35,7 +35,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -45,7 +45,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -55,7 +55,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: request_store
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +70,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
@@ -84,6 +98,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -113,7 +141,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -140,19 +168,50 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rails I18n de-facto standard library for ActiveRecord model/data translation.
 email: nobody@globalize-rails.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Appraisals
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
+- docker-compose.yml
+- globalize.gemspec
+- issue_template.rb
 - lib/globalize.rb
 - lib/globalize/active_record.rb
 - lib/globalize/active_record/act_macro.rb
@@ -163,7 +222,7 @@ files:
 - lib/globalize/active_record/exceptions.rb
 - lib/globalize/active_record/instance_methods.rb
 - lib/globalize/active_record/migration.rb
-- lib/globalize/active_record/query_methods.rb
+- lib/globalize/active_record/translated_attributes_query.rb
 - lib/globalize/active_record/translation.rb
 - lib/globalize/interpolation.rb
 - lib/globalize/version.rb
@@ -172,8 +231,11 @@ files:
 - lib/patches/active_record/persistence.rb
 - lib/patches/active_record/query_method.rb
 - lib/patches/active_record/rails4/query_method.rb
+- lib/patches/active_record/rails4/serialization.rb
 - lib/patches/active_record/rails4/uniqueness_validator.rb
 - lib/patches/active_record/rails5/uniqueness_validator.rb
+- lib/patches/active_record/rails5_1/serialization.rb
+- lib/patches/active_record/rails5_1/uniqueness_validator.rb
 - lib/patches/active_record/relation.rb
 - lib/patches/active_record/serialization.rb
 - lib/patches/active_record/uniqueness_validator.rb
@@ -182,7 +244,7 @@ homepage: http://github.com/globalize/globalize
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -190,16 +252,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.4.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: "[none]"
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Rails I18n de-facto standard library for ActiveRecord model/data translation
 test_files: []