globalize-r5 5.1.0

data/lib/globalize/active_record/query_methods.rb

@@ -0,0 +1,113 @@
+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)
+        else
+          translated, normal = translated_vs_normal(opts)
+          if not translated.empty?
+            join_translations(super(normal, *rest), translated)
+          else
+            super
+          end
+        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 exists?(conditions = :none)
+        if parsed = parse_translated_conditions(conditions)
+          with_translations_in_fallbacks.exists?(parsed)
+        else
+          super
+        end
+      end
+
+      def translated_vs_normal(opts)
+        translated = {}
+        if opts.is_a?(Hash) && respond_to?(:translated_attribute_names) && (opts.symbolize_keys.keys & translated_attribute_names).present?
+          opts = opts.dup
+          opts.each do |k,v|
+              translated[k] = opts.delete(k) || opts.delete(key.to_s) if translated_column? k.to_sym
+          end
+        end
+        return translated, opts
+      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, opts = {})
+        if relation.joins_values.include?(:translations)
+          rel = relation
+        else
+          rel = relation.with_translations_in_fallbacks
+        end
+        rel.with_where(opts)
+      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

data/lib/globalize/active_record/translation.rb

@@ -0,0 +1,45 @@
+module Globalize
+  module ActiveRecord
+    class Translation < ::ActiveRecord::Base
+
+      validates :locale, :presence => true
+
+      class << self
+        # Sometimes ActiveRecord queries .table_exists? before the table name
+        # has even been set which results in catastrophic failure.
+        def table_exists?
+          table_name.present? && super
+        end
+
+        def with_locales(*locales)
+          # Avoid using "IN" with SQL queries when only using one locale.
+          locales = locales.flatten.map(&:to_s)
+          locales = locales.first if locales.one?
+          where :locale => locales
+        end
+        alias with_locale with_locales
+
+        def translated_locales
+          select('DISTINCT locale').order(:locale).map(&:locale)
+        end
+      end
+
+      def locale
+        _locale = read_attribute :locale
+        _locale.present? ? _locale.to_sym : _locale
+      end
+
+      def locale=(locale)
+        write_attribute :locale, locale.to_s
+      end
+    end
+  end
+end
+
+# Setting this will force polymorphic associations to subclassed objects
+# to use their table_name rather than the parent object's table name,
+# which will allow you to get their models back in a more appropriate
+# format.
+#
+# See http://www.ruby-forum.com/topic/159894 for details.
+Globalize::ActiveRecord::Translation.abstract_class = true

data/lib/globalize/interpolation.rb

@@ -0,0 +1,28 @@
+module Globalize
+  module Interpolation
+    def interpolate(name, model, args)
+      translation = model.read_attribute(name, {:locale => locale_from(args)})
+      try_interpolation translation, interpolation_args_from(args)
+    end
+
+    private
+
+    def interpolation_args_from(args)
+      args.detect {|a| a.is_a? Hash }
+    end
+
+    def locale_from(args)
+      args.detect {|a| !a.is_a? Hash }
+    end
+
+    def try_interpolation(translation,args)
+      if args
+        I18n.interpolate(translation,args)
+      else
+        translation
+      end
+    end
+
+    extend self
+  end
+end

data/lib/globalize/version.rb

@@ -0,0 +1,3 @@
+module Globalize
+  Version = '5.1.0'
+end

data/lib/i18n/missing_translations_log_handler.rb

@@ -0,0 +1,41 @@
+# A simple exception handler that behaves like the default exception handler
+# but additionally logs missing translations to a given log.
+#
+# Useful for identifying missing translations during testing.
+#
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_log_handler'
+#   I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
+#   I18n.exception_handler = :missing_translations_log_handler
+#
+# To set up a different log file:
+#
+#   logger = Logger.new("#{RAILS_ROOT}/log/missing_translations.log")
+#   I18n.missing_translations_logger = logger
+
+module I18n
+  @@missing_translations_logger = nil
+
+  class << self
+    def missing_translations_logger
+      @@missing_translations_logger ||= begin
+        require 'logger' unless defined?(Logger)
+        Logger.new(STDOUT)
+      end
+    end
+
+    def missing_translations_logger=(logger)
+      @@missing_translations_logger = logger
+    end
+
+    def missing_translations_log_handler(exception, locale, key, options)
+      if MissingTranslationData === exception
+        missing_translations_logger.warn(exception.message)
+        return exception.message
+      else
+        raise exception
+      end
+    end
+  end
+end

data/lib/i18n/missing_translations_raise_handler.rb

@@ -0,0 +1,25 @@
+# A simple exception handler that behaves like the default exception handler
+# but also raises on missing translations.
+#
+# Useful for identifying missing translations during testing.
+#
+# E.g.
+#
+#   require 'globalize/i18n/missing_translations_raise_handler'
+#   I18n.exception_handler = :missing_translations_raise_handler
+module I18n
+  class << self
+    def missing_translations_raise_handler(exception, locale, key, options)
+      raise exception
+    end
+  end
+end
+
+I18n.exception_handler = :missing_translations_raise_handler
+
+ActionView::Helpers::TranslationHelper.module_eval do
+  def translate(key, options = {})
+    I18n.translate(key, options)
+  end
+  alias :t :translate
+end

data/lib/patches/active_record/persistence.rb

@@ -0,0 +1,17 @@
+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) }
+      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) }
+      super(attribute_names_without_translated)
+    end
+  end
+end
+
+ActiveRecord::Persistence.send(:prepend, Globalize::Persistence)

data/lib/patches/active_record/query_method.rb

@@ -0,0 +1,3 @@
+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/uniqueness_validator.rb

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

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/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

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