mobility 1.0.0.beta2 → 1.0.3

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require "mobility/backends/active_record"
 require "mobility/backends/container"
-require "mobility/arel/nodes/pg_ops"
+require "mobility/plugins/arel/nodes/pg_ops"
 
 module Mobility
   module Backends
@@ -49,15 +49,15 @@ Implements the {Mobility::Backends::Container} backend for ActiveRecord models.
 
         # @param [String] attr Attribute name
         # @param [Symbol] locale Locale
-        # @return [Mobility::Arel::Nodes::Json,Mobility::Arel::Nodes::Jsonb] Arel
+        # @return [Mobility::Plugins::Arel::Nodes::Json,Mobility::Arel::Nodes::Jsonb] Arel
         #   node for attribute on json or jsonb column
         def build_node(attr, locale)
           column = model_class.arel_table[column_name]
           case column_type
           when :json
-            Arel::Nodes::JsonContainer.new(column, build_quoted(locale), build_quoted(attr))
+            Plugins::Arel::Nodes::JsonContainer.new(column, build_quoted(locale), build_quoted(attr))
           when :jsonb
-            Arel::Nodes::JsonbContainer.new(column, build_quoted(locale), build_quoted(attr))
+            Plugins::Arel::Nodes::JsonbContainer.new(column, build_quoted(locale), build_quoted(attr))
           end
         end
 

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

@@ -1,5 +1,5 @@
 require 'mobility/backends/active_record/pg_hash'
-require 'mobility/arel/nodes/pg_ops'
+require 'mobility/plugins/arel/nodes/pg_ops'
 
 module Mobility
   module Backends
@@ -24,11 +24,11 @@ Implements the {Mobility::Backends::Hstore} backend for ActiveRecord models.
 
         # @param [String] attr Attribute name
         # @param [Symbol] locale Locale
-        # @return [Mobility::Arel::Nodes::Hstore] Arel node for value of
+        # @return [Mobility::Plugins::Arel::Nodes::Hstore] Arel node for value of
         #   attribute key on hstore column
         def self.build_node(attr, locale)
           column_name = column_affix % attr
-          Arel::Nodes::Hstore.new(model_class.arel_table[column_name], build_quoted(locale))
+          Plugins::Arel::Nodes::Hstore.new(model_class.arel_table[column_name], build_quoted(locale))
         end
       end
     end

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

@@ -1,5 +1,5 @@
 require 'mobility/backends/active_record/pg_hash'
-require 'mobility/arel/nodes/pg_ops'
+require 'mobility/plugins/arel/nodes/pg_ops'
 
 module Mobility
   module Backends
@@ -32,11 +32,11 @@ Implements the {Mobility::Backends::Json} backend for ActiveRecord models.
 
         # @param [String] attr Attribute name
         # @param [Symbol] locale Locale
-        # @return [Mobility::Arel::Nodes::Json] Arel node for value of
+        # @return [Mobility::Plugins::Arel::Nodes::Json] Arel node for value of
         #   attribute key on jsonb column
         def self.build_node(attr, locale)
           column_name = column_affix % attr
-          Arel::Nodes::Json.new(model_class.arel_table[column_name], build_quoted(locale))
+          Plugins::Arel::Nodes::Json.new(model_class.arel_table[column_name], build_quoted(locale))
         end
       end
     end

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

@@ -1,5 +1,5 @@
 require 'mobility/backends/active_record/pg_hash'
-require 'mobility/arel/nodes/pg_ops'
+require 'mobility/plugins/arel/nodes/pg_ops'
 
 module Mobility
   module Backends
@@ -32,11 +32,11 @@ Implements the {Mobility::Backends::Jsonb} backend for ActiveRecord models.
 
         # @param [String] attr Attribute name
         # @param [Symbol] locale Locale
-        # @return [Mobility::Arel::Nodes::Jsonb] Arel node for value of
+        # @return [Mobility::Plugins::Arel::Nodes::Jsonb] Arel node for value of
         #   attribute key on jsonb column
         def self.build_node(attr, locale)
           column_name = column_affix % attr
-          Arel::Nodes::Jsonb.new(model_class.arel_table[column_name], build_quoted(locale))
+          Plugins::Arel::Nodes::Jsonb.new(model_class.arel_table[column_name], build_quoted(locale))
         end
       end
     end

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

@@ -1,8 +1,6 @@
 # frozen-string-literal: true
 require "mobility/backends/active_record"
 require "mobility/backends/key_value"
-require "mobility/active_record/string_translation"
-require "mobility/active_record/text_translation"
 
 module Mobility
   module Backends
@@ -37,21 +35,21 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
           super
           if type = options[:type]
             options[:association_name] ||= :"#{options[:type]}_translations"
-            options[:class_name]       ||= Mobility::ActiveRecord.const_get("#{type.capitalize}Translation")
+            options[:class_name]       ||= const_get("#{type.capitalize}Translation")
           end
           options[:table_alias_affix] = "#{model_class}_%s_#{options[:association_name]}"
         rescue NameError
-          raise ArgumentError, "You must define a Mobility::ActiveRecord::#{type.capitalize}Translation class."
+          raise ArgumentError, "You must define a Mobility::Backends::ActiveRecord::KeyValue::#{type.capitalize}Translation class."
         end
         # @!endgroup
 
         # @param [String] attr Attribute name
         # @param [Symbol] _locale Locale
-        # @return [Mobility::Arel::Attribute] Arel attribute for aliased
+        # @return [Mobility::Plugins::Arel::Attribute] Arel attribute for aliased
         #   translation table value column
         def build_node(attr, locale)
           aliased_table = class_name.arel_table.alias(table_alias(attr, locale))
-          Arel::Attribute.new(aliased_table, :value, locale, self, attr.to_sym)
+          Plugins::Arel::Attribute.new(aliased_table, :value, locale, self, attr.to_sym)
         end
 
         # Joins translations using either INNER/OUTER join appropriate to the query.
@@ -119,7 +117,7 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
       # The title predicate has a non-nil value, so we can use an INNER JOIN,
       # whereas we are searching for nil content, which requires an OUTER JOIN.
       #
-      class Visitor < ::Mobility::Arel::Visitor
+      class Visitor < Plugins::Arel::Visitor
         private
 
         def visit_Arel_Nodes_Equality(object)
@@ -141,7 +139,7 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
             transform_values { OUTER_JOIN }
         end
 
-        def visit_Mobility_Arel_Attribute(object)
+        def visit_Mobility_Plugins_Arel_Attribute(object)
           if object.backend_class == backend_class && object.locale == locale
             { object.attribute_name => OUTER_JOIN }
           end
@@ -194,8 +192,8 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
 
       # Returns translation for a given locale, or builds one if none is present.
       # @param [Symbol] locale
-      # @return [Mobility::ActiveRecord::TextTranslation,Mobility::ActiveRecord::StringTranslation]
-      def translation_for(locale, _options = {})
+      # @return [Mobility::Backends::ActiveRecord::KeyValue::TextTranslation,Mobility::Backends::ActiveRecord::KeyValue::StringTranslation]
+      def translation_for(locale, **)
         translation = translations.find { |t| t.key == attribute && t.locale == locale.to_s }
         translation ||= translations.build(locale: locale, key: attribute)
         translation
@@ -205,12 +203,30 @@ Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
         def self.included(model_class)
           model_class.after_destroy do
             [:string, :text].each do |type|
-              Mobility::ActiveRecord.const_get("#{type.capitalize}Translation").
+              Mobility::Backends::ActiveRecord::KeyValue.const_get("#{type.capitalize}Translation").
                 where(translatable: self).destroy_all
             end
           end
         end
       end
+
+      class Translation < ::ActiveRecord::Base
+        self.abstract_class = true
+
+        belongs_to :translatable, polymorphic: true, touch: true
+
+        validates :key, presence: true, uniqueness: { scope: [:translatable_id, :translatable_type, :locale], case_sensitive: true }
+        validates :translatable, presence: true
+        validates :locale, presence: true
+      end
+
+      class TextTranslation < Translation
+        self.table_name = "mobility_text_translations"
+      end
+
+      class StringTranslation < Translation
+        self.table_name = "mobility_string_translations"
+      end
     end
 
     register_backend(:active_record_key_value, ActiveRecord::KeyValue)

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

@@ -1,7 +1,6 @@
 # frozen-string-literal: true
 require "mobility/backends/active_record"
 require "mobility/backends/table"
-require "mobility/active_record/model_translation"
 
 module Mobility
   module Backends
@@ -116,10 +115,10 @@ columns to that table.
 
         # @param [String] attr Attribute name
         # @param [Symbol] _locale Locale
-        # @return [Mobility::Arel::Attribute] Arel node for column on translation table
+        # @return [Mobility::Plugins::Arel::Attribute] Arel node for column on translation table
         def build_node(attr, locale)
           aliased_table = model_class.const_get(subclass_name).arel_table.alias(table_alias(locale))
-          Arel::Attribute.new(aliased_table, attr, locale, self)
+          Plugins::Arel::Attribute.new(aliased_table, attr, locale, self)
         end
 
         # Joins translations using either INNER/OUTER join appropriate to the
@@ -190,7 +189,7 @@ columns to that table.
       # we need an OUTER JOIN. In the second case, one attribute is matched
       # against a non-nil value, so we can use an INNER JOIN.
       #
-      class Visitor < Arel::Visitor
+      class Visitor < Plugins::Arel::Visitor
         private
 
         def visit_Arel_Nodes_Equality(object)
@@ -227,7 +226,7 @@ columns to that table.
           end
         end
 
-        def visit_Mobility_Arel_Attribute(object)
+        def visit_Mobility_Plugins_Arel_Attribute(object)
           # We compare table names here to ensure that attributes defined on
           # different backends but the same table will correctly get an OUTER
           # join when required. Use options[:table_name] here since we don't
@@ -245,7 +244,7 @@ columns to that table.
           if self.const_defined?(subclass_name, false)
             const_get(subclass_name, false)
           else
-            const_set(subclass_name, Class.new(Mobility::ActiveRecord::ModelTranslation))
+            const_set(subclass_name, Class.new(Translation))
           end
 
         translation_class.table_name = options[:table_name]
@@ -303,6 +302,12 @@ columns to that table.
           destroy(empty_translations) if empty_translations.any?
         end
       end
+
+      # Subclassed dynamically to generate translation class.
+      class Translation < ::ActiveRecord::Base
+        self.abstract_class = true
+        validates :locale, presence: true
+      end
     end
 
     register_backend(:active_record_table, ActiveRecord::Table)

data/lib/mobility/backends/sequel.rb

@@ -30,6 +30,38 @@ module Mobility
         def prepare_dataset(dataset, _predicate, _locale)
           dataset
         end
+
+        # Forces Sequel to notice changes when Mobility setter method is
+        # called.
+        # TODO: Find a better way to do this.
+        def define_column_changes(mod, attributes, column_affix: "%s")
+          mod.class_eval do
+            attributes.each do |attribute|
+              define_method "#{attribute}=" do |value, **options|
+                if !options[:super] && send(attribute) != value
+                  locale = options[:locale] || Mobility.locale
+                  column = (column_affix % attribute).to_sym
+                  attribute_with_locale = :"#{attribute}_#{Mobility.normalize_locale(locale)}"
+                  @changed_columns = changed_columns | [column, attribute.to_sym, attribute_with_locale]
+                end
+                super(value, **options)
+              end
+            end
+          end
+        end
+
+        # Initialize column value(s) by default to a hash.
+        # TODO: Find a better way to do this.
+        def define_hash_initializer(mod, columns)
+          mod.class_eval do
+            class_eval <<-EOM, __FILE__, __LINE__ + 1
+              def initialize_set(values)
+                #{columns.map { |c| "self[:#{c}] = {}" }.join(';')}
+                super
+              end
+            EOM
+          end
+        end
       end
     end
   end

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

@@ -57,9 +57,11 @@ Implements the {Mobility::Backends::Container} backend for Sequel models.
         end
       end
 
+      backend = self
+
       setup do |attributes, options|
         column_name = options[:column_name]
-        before_validation = Module.new do
+        mod = Module.new do
           define_method :before_validation do
             self[column_name].each do |k, v|
               v.delete_if { |_locale, translation| Util.blank?(translation) }
@@ -68,8 +70,8 @@ Implements the {Mobility::Backends::Container} backend for Sequel models.
             super()
           end
         end
-        include before_validation
-        include Mobility::Sequel::HashInitializer.new(column_name)
+        include mod
+        backend.define_hash_initializer(mod, [column_name])
 
         plugin :defaults_setter
         attributes.each { |attribute| default_values[attribute.to_sym] = {} }

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

@@ -2,11 +2,6 @@
 require "mobility/util"
 require "mobility/backends/sequel"
 require "mobility/backends/key_value"
-require "mobility/sequel/column_changes"
-require "mobility/sequel/hash_initializer"
-require "mobility/sequel/string_translation"
-require "mobility/sequel/text_translation"
-require "mobility/sequel/sql"
 
 module Mobility
   module Backends
@@ -34,7 +29,7 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
           super
           if type = options[:type]
             options[:association_name] ||= :"#{options[:type]}_translations"
-            options[:class_name]       ||= Mobility::Sequel.const_get("#{type.capitalize}Translation")
+            options[:class_name]       ||= const_get("#{type.capitalize}Translation")
           end
           options[:table_alias_affix] = "#{model_class}_%s_#{options[:association_name]}"
         rescue NameError
@@ -43,7 +38,7 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
         # @!endgroup
 
         def build_op(attr, locale)
-          ::Mobility::Sequel::SQL::QualifiedIdentifier.new(table_alias(attr, locale), :value, locale, self, attribute_name: attr)
+          QualifiedIdentifier.new(table_alias(attr, locale), :value, locale, self, attr)
         end
 
         # @param [Sequel::Dataset] dataset Dataset to prepare
@@ -75,7 +70,7 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
           case predicate
           when Array
             visit_collection(predicate, locale)
-          when ::Mobility::Sequel::SQL::QualifiedIdentifier
+          when QualifiedIdentifier
             visit_sql_identifier(predicate, locale)
           when ::Sequel::SQL::BooleanExpression
             visit_boolean(predicate, locale)
@@ -128,6 +123,8 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
         end
       end
 
+      backend = self
+
       setup do |attributes, options|
         association_name   = options[:association_name]
         translations_class = options[:class_name]
@@ -159,13 +156,14 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
         include callback_methods
 
         include DestroyKeyValueTranslations
-        include Mobility::Sequel::ColumnChanges.new(attributes)
+        include(mod = Module.new)
+        backend.define_column_changes(mod, attributes)
       end
 
       # Returns translation for a given locale, or initializes one if none is present.
       # @param [Symbol] locale
-      # @return [Mobility::Sequel::TextTranslation,Mobility::Sequel::StringTranslation]
-      def translation_for(locale, _)
+      # @return [Mobility::Backends::Sequel::KeyValue::TextTranslation,Mobility::Backends::Sequel::KeyValue::StringTranslation]
+      def translation_for(locale, **)
         translation = model.send(association_name).find { |t| t.key == attribute && t.locale == locale.to_s }
         translation ||= class_name.new(locale: locale, key: attribute)
         translation
@@ -184,7 +182,7 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
         def after_destroy
           super
           [:string, :text].freeze.each do |type|
-            Mobility::Sequel.const_get("#{type.capitalize}Translation").
+            Mobility::Backends::Sequel::KeyValue.const_get("#{type.capitalize}Translation").
               where(translatable_id: id, translatable_type: self.class.name).destroy
           end
         end
@@ -201,6 +199,75 @@ Implements the {Mobility::Backends::KeyValue} backend for Sequel models.
           (model.send(association_name) + cache.values).uniq
         end
       end
+
+      class QualifiedIdentifier < ::Sequel::SQL::QualifiedIdentifier
+        attr_reader :backend_class, :locale, :attribute_name
+
+        def initialize(table, column, locale, backend_class, attribute_name)
+          @backend_class = backend_class
+          @locale = locale
+          @attribute_name = attribute_name || column
+          super(table, column)
+        end
+      end
+
+      module Translation
+        def self.included(base)
+          base.class_eval do
+            plugin :validation_helpers
+
+            # Paraphased from sequel_polymorphic gem
+            #
+            model = underscore(self.to_s)
+            plural_model = pluralize(model)
+            many_to_one :translatable,
+              reciprocal: plural_model.to_sym,
+              reciprocal_type: :many_to_one,
+              setter: (proc do |able_instance|
+                self[:translatable_id]   = (able_instance.pk if able_instance)
+                self[:translatable_type] = (able_instance.class.name if able_instance)
+              end),
+              dataset: (proc do
+                translatable_type = send :translatable_type
+                translatable_id   = send :translatable_id
+                return if translatable_type.nil? || translatable_id.nil?
+                klass = self.class.send(:constantize, translatable_type)
+                klass.where(klass.primary_key => translatable_id)
+              end),
+              eager_loader: (proc do |eo|
+                id_map = {}
+                eo[:rows].each do |model|
+                  model_able_type = model.send :translatable_type
+                  model_able_id = model.send :translatable_id
+                  model.associations[:translatable] = nil
+                  ((id_map[model_able_type] ||= {})[model_able_id] ||= []) << model if !model_able_type.nil? && !model_able_id.nil?
+                end
+                id_map.each do |klass_name, id_map|
+                  klass = constantize(camelize(klass_name))
+                  klass.where(klass.primary_key=>id_map.keys).all do |related_obj|
+                    id_map[related_obj.pk].each do |model|
+                      model.associations[:translatable] = related_obj
+                    end
+                  end
+                end
+              end)
+
+            def validate
+              super
+              validates_presence [:locale, :key, :translatable_id, :translatable_type]
+              validates_unique   [:locale, :key, :translatable_id, :translatable_type]
+            end
+          end
+        end
+      end
+
+      class TextTranslation < ::Sequel::Model(:mobility_text_translations)
+        include Translation
+      end
+
+      class StringTranslation < ::Sequel::Model(:mobility_string_translations)
+        include Translation
+      end
     end
 
     register_backend(:sequel_key_value, Sequel::KeyValue)