globalize-danibachar 5.2.0

data/lib/globalize/active_record/translated_attributes_query.rb

@@ -0,0 +1,181 @@
+module Globalize
+  module ActiveRecord
+    module TranslatedAttributesQuery
+      class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
+        def not(opts, *rest)
+          if parsed = @scope.clone.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 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)
+        else
+          super
+        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)
+        else
+          super
+        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
+
+      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)
+        if relation.joins_values.include?(:translations)
+          relation
+        else
+          relation.with_translations_in_fallbacks
+        end
+      end
+
+      private
+
+      def arel_translated_order_node(column, direction)
+        unless translated_column?(column)
+          return self.arel_table[column].send(direction)
+        end
+
+        full_column = translated_column_name(column)
+
+        # Inject `full_column` to the select values to avoid
+        # PG::InvalidColumnReference errors with distinct queries on Postgres
+        if select_values.empty?
+          self.select_values = [self.arel_table[Arel.star], full_column]
+        else
+          self.select_values << full_column
+        end
+
+        translation_class.arel_table[column].send(direction)
+      end
+
+      def parse_translated_order(opts)
+        case opts
+        when Hash
+          # Do not process nothing unless there is at least a translated column
+          # so that the `order` statement will be processed by the original
+          # ActiveRecord method
+          return nil unless opts.find { |col, dir| translated_column?(col) }
+
+          # Build order arel nodes for translateds and untranslateds statements
+          ordering = opts.map do |column, direction|
+            arel_translated_order_node(column, direction)
+          end
+
+          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
+    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.2.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/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