mobility 0.3.6 → 0.4.0

data/lib/mobility/backends/active_record/column/query_methods.rb

@@ -5,17 +5,10 @@ module Mobility
     class ActiveRecord::Column::QueryMethods < ActiveRecord::QueryMethods
       def initialize(attributes, _)
         super
-        attributes_extractor = @attributes_extractor
-        @opts_converter = opts_converter = lambda do |opts|
-          if i18n_keys = attributes_extractor.call(opts)
-            opts = opts.with_indifferent_access
-            i18n_keys.each { |attr| opts[Column.column_name_for(attr)] = opts.delete(attr) }
-          end
-          return opts
-        end
+        q = self
 
         define_method :where! do |opts, *rest|
-          super(opts_converter.call(opts), *rest)
+          super(q.convert_opts(opts), *rest)
         end
 
         attributes.each do |attribute|
@@ -27,15 +20,23 @@ module Mobility
 
       def extended(relation)
         super
-        opts_converter = @opts_converter
+        q = self
 
         mod = Module.new do
           define_method :not do |opts, *rest|
-            super(opts_converter.call(opts), *rest)
+            super(q.convert_opts(opts), *rest)
           end
         end
         relation.mobility_where_chain.include(mod)
       end
+
+      def convert_opts(opts)
+        if i18n_keys = extract_attributes(opts)
+          opts = opts.with_indifferent_access
+          i18n_keys.each { |attr| opts[Column.column_name_for(attr)] = opts.delete(attr) }
+        end
+        opts
+      end
     end
   end
 end

data/lib/mobility/backends/active_record/container.rb

@@ -0,0 +1,116 @@
+module Mobility
+  module Backends
+=begin
+
+Implements the {Mobility::Backends::Container} backend for ActiveRecord models.
+
+=end
+    class ActiveRecord::Container
+      include ActiveRecord
+
+      require 'mobility/backends/active_record/container/query_methods'
+
+      # @return [Symbol] name of container column
+      attr_reader :column_name
+
+      # @!macro backend_constructor
+      # @option options [Symbol] column_name Name of container column
+      def initialize(model, attribute, options = {})
+        super
+        @column_name = options[:column_name]
+      end
+
+      # @!group Backend Accessors
+      #
+      # @note Translation may be a string, integer, boolean, hash or array
+      #   since value is stored on a JSON hash.
+      # @param [Symbol] locale Locale to read
+      # @param [Hash] options
+      # @return [String,Integer,Boolean] Value of translation
+      def read(locale, _ = nil)
+        model_translations(locale)[attribute]
+      end
+
+      # @note Translation may be a string, integer, boolean, hash or array
+      #   since value is stored on a JSON hash.
+      # @param [Symbol] locale Locale to write
+      # @param [String,Integer,Boolean] value Value to write
+      # @param [Hash] options
+      # @return [String,Integer,Boolean] Updated value
+      def write(locale, value, _ = nil)
+        set_attribute_translation(locale, value)
+        model_translations(locale)[attribute]
+      end
+      # @!endgroup
+
+      # @!group Backend Configuration
+      # @option options [Symbol] column_name (:translations) Name of column on which to store translations
+      def self.configure(options)
+        options[:column_name] ||= :translations
+      end
+      # @!endgroup
+
+      # @!macro backend_iterator
+      def each_locale
+        model[column_name].each do |l, v|
+          yield l.to_sym if v.present?
+        end
+      end
+
+      setup do |_attributes, options|
+        store options[:column_name], coder: Coder
+
+        # Fix for duping depth-2 jsonb column in AR < 5.0
+        if ::ActiveRecord::VERSION::STRING < '5.0'
+          column_name = options[:column_name]
+          module_name = "MobilityArContainer#{column_name.to_s.camelcase}"
+          unless const_defined?(module_name)
+            dupable = Module.new do
+              class_eval <<-EOM, __FILE__, __LINE__ + 1
+                def initialize_dup(source)
+                  super
+                  self.#{column_name} = source.#{column_name}.deep_dup
+                end
+              EOM
+            end
+            include const_set(module_name, dupable)
+          end
+        end
+      end
+
+      setup_query_methods(QueryMethods)
+
+      private
+
+      def model_translations(locale)
+        model[column_name][locale] ||= {}
+      end
+
+      def set_attribute_translation(locale, value)
+        translations = model[column_name] || {}
+        translations[locale.to_s] ||= {}
+        translations[locale.to_s][attribute] = value
+        model[column_name] = translations
+      end
+
+      class Coder
+        def self.dump(obj)
+          if obj.is_a? Hash
+            obj.inject({}) do |translations, (locale, value)|
+              value.each do |k, v|
+                (translations[locale] ||= {})[k] = v if v.present?
+              end
+              translations
+            end
+          else
+            raise ArgumentError, "Attribute is supposed to be a Hash, but was a #{obj.class}. -- #{obj.inspect}"
+          end
+        end
+
+        def self.load(obj)
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/mobility/backends/active_record/container/query_methods.rb

@@ -0,0 +1,31 @@
+require "mobility/backends/active_record/jsonb"
+
+module Mobility
+  module Backends
+    class ActiveRecord::Container::QueryMethods < ActiveRecord::QueryMethods
+      include ActiveRecord::PgQueryMethods
+      attr_reader :column_name, :column
+
+      def initialize(_attributes, options)
+        super
+        @column_name = options[:column_name]
+        @column      = arel_table[@column_name]
+      end
+
+      private
+
+      def contains_value(key, value, locale)
+        build_infix(:'@>',
+                    build_infix(:'->', column, quote(locale)),
+                    quote({ key => value }.to_json))
+      end
+
+      def has_locale(key, locale)
+        build_infix(:'?', column, quote(locale)).and(
+          build_infix(:'?',
+                      build_infix(:'->', column, quote(locale)),
+                      quote(key)))
+      end
+    end
+  end
+end

data/lib/mobility/backends/active_record/hstore/query_methods.rb

@@ -1,62 +1,15 @@
+require 'mobility/backends/active_record/pg_query_methods'
+require 'mobility/backends/active_record/query_methods'
+
 module Mobility
   module Backends
     class ActiveRecord::Hstore::QueryMethods < ActiveRecord::QueryMethods
-      def initialize(attributes, _)
-        super
-        attributes_extractor = @attributes_extractor
-
-        define_method :where! do |opts, *rest|
-          if i18n_keys = attributes_extractor.call(opts)
-            m = arel_table
-            locale = Arel::Nodes.build_quoted(Mobility.locale.to_s)
-            opts = opts.with_indifferent_access
-            infix = Arel::Nodes::InfixOperation
-
-            i18n_query = i18n_keys.map { |key|
-              column = m[key.to_sym]
-              value = opts.delete(key)
-
-              if value.nil?
-                infix.new(:'?', column, locale).not
-              else
-                infix.new(:'->', m[key.to_sym], locale).eq(value)
-              end
-            }.inject(&:and)
-
-            opts.empty? ? super(i18n_query) : super(opts, *rest).where(i18n_query)
-          else
-            super(opts, *rest)
-          end
-        end
-      end
-
-      def extended(relation)
-        super
-        attributes_extractor = @attributes_extractor
-        m = relation.model.arel_table
-
-        mod = Module.new do
-          define_method :not do |opts, *rest|
-            if i18n_keys = attributes_extractor.call(opts)
-              locale = Arel::Nodes.build_quoted(Mobility.locale.to_s)
-              opts = opts.with_indifferent_access
-              infix = Arel::Nodes::InfixOperation
+      include ActiveRecord::PgQueryMethods
 
-              i18n_query = i18n_keys.map { |key|
-                column = m[key.to_sym]
-                value = Arel::Nodes.build_quoted(opts.delete(key).to_s)
-                has_key = infix.new(:'?', column, locale)
-                not_eq_value = infix.new(:'->', column, locale).not_eq(value)
-                has_key.and(not_eq_value)
-              }.inject(&:and)
+      private
 
-              super(opts, *rest).where(i18n_query)
-            else
-              super(opts, *rest)
-            end
-          end
-        end
-        relation.mobility_where_chain.include(mod)
+      def contains_value(key, value, locale)
+        build_infix(:'->', arel_table[key], quote(locale)).eq(quote(value.to_s))
       end
     end
   end

data/lib/mobility/backends/active_record/jsonb/query_methods.rb

@@ -1,65 +1,15 @@
+require 'mobility/backends/active_record/pg_query_methods'
 require "mobility/backends/active_record/query_methods"
 
 module Mobility
   module Backends
     class ActiveRecord::Jsonb::QueryMethods < ActiveRecord::QueryMethods
-      def initialize(attributes, _)
-        super
-        attributes_extractor = @attributes_extractor
+      include ActiveRecord::PgQueryMethods
 
-        define_method :where! do |opts, *rest|
-          if i18n_keys = attributes_extractor.call(opts)
-            m = arel_table
-            locale = Arel::Nodes.build_quoted(Mobility.locale.to_s)
-            opts = opts.with_indifferent_access
-            infix = Arel::Nodes::InfixOperation
+      private
 
-            i18n_query = i18n_keys.map { |key|
-              column = m[key.to_sym]
-              value = opts.delete(key)
-
-              if value.nil?
-                infix.new(:'?', column, locale).not
-              else
-                predicate = Arel::Nodes.build_quoted({ Mobility.locale => value }.to_json)
-                infix.new(:'@>', m[key.to_sym], predicate)
-              end
-            }.inject(&:and)
-
-            opts.empty? ? super(i18n_query) : super(opts, *rest).where(i18n_query)
-          else
-            super(opts, *rest)
-          end
-        end
-      end
-
-      def extended(relation)
-        super
-        attributes_extractor = @attributes_extractor
-        m = relation.model.arel_table
-
-        mod = Module.new do
-          define_method :not do |opts, *rest|
-            if i18n_keys = attributes_extractor.call(opts)
-              locale = Arel::Nodes.build_quoted(Mobility.locale.to_s)
-              opts = opts.with_indifferent_access
-              infix = Arel::Nodes::InfixOperation
-
-              i18n_query = i18n_keys.map { |key|
-                column = m[key.to_sym]
-                has_key = infix.new(:'?', column, locale)
-                predicate = Arel::Nodes.build_quoted({ Mobility.locale => opts.delete(key) }.to_json)
-                not_eq_value = infix.new(:'@>', m[key.to_sym], predicate).not
-                has_key.and(not_eq_value)
-              }.inject(&:and)
-
-              super(opts, *rest).where(i18n_query)
-            else
-              super(opts, *rest)
-            end
-          end
-        end
-        relation.mobility_where_chain.include(mod)
+      def contains_value(key, value, locale)
+        build_infix(:'@>', arel_table[key], quote({locale => value }.to_json))
       end
     end
   end

data/lib/mobility/backends/active_record/key_value.rb

@@ -83,15 +83,7 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
           include const_set(module_name, callback_methods)
         end
 
-        private
-
-        # Clean up *all* leftover translations of this model, only once.
-        def mobility_destroy_key_value_translations
-          [:string, :text].freeze.each do |type|
-            Mobility::ActiveRecord.const_get("#{type.capitalize}Translation".freeze).
-              where(translatable: self).destroy_all
-          end
-        end unless private_instance_methods(false).include?(:mobility_destroy_key_value_translations)
+        include DestroyKeyValueTranslations
       end
 
       setup_query_methods(QueryMethods)
@@ -104,6 +96,18 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
         translation ||= translations.build(locale: locale, key: attribute)
         translation
       end
+
+      module DestroyKeyValueTranslations
+        private
+
+        # Clean up *all* leftover translations of this model, only once.
+        def mobility_destroy_key_value_translations
+          [:string, :text].freeze.each do |type|
+            Mobility::ActiveRecord.const_get("#{type.capitalize}Translation".freeze).
+              where(translatable: self).destroy_all
+          end
+        end
+      end
     end
   end
 end

data/lib/mobility/backends/active_record/key_value/query_methods.rb

@@ -19,12 +19,12 @@ module Mobility
 
       def extended(relation)
         super
-        association_name     = @association_name
-        attributes_extractor = @attributes_extractor
+        association_name = @association_name
+        q = self
 
         mod = Module.new do
           define_method :not do |opts, *rest|
-            if i18n_keys = attributes_extractor.call(opts)
+            if i18n_keys = q.extract_attributes(opts)
               opts = opts.with_indifferent_access
               i18n_keys.each { |attr| opts["#{attr}_#{association_name}"] = { value: opts.delete(attr) }}
               super(opts, *rest).send(:"join_#{association_name}", *i18n_keys)
@@ -54,12 +54,12 @@ module Mobility
       end
 
       def define_query_methods(association_name)
-        attributes_extractor = @attributes_extractor
+        q = self
 
         define_method :where! do |opts, *rest|
-          if i18n_keys = attributes_extractor.call(opts)
+          if i18n_keys = q.extract_attributes(opts)
             opts = opts.with_indifferent_access
-            i18n_nulls = i18n_keys.select { |key| opts[key].nil? }
+            i18n_nulls = i18n_keys.reject { |key| opts[key] && Array.wrap(opts[key]).all? }
             i18n_keys.each { |attr| opts["#{attr}_#{association_name}"] = { value: opts.delete(attr) }}
             super(opts, *rest).
               send("join_#{association_name}", *(i18n_keys - i18n_nulls)).

data/lib/mobility/backends/active_record/pg_query_methods.rb

@@ -0,0 +1,115 @@
+module Mobility
+  module Backends
+    module ActiveRecord
+=begin
+
+Defines query methods for Postgres backends. Including class must define a
+single method, +contains_value+, which accepts a column, value and locale to
+match, and returns an Arel node.
+
+This module avoids 99% duplication between hstore and jsonb backend querying
+code.
+
+@see Mobility::Backends::ActiveRecord::Jsonb::QueryMethods
+@see Mobility::Backends::ActiveRecord::Hstore::QueryMethods
+
+=end
+      module PgQueryMethods
+        attr_reader :arel_table
+
+        def initialize(attributes, options)
+          super
+          @arel_table = options[:model_class].arel_table
+
+          q = self
+
+          define_method :where! do |opts, *rest|
+            if i18n_keys = q.extract_attributes(opts)
+              opts = opts.with_indifferent_access
+              query = q.create_where_query!(opts, i18n_keys)
+
+              opts.empty? ? super(query) : super(opts, *rest).where(query)
+            else
+              super(opts, *rest)
+            end
+          end
+        end
+
+        def extended(relation)
+          super
+          q = self
+
+          mod = Module.new do
+            define_method :not do |opts, *rest|
+              if i18n_keys = q.extract_attributes(opts)
+                opts = opts.with_indifferent_access
+                query = q.create_not_query!(opts, i18n_keys)
+
+                super(opts, *rest).where(query)
+              else
+                super(opts, *rest)
+              end
+            end
+          end
+          relation.mobility_where_chain.include(mod)
+        end
+
+        # Create +where+ query for options hash, translated keys and arel_table
+        # @note This is a destructive operation, it will modify +opts+.
+        #
+        # @param [Hash] opts Hash of attribute/value pairs
+        # @param [Array] keys Translated attribute names
+        # @return [Arel::Node] Arel node to pass to +where+
+        def create_where_query!(opts, keys)
+          locale = Mobility.locale
+          keys.map { |key|
+            values = opts.delete(key)
+
+            next has_locale(key, locale).not if values.nil?
+
+            Array.wrap(values).map { |value|
+              value.nil? ?
+                has_locale(key, locale).not :
+                contains_value(key, value, locale)
+            }.inject(&:or)
+          }.inject(&:and)
+        end
+
+        # Create +not+ query for options hash and translated keys
+        # @note This is a destructive operation, it will modify +opts+.
+        #
+        # @param [Hash] opts Hash of attribute/value pairs
+        # @param [Array] keys Translated attribute names
+        # @return [Arel::Node] Arel node to pass to +where+
+        def create_not_query!(opts, keys)
+          locale = Mobility.locale
+          keys.map { |key|
+            values = opts.delete(key)
+
+            Array.wrap(values).map { |value|
+              contains_value(key, value, locale).not
+            }.inject(has_locale(key, locale), &:and)
+          }.inject(&:and)
+        end
+
+        private
+
+        def contains_value(_key, _value, _locale)
+          raise NotImplementedError
+        end
+
+        def has_locale(key, locale)
+          build_infix(:'?', arel_table[key], quote(locale))
+        end
+
+        def build_infix(*args)
+          Arel::Nodes::InfixOperation.new(*args)
+        end
+
+        def quote(value)
+          Arel::Nodes.build_quoted(value.to_s)
+        end
+      end
+    end
+  end
+end