globalize 5.0.1 → 5.2.0

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

@@ -0,0 +1,47 @@
+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
+          finder_table = finder_class.arel_table
+          relation = build_relation(finder_class, finder_table, 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 klass.unscoped.with_translations.where(relation).exists?
+          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/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/relation.rb

@@ -0,0 +1,12 @@
+if ::ActiveRecord::VERSION::STRING >= "5.0.0"
+  module Globalize
+    module Relation
+      def where_values_hash(relation_table_name = table_name)
+        return super unless respond_to?(:translations_table_name)
+        super.merge(super(translations_table_name))
+      end
+    end
+  end
+
+  ActiveRecord::Relation.prepend Globalize::Relation
+end

data/lib/patches/active_record/serialization.rb

@@ -1,24 +1,5 @@
-module ActiveRecord
-  module AttributeMethods
-    module Serialization
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def serialize_with_globalize(attr_name, class_name_or_coder = Object)
-          serialize_without_globalize(attr_name, class_name_or_coder)
-
-          coder = if class_name_or_coder == ::JSON
-                    Coders::JSON
-                  elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
-                    class_name_or_coder
-                  else
-                    Coders::YAMLColumn.new(class_name_or_coder)
-                  end
-
-          self.globalize_serialized_attributes[attr_name] = coder
-        end
-        alias_method_chain :serialize, :globalize
-      end
-    end
-  end
-end
+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,39 +1,7 @@
-require 'active_record/validations/uniqueness.rb'
-
-ActiveRecord::Validations::UniquenessValidator.class_eval do
-  def validate_each_with_translations(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
-      validate_each_without_translations(record, attribute, value)
-    end
-  end
-  alias_method_chain :validate_each, :translations
-end
+if ::ActiveRecord::VERSION::STRING < "5.0.0"
+  require_relative 'rails4/uniqueness_validator'
+elsif ::ActiveRecord::VERSION::STRING < "5.1.0"
+  require_relative 'rails5/uniqueness_validator'
+else
+  require_relative 'rails5_1/uniqueness_validator'
+end

data/lib/patches/active_record/xml_attribute_serializer.rb

@@ -1,13 +1,23 @@
-require 'active_record/serializers/xml_serializer'
+begin
+  require 'active_record/serializers/xml_serializer'
+rescue LoadError
+end
 
-ActiveRecord::XmlSerializer::Attribute.class_eval do
-  def compute_type_with_translations
-    klass = @serializable.class
-    if klass.translates? && klass.translated_attribute_names.include?(name.to_sym)
-      :string
-    else
-      compute_type_without_translations
+module Globalize
+  module XmlSerializer
+    module Attribute
+      def compute_type
+        klass = @serializable.class
+        if klass.translates? && klass.translated_attribute_names.include?(name.to_sym)
+          :string
+        else
+          super
+        end
+      end
     end
   end
-  alias_method_chain :compute_type, :translations
+end
+
+if defined?(ActiveRecord::XmlSerializer)
+  ActiveRecord::XmlSerializer::Attribute.send(:prepend, Globalize::XmlSerializer::Attribute)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: globalize
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.2.0
 platform: ruby
 authors:
 - Sven Fuchs
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-15 00:00:00.000000000 Z
+date: 2018-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -22,54 +22,96 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.3'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.3'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: request_store
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :development
+        version: '1.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        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
+    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: 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
@@ -99,7 +141,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: pry
+  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: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -127,7 +183,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -146,23 +202,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Appraisals
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
+- README.md
 - Rakefile
-- globalize.gemspec
 - lib/globalize.rb
 - lib/globalize/active_record.rb
 - lib/globalize/active_record/act_macro.rb
 - lib/globalize/active_record/adapter.rb
+- lib/globalize/active_record/adapter_dirty.rb
 - lib/globalize/active_record/attributes.rb
 - lib/globalize/active_record/class_methods.rb
 - 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
@@ -170,10 +228,16 @@ files:
 - lib/i18n/missing_translations_raise_handler.rb
 - 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
 - lib/patches/active_record/xml_attribute_serializer.rb
-- readme.md
 homepage: http://github.com/globalize/globalize
 licenses:
 - MIT
@@ -186,7 +250,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -194,9 +258,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: "[none]"
-rubygems_version: 2.4.5
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Rails I18n de-facto standard library for ActiveRecord model/data translation
 test_files: []
-has_rdoc: 

data/globalize.gemspec

@@ -1,29 +0,0 @@
-require File.expand_path('../lib/globalize/version', __FILE__)
-
-Gem::Specification.new do |s|
-  s.name         = 'globalize'
-  s.version      = Globalize::Version
-  s.authors      = ['Sven Fuchs', 'Joshua Harvey', 'Clemens Kofler', 'John-Paul Bader', 'Tomasz Stachewicz', 'Philip Arndt', 'Chris Salzberg']
-  s.email        = 'nobody@globalize-rails.org'
-  s.homepage     = 'http://github.com/globalize/globalize'
-  s.summary      = 'Rails I18n de-facto standard library for ActiveRecord model/data translation'
-  s.description  = "#{s.summary}."
-  s.license      = "MIT"
-
-  s.files        = Dir['{lib/**/*,[A-Z]*}']
-  s.platform     = Gem::Platform::RUBY
-  s.require_path = 'lib'
-  s.rubyforge_project = '[none]'
-
-  s.add_dependency 'activerecord', '>= 4.2.0', '< 4.3'
-  s.add_dependency 'activemodel', '>= 4.2.0', '< 4.3'
-
-  s.add_development_dependency 'database_cleaner', '~> 1.4.0'
-  s.add_development_dependency 'minitest'
-  s.add_development_dependency 'minitest-reporters'
-
-  s.add_development_dependency 'sqlite3'
-  s.add_development_dependency 'rdoc'
-
-  s.add_development_dependency 'rake'
-end

data/lib/globalize/active_record/query_methods.rb

@@ -1,98 +0,0 @@
-module Globalize
-  module ActiveRecord
-    module QueryMethods
-
-      class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
-        def not(opts, *rest)
-          if parsed = @scope.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 order(opts, *rest)
-        if respond_to?(:translated_attribute_names) && parsed = parse_translated_order(opts)
-          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 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
-
-      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
-
-      def join_translations(relation = self)
-        if relation.joins_values.include?(:translations)
-          relation
-        else
-          relation.with_translations_in_fallbacks
-        end
-      end
-
-      private
-
-      def parse_translated_order(opts)
-        case opts
-        when Hash
-          ordering = opts.map do |column, direction|
-            klass = translated_column?(column) ? translation_class : self
-            klass.arel_table[column].send(direction)
-          end
-          order(ordering).order_values
-        when Symbol
-          translated_column_name(opts) if translated_attribute_names.include?(opts)
-        else # failsafe returns nothing
-          nil
-        end
-      end
-
-      def translated_column?(column)
-        translated_attribute_names.include?(column)
-      end
-    end
-  end
-end