mobility 0.6.0 → 0.7.0

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

@@ -1,25 +0,0 @@
-require 'mobility/backends/active_record/pg_query_methods'
-require 'mobility/backends/active_record/query_methods'
-
-module Mobility
-  module Backends
-    module ActiveRecord
-      class Hstore::QueryMethods < QueryMethods
-        include PgQueryMethods
-
-        def matches(key, locale)
-          build_infix(:'->', arel_table[column_name(key)], build_quoted(locale))
-        end
-
-        def exists(key, locale)
-          build_infix(:'?', arel_table[column_name(key)], build_quoted(locale))
-        end
-
-        def quote(value)
-          build_quoted(value)
-        end
-      end
-      Hstore.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-require 'mobility/backends/active_record/pg_query_methods'
-require "mobility/backends/active_record/query_methods"
-
-module Mobility
-  module Backends
-    module ActiveRecord
-      class Json::QueryMethods < QueryMethods
-        include PgQueryMethods
-
-        def matches(key, locale)
-          build_infix(:'->>', arel_table[column_name(key)], build_quoted(locale))
-        end
-
-        def exists(key, locale)
-          absent(key, locale).not
-        end
-
-        def absent(key, locale)
-          matches(key, locale).eq(nil)
-        end
-
-        def quote(value)
-          value.to_s
-        end
-      end
-      Json.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-require 'mobility/backends/active_record/pg_query_methods'
-require "mobility/backends/active_record/query_methods"
-
-module Mobility
-  module Backends
-    module ActiveRecord
-      class Jsonb::QueryMethods < QueryMethods
-        include PgQueryMethods
-
-        def matches(key, locale)
-          build_infix(:'->', arel_table[column_name(key)], build_quoted(locale))
-        end
-
-        def exists(key, locale)
-          build_infix(:'?', arel_table[column_name(key)], build_quoted(locale))
-        end
-
-        def quote(value)
-          build_quoted(value.to_json)
-        end
-      end
-      Jsonb.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/active_record/query_methods"
-
-module Mobility
-  module Backends
-    module ActiveRecord
-      class KeyValue::QueryMethods < QueryMethods
-        def initialize(attributes, association_name: nil, class_name: nil, **)
-          super
-          @association_name = association_name
-
-          define_join_method(association_name, class_name)
-          define_query_methods(association_name)
-        end
-
-        def extended(relation)
-          super
-          association_name = @association_name
-          q = self
-
-          mod = Module.new do
-            define_method :not do |opts, *rest|
-              if i18n_keys = q.extract_attributes(opts)
-                opts = opts.with_indifferent_access
-                i18n_keys.each do |attr|
-                  opts["#{attr}_#{association_name}"] = { value: q.collapse(opts.delete(attr)) }
-                end
-                super(opts, *rest).send(:"join_#{association_name}", *i18n_keys)
-              else
-                super(opts, *rest)
-              end
-            end
-          end
-          relation.mobility_where_chain.include(mod)
-        end
-
-        private
-
-        def define_join_method(association_name, translation_class)
-          define_method :"join_#{association_name}" do |*attributes, **options|
-            attributes.inject(self) do |relation, attribute|
-              t = translation_class.arel_table.alias("#{attribute}_#{association_name}")
-              m = arel_table
-              join_type = options[:outer_join] ? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
-              relation.joins(m.join(t, join_type).
-                             on(t[:key].eq(attribute).
-                                and(t[:locale].eq(Mobility.locale).
-                                    and(t[:translatable_type].eq(base_class.name).
-                                        and(t[:translatable_id].eq(m[:id]))))).join_sources)
-            end
-          end
-        end
-
-        def define_query_methods(association_name)
-          q = self
-
-          define_method :where! do |opts, *rest|
-            if i18n_keys = q.extract_attributes(opts)
-              opts = opts.with_indifferent_access
-              i18n_nulls = i18n_keys.reject { |key| opts[key] && [*opts[key]].all? }
-              i18n_keys.each do |attr|
-                opts["#{attr}_#{association_name}"] = { value: q.collapse(opts.delete(attr)) }
-              end
-              super(opts, *rest).
-                send("join_#{association_name}", *(i18n_keys - i18n_nulls)).
-                send("join_#{association_name}", *i18n_nulls, outer_join: true)
-            else
-              super(opts, *rest)
-            end
-          end
-        end
-      end
-      KeyValue.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-  module Backends
-    module ActiveRecord
-=begin
-
-Internal module builder defining query methods for Postgres backends. Including
-class must define the following methods:
-
-- a method +matches+ which takes an attribute, and a locale to match, and
-  returns an Arel node which is used to check that the attribute has the
-  specified value in the specified locale
-- a method +exists+ which takes an attribute and a locale and
-  returns an Arel node checking that a value exists for the attribute in the
-  specified locale
-- a method +quote+ which quotes the value to be matched
-- an optional method +absent+ which takes an attribute and a locale and returns
-  an Arel node checking that the value for the attribute does not exist in the
-  specified locale. Defaults to +exists(key, locale).not+.
-
-This module avoids a lot of duplication between hstore/json/jsonb/container
-backend querying code.
-
-@see Mobility::Backends::ActiveRecord::Json::QueryMethods
-@see Mobility::Backends::ActiveRecord::Jsonb::QueryMethods
-@see Mobility::Backends::ActiveRecord::Hstore::QueryMethods
-@see Mobility::Backends::ActiveRecord::Container::JsonQueryMethods
-@see Mobility::Backends::ActiveRecord::Container::JsonbQueryMethods
-
-=end
-      module PgQueryMethods
-        attr_reader :arel_table, :column_affix
-
-        def initialize(attributes, options)
-          super
-          @arel_table   = options[:model_class].arel_table
-          @column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
-
-          q = self
-
-          define_method :where! do |opts, *rest|
-            if i18n_keys = q.extract_attributes(opts)
-              opts = opts.with_indifferent_access
-              query = q.create_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_query!(opts, i18n_keys, inverse: true)
-
-                super(opts, *rest).where(query)
-              else
-                super(opts, *rest)
-              end
-            end
-          end
-          relation.mobility_where_chain.include(mod)
-        end
-
-        # Create +where+ query for specified key and value
-        #
-        # @note This is a destructive operation, it will modify +opts+.
-        # @param [Hash] opts Hash of attribute/value pairs
-        # @param [Array] keys Translated attribute names
-        # @option [Boolean] inverse (false) If true, create a +not+ query
-        #   instead of a +where+ query
-        # @return [Arel::Node] Arel node to pass to +where+
-        def create_query!(opts, keys, inverse: false)
-          keys.map { |key|
-            values = Array.wrap(opts.delete(key)).uniq
-            send(inverse ? :not_query : :where_query, key, values, Mobility.locale)
-          }.inject(&:and)
-        end
-
-        def matches(_key, _locale)
-          raise NotImplementedError
-        end
-
-        def exists(_key, _locale)
-          raise NotImplementedError
-        end
-
-        def quote(_value)
-          raise NotImplementedError
-        end
-
-        def absent(key, locale)
-          exists(key, locale).not
-        end
-
-        private
-
-        def build_infix(*args)
-          arel_table.grouping(Arel::Nodes::InfixOperation.new(*args))
-        end
-
-        def build_quoted(value)
-          Arel::Nodes.build_quoted(value.to_s)
-        end
-
-        def column_name(attribute)
-          column_affix % attribute
-        end
-
-        # Create +where+ query for specified key and values
-        #
-        # @param [String] key Translated attribute name
-        # @param [Array] values Values to match
-        # @param [Symbol] locale Locale to query for
-        # @return [Arel::Node] Arel node to pass to +where+
-        def where_query(key, values, locale)
-          nils, vals = values.partition(&:nil?)
-
-          return absent(key, locale) if vals.empty?
-
-          node = matches(key, locale)
-          vals = vals.map(&method(:quote))
-
-          query = vals.size == 1 ? node.eq(vals.first) : node.in(vals)
-          query = query.or(absent(key, locale)) unless nils.empty?
-          query
-        end
-
-        # Create +not+ query for specified key and values
-        #
-        # @param [String] key Translated attribute name
-        # @param [Array] values Values to match
-        # @param [Symbol] locale Locale to query for
-        # @return [Arel::Node] Arel node to pass to +where+
-        def not_query(key, values, locale)
-          vals = values.map(&method(:quote))
-          node = matches(key, locale)
-
-          query = vals.size == 1 ? node.eq(vals.first) : node.in(vals)
-          query.not.and(exists(key, locale))
-        end
-      end
-      private_constant :PgQueryMethods
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/active_record/query_methods"
-
-module Mobility
-  module Backends
-    module ActiveRecord
-      class Serialized::QueryMethods < QueryMethods
-        include Backends::Serialized
-
-        def initialize(attributes, _)
-          super
-          q = self
-
-          define_method :where! do |opts, *rest|
-            q.check_opts(opts) || super(opts, *rest)
-          end
-        end
-
-        def extended(relation)
-          super
-          q = self
-
-          mod = Module.new do
-            define_method :not do |opts, *rest|
-              q.check_opts(opts) || super(opts, *rest)
-            end
-          end
-          relation.mobility_where_chain.include(mod)
-        end
-      end
-      Serialized.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/active_record/query_methods"
-
-module Mobility
-  module Backends
-    module ActiveRecord
-      class Table::QueryMethods < QueryMethods
-        def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
-          super
-
-          @association_name  = association_name
-          @translation_class = translation_class = model_class.const_get(subclass_name)
-
-          define_join_method(association_name, translation_class, **options)
-          define_query_methods(association_name, translation_class, **options)
-        end
-
-        def extended(relation)
-          super
-          association_name  = @association_name
-          translation_class = @translation_class
-          q                 = self
-
-          mod = Module.new do
-            define_method :not do |opts, *rest|
-              if i18n_keys = q.extract_attributes(opts)
-                opts = opts.with_indifferent_access
-                i18n_keys.each do |attr|
-                  opts["#{translation_class.table_name}.#{attr}"] = q.collapse opts.delete(attr)
-                end
-                super(opts, *rest).send("join_#{association_name}")
-              else
-                super(opts, *rest)
-              end
-            end
-          end
-          relation.mobility_where_chain.include(mod)
-        end
-
-        private
-
-        def define_join_method(association_name, translation_class, foreign_key: nil, table_name: nil, **)
-          define_method :"join_#{association_name}" do |**options|
-            if join = joins_values.find { |v| (Arel::Nodes::Join === v) && (v.left.name == table_name.to_s) }
-              return self if (options[:outer_join] || Arel::Nodes::InnerJoin === join)
-              self.joins_values = joins_values - [join]
-            end
-            t = translation_class.arel_table
-            m = arel_table
-            join_type = options[:outer_join] ? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
-            joins(m.join(t, join_type).
-                  on(t[foreign_key].eq(m[:id]).
-                     and(t[:locale].eq(Mobility.locale))).join_sources)
-          end
-        end
-
-        def define_query_methods(association_name, translation_class, **)
-          q = self
-
-          # Note that Mobility will try to use inner/outer joins appropriate to the query,
-          # so for example:
-          #
-          # Article.where(title: nil, content: nil)          #=> OUTER JOIN (all nils)
-          # Article.where(title: "foo", content: nil)        #=> INNER JOIN (one non-nil)
-          #
-          # In the first case, if we are in (say) the "en" locale, then we should match articles
-          # that have *no* article_translations with English locales (since no translation is
-          # equivalent to a nil value). If we used an inner join in the first case, an article
-          # with no English translations would be filtered out, so we use an outer join.
-          #
-          # When deciding whether to use an outer or inner join, array-valued
-          # conditions are treated as nil if they have any values.
-          #
-          # Article.where(title: nil, content: ["foo", nil])                  #=> OUTER JOIN (all nil or array with nil)
-          # Article.where(title: "foo", content: ["foo", nil])                #=> INNER JOIN (one non-nil)
-          # Article.where(title: ["foo", "bar"], content: ["foo", nil])       #=> INNER JOIN (one non-nil array)
-          #
-          # The logic also applies when a query has more than one where clause.
-          #
-          # Article.where(title: nil).where(content: nil)    #=> OUTER JOIN (all nils)
-          # Article.where(title: nil).where(content: "foo")  #=> INNER JOIN (one non-nil)
-          # Article.where(title: "foo").where(content: nil)  #=> INNER JOIN (one non-nil)
-          #
-          define_method :where! do |opts, *rest|
-            if i18n_keys = q.extract_attributes(opts)
-              opts = opts.with_indifferent_access
-              options = {
-                # We only need an OUTER JOIN if every value is either nil, or an
-                # array with at least one nil value.
-                outer_join: opts.values_at(*i18n_keys).compact.all? { |v| ![*v].all? }
-              }
-              i18n_keys.each do |attr|
-                opts["#{translation_class.table_name}.#{attr}"] = q.collapse opts.delete(attr)
-              end
-              super(opts, *rest).send("join_#{association_name}", options)
-            else
-              super(opts, *rest)
-            end
-          end
-        end
-      end
-      Table.private_constant :QueryMethods
-    end
-  end
-end