globalize 5.0.1 → 5.1.0

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,23 @@ module Globalize
       i18n_fallbacks? ? I18n.fallbacks[for_locale] : [for_locale.to_sym]
     end
 
+    # Thread-safe global storage
+    def storage
+      RequestStore.store
+    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 +79,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

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.1.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-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -22,56 +22,56 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '5.2'
   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.2'
 - !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.2'
   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.2'
 - !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: minitest
+  name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -85,7 +85,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-reporters
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -99,7 +99,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -151,12 +151,13 @@ files:
 - 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
@@ -170,10 +171,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 +193,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 +201,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: "[none]"
-rubygems_version: 2.4.5
+rubygems_version: 2.6.13
 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