mobility 0.5.1 → 0.6.0

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

@@ -3,51 +3,56 @@ require "mobility/backends/sequel/query_methods"
 
 module Mobility
   module Backends
-    class Sequel::KeyValue::QueryMethods < Sequel::QueryMethods
-      def initialize(attributes, association_name: nil, class_name: nil, **)
-        super
+    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
+          define_join_method(association_name, class_name)
+          define_query_methods(association_name)
+        end
 
-      private
+        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}")
+        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
-      end
 
-      def define_query_methods(association_name)
-        q = self
+        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 { |attr| cond[::Sequel[:"#{attr}_#{association_name}"][:value]] = cond.delete(attr) }
-              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)
+          %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_hash.rb

@@ -2,7 +2,6 @@
 require "mobility/util"
 require "mobility/backends/sequel"
 require "mobility/backends/hash_valued"
-require "mobility/backend/stringify_locale"
 require "mobility/sequel/column_changes"
 
 module Mobility
@@ -13,36 +12,49 @@ Internal class used by Sequel backends backed by a Postgres data type (hstore,
 jsonb).
 
 =end
-    class Sequel::PgHash
-      include Sequel
-      include HashValued
-      include StringifyLocale
-
-      # @!macro backend_iterator
-      def each_locale
-        super { |l| yield l.to_sym }
-      end
+    module Sequel
+      class PgHash
+        include Sequel
+        include HashValued
 
-      def translations
-        model[attribute.to_sym]
-      end
+        def read(locale, options = {})
+          super(locale.to_s, options)
+        end
+
+        def write(locale, value, options = {})
+          super(locale.to_s, value, options)
+        end
+
+        # @!macro backend_iterator
+        def each_locale
+          super { |l| yield l.to_sym }
+        end
+
+        def translations
+          model[column_name.to_sym]
+        end
 
-      setup do |attributes|
-        before_validation = Module.new do
-          define_method :before_validation do
-            attributes.each do |attribute|
-              self[attribute.to_sym].delete_if { |_, v| Util.blank?(v) }
+        setup do |attributes, options|
+          column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+          columns = attributes.map { |attribute| (column_affix % attribute).to_sym }
+
+          before_validation = Module.new do
+            define_method :before_validation do
+              columns.each do |column|
+                self[column].delete_if { |_, v| Util.blank?(v) }
+              end
+              super()
             end
-            super()
           end
-        end
-        include before_validation
-        include Mobility::Sequel::HashInitializer.new(*attributes)
-        include Mobility::Sequel::ColumnChanges.new(*attributes)
+          include before_validation
+          include Mobility::Sequel::HashInitializer.new(*columns)
+          include Mobility::Sequel::ColumnChanges.new(attributes, column_affix: column_affix)
 
-        plugin :defaults_setter
-        attributes.each { |attribute| default_values[attribute.to_sym] = {} }
+          plugin :defaults_setter
+          columns.each { |column| default_values[column] = {} }
+        end
       end
+      private_constant :PgHash
     end
   end
 end

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

@@ -1,25 +1,36 @@
+# frozen_string_literal: true
+
 module Mobility
   module Backends
     module Sequel
 =begin
 
-Defines query methods for Postgres backends. Including class must define two
-private methods:
+Internal module builder defining query methods for Postgres backends. Including
+class must define three methods:
 
-- a private method +matches+ which takes a key (column name), value and
-  locale and returns an SQL expression, and checks that the column has the
-  specified value in the specified locale
-- a private method +has_locale+ 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 +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+ and +has_locale+ methods are implemented slightly differently
+(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
-        def initialize(attributes, _)
+        attr_reader :column_affix
+
+        def initialize(attributes, options)
           super
+          @column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
           define_query_methods
         end
 
@@ -33,11 +44,23 @@ for hstore/json/jsonb/container backends.)
         def create_query!(cond, keys, invert = false)
           keys.map { |key|
             values = cond.delete(key)
-            values = [values] unless values.is_a?(Array)
-            values.map { |value| create_query_op(key, value, invert) }.inject(&:|)
+            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
@@ -66,24 +89,26 @@ for hstore/json/jsonb/container backends.)
           end
         end
 
-        def create_query_op(key, value, invert)
+        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
-            has_locale(key, locale) & ~matches(key, value, locale)
+            exists(key, locale) & ~match
           else
-            value.nil? ? ~has_locale(key, locale) : matches(key, value, locale)
+            values.nil? ? ~exists(key, locale) : match
           end
         end
 
-        def matches(_key, _value, _locale)
-          raise NotImplementedError
-        end
 
-        def has_locale(_key, _locale)
-          raise NotImplementedError
+        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

@@ -25,7 +25,12 @@ models. For details see backend-specific subclasses.
         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.rb

@@ -49,18 +49,20 @@ Sequel serialization plugin.
 
       setup do |attributes, options|
         format = options[:format]
+        column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+        columns = attributes.map { |attribute| (column_affix % attribute).to_sym }
+
         plugin :serialization
         plugin :serialization_modification_detection
 
-        attributes.each do |attribute_|
-          attribute = attribute_.to_sym
-          self.serialization_map[attribute] = Serialized.serializer_for(format)
-          self.deserialization_map[attribute] = Serialized.deserializer_for(format)
+        columns.each do |column|
+          self.serialization_map[column] = Serialized.serializer_for(format)
+          self.deserialization_map[column] = Serialized.deserializer_for(format)
         end
 
         method_overrides = Module.new do
           define_method :initialize_set do |values|
-            attributes.each { |attribute| self[attribute.to_sym] = {}.send(:"to_#{format}") }
+            columns.each { |column| self[column] = {}.send(:"to_#{format}") }
             super(values)
           end
         end
@@ -74,13 +76,12 @@ Sequel serialization plugin.
       # Returns deserialized column value
       # @return [Hash]
       def translations
-        attribute_ = attribute.to_sym
-        if model.deserialized_values.has_key?(attribute_)
-          model.deserialized_values[attribute_]
+        if model.deserialized_values.has_key?(column_name)
+          model.deserialized_values[column_name]
         elsif model.frozen?
-          deserialize_value(attribute_, serialized_value)
+          deserialize_value(serialized_value)
         else
-          model.deserialized_values[attribute_] = deserialize_value(attribute_, serialized_value)
+          model.deserialized_values[column_name] = deserialize_value(serialized_value)
         end
       end
 
@@ -96,12 +97,16 @@ Sequel serialization plugin.
 
       private
 
-      def deserialize_value(column, value)
-        model.send(:deserialize_value, column, value)
+      def deserialize_value(value)
+        model.send(:deserialize_value, column_name, value)
       end
 
       def serialized_value
-        model[attribute.to_sym]
+        model[column_name]
+      end
+
+      def column_name
+        super.to_sym
       end
     end
   end

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

@@ -3,17 +3,20 @@ require "mobility/backends/sequel/query_methods"
 
 module Mobility
   module Backends
-    class Sequel::Serialized::QueryMethods < Sequel::QueryMethods
-      include Serialized
+    module Sequel
+      class Serialized::QueryMethods < QueryMethods
+        include Backends::Serialized
 
-      def initialize(attributes, _)
-        super
-        q = self
+        def initialize(attributes, _)
+          super
+          q = self
 
-        define_method :where do |*cond, &block|
-          q.check_opts(cond.first) || super(*cond, &block)
+          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.rb

@@ -84,7 +84,7 @@ Implements the {Mobility::Backends::Table} backend for Sequel models.
         end
         include callback_methods
 
-        include Mobility::Sequel::ColumnChanges.new(*attributes)
+        include Mobility::Sequel::ColumnChanges.new(attributes)
       end
 
       setup_query_methods(QueryMethods)

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

@@ -3,51 +3,56 @@ require "mobility/backends/sequel/query_methods"
 
 module Mobility
   module Backends
-    class Sequel::Table::QueryMethods < Sequel::QueryMethods
-      def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
-        super
-        translation_class = model_class.const_get(subclass_name)
+    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
+          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
+        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]
-                     })
+            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
-      end
 
-      def define_query_methods(association_name, translation_class, **)
-        q = self
+        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 { |attr| cond[::Sequel[translation_class.table_name][attr]] = cond.delete(attr) }
-              super(cond, &block).send("join_#{association_name}", outer_join: outer_join)
-            else
-              super(*conds, &block)
+          # 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