mobility 0.7.6 → 0.8.0

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/sequel/pg_query_methods"
-require "mobility/backends/sequel/query_methods"
-
-Sequel.extension :pg_json, :pg_json_ops
-
-module Mobility
-  module Backends
-    module Sequel
-      class Jsonb::QueryMethods < QueryMethods
-        include PgQueryMethods
-
-        def matches(key, locale)
-          build_op(key)[locale]
-        end
-
-        def exists(key, locale)
-          build_op(key).has_key?(locale)
-        end
-
-        def quote(value)
-          value && value.to_json
-        end
-
-        private
-
-        def build_op(key)
-          ::Sequel.pg_jsonb_op(column_name(key))
-        end
-      end
-      Jsonb.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/sequel/query_methods"
-
-module Mobility
-  module Backends
-    module Sequel
-      class KeyValue::QueryMethods < QueryMethods
-        def initialize(attributes, association_name: nil, class_name: nil, **)
-          super
-
-          define_join_method(association_name, class_name)
-          define_query_methods(association_name)
-        end
-
-        private
-
-        def define_join_method(association_name, translation_class)
-          define_method :"join_#{association_name}" do |*attributes, **options|
-            attributes.inject(self) do |relation, attribute|
-              join_type = options[:outer_join] ? :left_outer : :inner
-              relation.join_table(join_type,
-                                  translation_class.table_name,
-                                  {
-                                    key: attribute.to_s,
-                                    locale: Mobility.locale.to_s,
-                                    translatable_type: model.name,
-                                    translatable_id: ::Sequel[:"#{model.table_name}"][:id]
-                                  },
-                                  table_alias: "#{attribute}_#{association_name}")
-            end
-          end
-        end
-
-        def define_query_methods(association_name)
-          q = self
-
-          %w[exclude or where].each do |method_name|
-            define_method method_name do |*conds, &block|
-              if i18n_keys = q.extract_attributes(conds.first)
-                cond = conds.first.dup
-                i18n_nulls = i18n_keys.select { |key| cond[key].nil? }
-                i18n_keys.each do |attr|
-                  cond[::Sequel[:"#{attr}_#{association_name}"][:value]] = q.collapse cond.delete(attr)
-                end
-                super(cond, &block).
-                  send("join_#{association_name}", *(i18n_keys - i18n_nulls), outer_join: method_name == "or").
-                  send("join_#{association_name}", *i18n_nulls, outer_join: true)
-              else
-                super(*conds, &block)
-              end
-            end
-          end
-        end
-      end
-      KeyValue.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-  module Backends
-    module Sequel
-=begin
-
-Internal module builder defining query methods for Postgres backends. Including
-class must define three methods:
-
-- a method +matches+ which takes a key (column name) and a locale to match and
-  returns an SQL expression checking that the column has the specified value
-  in the specified locale
-- a method +exists+ which takes a key (column name) and locale, and returns
-  an SQL expression which checks that the column has a value in the locale
-- a method +quote+ which quotes the value to be matched
-
-(The +matches+/+exists+/+quote+ methods are implemented slightly differently
-for hstore/json/jsonb/container backends.)
-
-@see Mobility::Backends::Sequel::Json::QueryMethods
-@see Mobility::Backends::Sequel::Jsonb::QueryMethods
-@see Mobility::Backends::Sequel::Hstore::QueryMethods
-@see Mobility::Backends::Sequel::Container::JsonQueryMethods
-@see Mobility::Backends::Sequel::Container::JsonbQueryMethods
-
-=end
-      module PgQueryMethods
-        attr_reader :column_affix
-
-        def initialize(attributes, options)
-          super
-          @column_affix = options[:column_affix]
-          define_query_methods
-        end
-
-        # Create query for conditions and translated keys
-        # @note This is a destructive action, it will alter +cond+.
-        #
-        # @param [Hash] cond Hash of attribute/value pairs
-        # @param [Array] keys Translated attribute names
-        # @param [Boolean] invert Invert query, true for +exclude+, false otherwise
-        # @return [Sequel::SQL::Expression] Query expression
-        def create_query!(cond, keys, invert = false)
-          keys.map { |key|
-            values = cond.delete(key)
-            values = values.is_a?(Array) ? values.uniq: [values]
-            create_query_op(key, values, invert)
-          }.inject(invert ? :| : :&)
-        end
-
-        def matches(_key, _locale)
-          raise NotImplementedError
-        end
-
-        def exists(_key, _locale)
-          raise NotImplementedError
-        end
-
-        def quote(_value)
-          raise NotImplementedError
-        end
-
-        private
-
-        def define_query_methods
-          %w[exclude or where].each do |method_name|
-            define_query_method(method_name)
-          end
-        end
-
-        def define_query_method(method_name)
-          q = self
-
-          define_method method_name do |*cond, &block|
-            if i18n_keys = q.extract_attributes(cond.first)
-              cond = cond.first
-
-              query = q.create_query!(cond, i18n_keys, method_name == "exclude")
-              if method_name == "or"
-                query = ::Sequel.&(cond, query) unless cond.empty?
-                super(query, &block)
-              else
-                super(cond, &block).where(query)
-              end
-            else
-              super(*cond, &block)
-            end
-          end
-        end
-
-        def create_query_op(key, values, invert)
-          locale = Mobility.locale.to_s
-          values = values.map(&method(:quote))
-          values = values.first if values.size == 1
-
-          match = matches(key, locale) =~ values
-
-          if invert
-            exists(key, locale) & ~match
-          else
-            values.nil? ? ~exists(key, locale) : match
-          end
-        end
-
-
-        def column_name(attribute)
-          (column_affix % attribute).to_sym
-        end
-      end
-      private_constant :PgQueryMethods
-    end
-  end
-end

data/lib/mobility/backends/sequel/query_methods.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-require "mobility/util"
-
-module Mobility
-  module Backends
-    module Sequel
-=begin
-
-Defines query method overrides to handle translated attributes for Sequel
-models. For details see backend-specific subclasses.
-
-=end
-      class QueryMethods < Module
-        # @param [Array<String>] attributes Translated attributes
-        def initialize(attributes, _)
-          @attributes = attributes.map(&:to_sym)
-
-          @attributes.each do |attribute|
-            define_method :"first_by_#{attribute}" do |value|
-              where(attribute => value).select_all(model.table_name).first
-            end
-          end
-        end
-
-        def extract_attributes(cond)
-          cond.is_a?(Hash) && Util.presence(cond.keys & @attributes)
-        end
-
-        def collapse(value)
-          value.is_a?(Array) ? value.uniq : value
-        end
-      end
-      private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/sequel/query_methods"
-
-module Mobility
-  module Backends
-    module Sequel
-      class Serialized::QueryMethods < QueryMethods
-        include Backends::Serialized
-
-        def initialize(attributes, _)
-          super
-          q = self
-
-          define_method :where do |*cond, &block|
-            q.check_opts(cond.first) || super(*cond, &block)
-          end
-        end
-      end
-      Serialized.private_constant :QueryMethods
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require "mobility/backends/sequel/query_methods"
-
-module Mobility
-  module Backends
-    module Sequel
-      class Table::QueryMethods < QueryMethods
-        def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
-          super
-          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 define_join_method(association_name, translation_class, table_name: nil, foreign_key: nil, **)
-          define_method :"join_#{association_name}" do |**options|
-            if joins = @opts[:join]
-              # Return self if we've already joined this table
-              return self if joins.any? { |clause| clause.table_expr == table_name }
-            end
-
-            join_type = options[:outer_join] ? :left_outer : :inner
-            join_table(join_type,
-                       translation_class.table_name,
-                       {
-                         locale: Mobility.locale.to_s,
-                         foreign_key => ::Sequel[model.table_name][:id]
-                       })
-          end
-        end
-
-        def define_query_methods(association_name, translation_class, **)
-          q = self
-
-          # See note in AR Table QueryMethods class about limitations of
-          # query methods on translated attributes when searching on nil values.
-          #
-          %w[exclude or where].each do |method_name|
-            define_method method_name do |*conds, &block|
-              if i18n_keys = q.extract_attributes(conds.first)
-                cond = conds.first.dup
-                outer_join = method_name == "or" || i18n_keys.all? { |key| cond[key].nil? }
-                i18n_keys.each do |attr|
-                  cond[::Sequel[translation_class.table_name][attr]] = q.collapse cond.delete(attr)
-                end
-                super(cond, &block).send("join_#{association_name}", outer_join: outer_join)
-              else
-                super(*conds, &block)
-              end
-            end
-          end
-        end
-      end
-      Table.private_constant :QueryMethods
-    end
-  end
-end