globalize 5.3.1 → 7.0.0

data/issue_template.rb

@@ -1,38 +0,0 @@
-# Activate the gem you are reporting the issue against.
-gem 'activerecord', '4.2.0'
-gem 'globalize', '5.0.1'
-require 'active_record'
-require 'globalize'
-require 'minitest/autorun'
-require 'logger'
-
-# Ensure backward compatibility with Minitest 4
-Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
-
-# This connection will do for database-independent bug reports.
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-ActiveRecord::Base.logger = Logger.new(STDOUT)
-
-ActiveRecord::Schema.define do
-  create_table :posts, force: true do |t|
-  end
-
-  create_table :post_translations, force: true do |t|
-    t.references :post
-    t.string     :title
-    t.text       :content
-    t.string     :locale
-  end
-end
-
-class Post < ActiveRecord::Base
-  translates :content, :title
-end
-
-class BugTest < Minitest::Test
-  def test_association_stuff
-    post = Post.create!(title: 'HI')
-
-    assert_equal 'HI', post.title
-  end
-end

data/lib/patches/active_record/query_method.rb

@@ -1,3 +0,0 @@
-if ::ActiveRecord::VERSION::STRING < "5.0.0"
-  require_relative 'rails4/query_method'
-end

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

@@ -1,35 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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