mobility 1.0.0.alpha → 1.0.1

data/lib/mobility/pluggable.rb

@@ -17,6 +17,10 @@ Works with {Mobility::Plugin}. (Subclassed by {Mobility::Translations}.)
         Plugin.configure(self, defaults, &block)
       end
 
+      def included_plugins
+        included_modules.grep(Plugin)
+      end
+
       def defaults
         @defaults ||= {}
       end
@@ -28,9 +32,25 @@ Works with {Mobility::Plugin}. (Subclassed by {Mobility::Translations}.)
     end
 
     def initialize(*, **options)
-      @options = self.class.defaults.merge(options)
+      initialize_options(options)
+      validate_options(@options)
     end
 
     attr_reader :options
+
+    private
+
+    def initialize_options(options)
+      @options = self.class.defaults.merge(options)
+    end
+
+    # This is overridden by backend plugin to exclude mixed-in backend options.
+    def validate_options(options)
+      plugin_keys = self.class.included_plugins.map { |p| Plugins.lookup_name(p) }
+      extra_keys = options.keys - plugin_keys
+      raise InvalidOptionKey, "No plugin configured for these keys: #{extra_keys.join(', ')}." unless extra_keys.empty?
+    end
+
+    class InvalidOptionKey < Error; end
   end
 end

data/lib/mobility/plugin.rb

@@ -121,8 +121,8 @@ Also includes a +configure+ class method to apply plugins to a pluggable
     # Does this class include all plugins this plugin depends (directly) on?
     # @param [Class] klass Pluggable class
     def dependencies_satisfied?(klass)
-      required_plugins = dependencies.keys.map { |name| Plugins.load_plugin(name) }
-      (required_plugins - klass.included_modules).none?
+      plugin_keys = klass.included_plugins.map { |plugin| Plugins.lookup_name(plugin) }
+      (dependencies.keys - plugin_keys).none?
     end
 
     # Specifies a dependency of this plugin.

data/lib/mobility/plugins.rb

@@ -14,6 +14,8 @@ declared in any order (dependencies will be resolved).
     class << self
       # @param [Symbol] name Name of plugin to load.
       def load_plugin(name)
+        return name if Module === name || name.nil?
+
         unless (plugin = @plugins[name])
           require "mobility/plugins/#{name}"
           raise LoadError, "plugin #{name} did not register itself correctly in Mobility::Plugins" unless (plugin = @plugins[name])

data/lib/mobility/plugins/active_model/dirty.rb

@@ -80,7 +80,12 @@ the ActiveRecord dirty plugin for more information.
           attribute_names.each do |name|
             dirty_handler_methods.each_pattern(name) do |method_name, attribute_method|
               define_method(method_name) do |*args|
-                mutations_from_mobility.send(attribute_method, Dirty.append_locale(name), *args)
+                # for %s_changed?(from:, to:) pattern
+                if (kwargs = args.last).is_a?(Hash)
+                  mutations_from_mobility.send(attribute_method, Dirty.append_locale(name), *args[0,-1], **kwargs)
+                else
+                  mutations_from_mobility.send(attribute_method, Dirty.append_locale(name), *args)
+                end
               end
             end
 
@@ -130,11 +135,12 @@ the ActiveRecord dirty plugin for more information.
             public_patterns.each do |pattern|
               method_name = pattern % 'attribute'
 
+              kwargs = pattern == '%s_changed?' ? ', **kwargs' : ''
               module_eval <<-EOM, __FILE__, __LINE__ + 1
-              def #{method_name}(attr_name, *rest)
+              def #{method_name}(attr_name, *rest#{kwargs})
                 if (mutations_from_mobility.attribute_changed?(attr_name) ||
                     mutations_from_mobility.attribute_previously_changed?(attr_name))
-                  mutations_from_mobility.send(#{method_name.inspect}, attr_name, *rest)
+                  mutations_from_mobility.send(#{method_name.inspect}, attr_name, *rest#{kwargs})
                 else
                   super
                 end
@@ -330,11 +336,11 @@ the ActiveRecord dirty plugin for more information.
           # @!group Backend Accessors
           # @!macro backend_writer
           # @param [Hash] options
-          def write(locale, value, options = {})
+          def write(locale, value, **options)
             locale_accessor = Mobility.normalize_locale_accessor(attribute, locale)
             if model.changed_attributes.has_key?(locale_accessor) && model.changed_attributes[locale_accessor] == value
               mutations_from_mobility.restore_attribute!(locale_accessor)
-            elsif read(locale, options.merge(locale: true)) != value
+            elsif read(locale, **options.merge(locale: true)) != value
               mutations_from_mobility.attribute_will_change!(locale_accessor)
             end
             super

data/lib/mobility/plugins/active_record.rb

@@ -15,12 +15,15 @@ Plugin for ActiveRecord models.
     module ActiveRecord
       extend Plugin
 
+      requires :arel
+
       requires :active_record_backend, include: :after
       requires :active_record_dirty
       requires :active_record_cache
       requires :active_record_query
       requires :active_record_uniqueness_validation
 
+
       included_hook do |klass|
         unless active_record_class?(klass)
           name = klass.name || klass.to_s

data/lib/mobility/plugins/active_record/backend.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Mobility
   module Plugins
     module ActiveRecord

data/lib/mobility/plugins/active_record/query.rb

@@ -67,9 +67,9 @@ enabled for any one attribute on the model.
           end
         end
 
-        # Internal class to create a "clean room" for manipulating translated
-        # attribute nodes in an instance-eval'ed block. Inspired by Sequel's
-        # (much more sophisticated) virtual rows.
+        # Creates a "clean room" for manipulating translated attribute nodes in
+        # an instance-eval'ed block. Inspired by Sequel's (much more
+        # sophisticated) virtual rows.
         class VirtualRow < BasicObject
           attr_reader :__backends
 
@@ -108,7 +108,7 @@ enabled for any one attribute on the model.
             end
           end
         end
-        private_constant :QueryMethod, :VirtualRow
+        private_constant :QueryMethod
 
         module QueryExtension
           def where!(opts, *rest)
@@ -199,7 +199,7 @@ enabled for any one attribute on the model.
               # Builds a translated relation for a given opts hash and optional
               # invert boolean.
               def _build(scope, opts, locale, invert)
-                return yield if (mods = attribute_modules(scope)).empty?
+                return yield if (mods = translation_modules(scope)).empty?
 
                 keys, predicates = opts.keys.map(&:to_s), []
 
@@ -222,7 +222,7 @@ enabled for any one attribute on the model.
                 query_map[relation.where(predicates.inject(:and))]
               end
 
-              def attribute_modules(scope)
+              def translation_modules(scope)
                 scope.model.ancestors.grep(::Mobility::Translations)
               end
 
@@ -273,7 +273,7 @@ enabled for any one attribute on the model.
           end
         end
 
-        private_constant :QueryExtension, :FindByMethods
+        private_constant :FindByMethods
       end
 
       class MissingBackend < Mobility::Error; end

data/lib/mobility/plugins/active_record/uniqueness_validation.rb

@@ -10,6 +10,10 @@ module Mobility
           klass.class_eval do
             unless const_defined?(:UniquenessValidator, false)
               self.const_set(:UniquenessValidator, Class.new(UniquenessValidator))
+
+              def self.validates_uniqueness_of(*attr_names)
+                validates_with(UniquenessValidator, _merge_attributes(attr_names))
+              end
             end
           end
         end
@@ -35,7 +39,7 @@ module Mobility
                 error_options = options.except(:case_sensitive, :scope, :conditions)
                 error_options[:value] = value
 
-                record.errors.add(attribute, :taken, error_options)
+                record.errors.add(attribute, :taken, **error_options)
               end
             else
               super

data/lib/mobility/plugins/arel.rb

@@ -0,0 +1,125 @@
+# frozen-string-literal: true
+
+module Mobility
+  module Plugins
+=begin
+
+Plugin for Mobility Arel customizations. Basically used as a namespace to store
+Arel-specific classes and modules.
+
+=end
+    module Arel
+      extend Plugin
+
+      module MobilityExpressions
+        include ::Arel::Expressions
+
+        # @note This is necessary in order to ensure that when a translated
+        #   attribute is selected with an alias using +AS+, the resulting
+        #   expression can still be counted without blowing up.
+        #
+        #   Extending +::Arel::Expressions+ is necessary to convince ActiveRecord
+        #   that this node should not be stringified, which otherwise would
+        #   result in garbage SQL.
+        #
+        # @see https://github.com/rails/rails/blob/847342c25c61acaea988430dc3ab66a82e3ed486/activerecord/lib/active_record/relation/calculations.rb#L261
+        def as(*)
+          super
+            .extend(::Arel::Expressions)
+            .extend(Countable)
+        end
+
+        module Countable
+          # @note This allows expressions with selected translated attributes to
+          #   be counted.
+          def count(*args)
+            left.count(*args)
+          end
+        end
+      end
+
+      class Attribute < ::Arel::Attributes::Attribute
+        include MobilityExpressions
+
+        attr_reader :backend_class
+        attr_reader :locale
+        attr_reader :attribute_name
+
+        def initialize(relation, column_name, locale, backend_class, attribute_name = nil)
+          @backend_class = backend_class
+          @locale = locale
+          @attribute_name = attribute_name || column_name
+          super(relation, column_name)
+        end
+      end
+
+      class Visitor < ::Arel::Visitors::Visitor
+        INNER_JOIN = ::Arel::Nodes::InnerJoin
+        OUTER_JOIN = ::Arel::Nodes::OuterJoin
+
+        attr_reader :backend_class, :locale
+
+        def initialize(backend_class, locale)
+          super()
+          @backend_class, @locale = backend_class, locale
+        end
+
+        private
+
+        def visit(*args)
+          super
+        rescue TypeError
+          visit_default(*args)
+        end
+
+        def visit_collection(_objects)
+          raise NotImplementedError
+        end
+        alias :visit_Array :visit_collection
+
+        def visit_Arel_Nodes_Unary(object)
+          visit(object.expr)
+        end
+
+        def visit_Arel_Nodes_Binary(object)
+          visit_collection([object.left, object.right])
+        end
+
+        def visit_Arel_Nodes_Function(object)
+          visit_collection(object.expressions)
+        end
+
+        def visit_Arel_Nodes_Case(object)
+          visit_collection([object.case, object.conditions, object.default])
+        end
+
+        def visit_Arel_Nodes_And(object)
+          visit_Array(object.children)
+        end
+
+        def visit_Arel_Nodes_Node(object)
+          visit_default(object)
+        end
+
+        def visit_Arel_Attributes_Attribute(object)
+          visit_default(object)
+        end
+
+        def visit_default(_object)
+          nil
+        end
+      end
+
+      module Nodes
+        class Binary < ::Arel::Nodes::Binary; end
+        class Grouping < ::Arel::Nodes::Grouping; end
+
+        ::Arel::Visitors::ToSql.class_eval do
+          alias :visit_Mobility_Plugins_Arel_Nodes_Grouping :visit_Arel_Nodes_Grouping
+        end
+      end
+    end
+
+    register_plugin(:arel, Arel)
+  end
+end

data/lib/mobility/plugins/arel/nodes.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+module Mobility
+  module Plugins
+    module Arel
+      module Nodes
+        class Binary < ::Arel::Nodes::Binary; end
+        class Grouping < ::Arel::Nodes::Grouping; end
+
+        ::Arel::Visitors::ToSql.class_eval do
+          alias :visit_Mobility_Plugins_Arel_Nodes_Grouping :visit_Arel_Nodes_Grouping
+        end
+      end
+    end
+  end
+end

data/lib/mobility/plugins/arel/nodes/pg_ops.rb

@@ -0,0 +1,134 @@
+# frozen-string-literal: true
+require "mobility/plugins/arel"
+
+module Mobility
+  module Plugins
+    module Arel
+      module Nodes
+        %w[
+          JsonDashArrow
+          JsonDashDoubleArrow
+          JsonbDashArrow
+          JsonbDashDoubleArrow
+          JsonbQuestion
+          HstoreDashArrow
+          HstoreQuestion
+        ].each do |name|
+          const_set name, (Class.new(Binary) do
+            include ::Arel::Predications
+            include ::Arel::OrderPredications
+            include ::Arel::AliasPredication
+            include MobilityExpressions
+
+            def lower
+              super self
+            end
+          end)
+        end
+
+        # Needed for AR 4.2, can be removed when support is deprecated
+        if ::ActiveRecord::VERSION::STRING < '5.0'
+          [JsonbDashDoubleArrow, HstoreDashArrow].each do |klass|
+            klass.class_eval do
+              def quoted_node other
+                other && super
+              end
+            end
+          end
+        end
+
+        class Jsonb  < JsonbDashDoubleArrow
+          def to_dash_arrow
+            JsonbDashArrow.new left, right
+          end
+
+          def to_question
+            JsonbQuestion.new left, right
+          end
+
+          def eq other
+            case other
+            when NilClass
+              to_question.not
+            when Integer, Array, ::Hash
+              to_dash_arrow.eq other.to_json
+            when Jsonb
+              to_dash_arrow.eq other.to_dash_arrow
+            when JsonbDashArrow
+              to_dash_arrow.eq other
+            else
+              super
+            end
+          end
+        end
+
+        class Hstore < HstoreDashArrow
+          def to_question
+            HstoreQuestion.new left, right
+          end
+
+          def eq other
+            other.nil? ? to_question.not : super
+          end
+        end
+
+        class Json < JsonDashDoubleArrow; end
+
+        class JsonContainer < Json
+          def initialize column, locale, attr
+            super(Nodes::JsonDashArrow.new(column, locale), attr)
+          end
+        end
+
+        class JsonbContainer < Jsonb
+          def initialize column, locale, attr
+            @column, @locale = column, locale
+            super(JsonbDashArrow.new(column, locale), attr)
+          end
+
+          def eq other
+            other.nil? ? super.or(JsonbQuestion.new(@column, @locale).not) : super
+          end
+        end
+      end
+
+      module Visitors
+        def visit_Mobility_Plugins_Arel_Nodes_JsonDashArrow o, a
+          json_infix o, a, '->'
+        end
+
+        def visit_Mobility_Plugins_Arel_Nodes_JsonDashDoubleArrow o, a
+          json_infix o, a, '->>'
+        end
+
+        def visit_Mobility_Plugins_Arel_Nodes_JsonbDashArrow o, a
+          json_infix o, a, '->'
+        end
+
+        def visit_Mobility_Plugins_Arel_Nodes_JsonbDashDoubleArrow o, a
+          json_infix o, a, '->>'
+        end
+
+        def visit_Mobility_Plugins_Arel_Nodes_JsonbQuestion o, a
+          json_infix o, a, '?'
+        end
+
+        def visit_Mobility_Plugins_Arel_Nodes_HstoreDashArrow o, a
+          json_infix o, a, '->'
+        end
+
+        def visit_Mobility_Plugins_Arel_Nodes_HstoreQuestion o, a
+          json_infix o, a, '?'
+        end
+
+        private
+
+        def json_infix o, a, opr
+          visit(Nodes::Grouping.new(::Arel::Nodes::InfixOperation.new(opr, o.left, o.right)), a)
+        end
+      end
+
+      ::Arel::Visitors::PostgreSQL.include Visitors
+    end
+  end
+end