mobility 1.0.0.alpha → 1.0.1

data/lib/mobility/active_record/model_translation.rb

@@ -1,14 +0,0 @@
-module Mobility
-  module ActiveRecord
-=begin
-
-Subclassed dynamically to generate translation class in
-{Backends::ActiveRecord::Table} backend.
-
-=end
-    class ModelTranslation < ::ActiveRecord::Base
-      self.abstract_class = true
-      validates :locale, presence: true
-    end
-  end
-end

data/lib/mobility/active_record/string_translation.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "mobility/active_record/translation"
-
-module Mobility
-  module ActiveRecord
-    class StringTranslation < Translation
-      self.table_name = "mobility_string_translations"
-    end
-  end
-end

data/lib/mobility/active_record/text_translation.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "mobility/active_record/translation"
-
-module Mobility
-  module ActiveRecord
-    class TextTranslation < Translation
-      self.table_name = "mobility_text_translations"
-    end
-  end
-end

data/lib/mobility/active_record/translation.rb

@@ -1,14 +0,0 @@
-module Mobility
-  module ActiveRecord
-    # @abstract Subclass and set +table_name+ to implement for a particular column type.
-    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
-  end
-end

data/lib/mobility/arel.rb

@@ -1,49 +0,0 @@
-# frozen-string-literal: true
-require "mobility/arel/nodes"
-require "mobility/arel/visitor"
-
-module Mobility
-  module Arel
-    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
-  end
-end

data/lib/mobility/arel/nodes.rb

@@ -1,13 +0,0 @@
-# frozen-string-literal: true
-module Mobility
-  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_Arel_Nodes_Grouping :visit_Arel_Nodes_Grouping
-      end
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-# frozen-string-literal: true
-require "mobility/arel"
-
-module Mobility
-  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 ::Mobility::Arel::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(Arel::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_Arel_Nodes_JsonDashArrow o, a
-        json_infix o, a, '->'
-      end
-
-      def visit_Mobility_Arel_Nodes_JsonDashDoubleArrow o, a
-        json_infix o, a, '->>'
-      end
-
-      def visit_Mobility_Arel_Nodes_JsonbDashArrow o, a
-        json_infix o, a, '->'
-      end
-
-      def visit_Mobility_Arel_Nodes_JsonbDashDoubleArrow o, a
-        json_infix o, a, '->>'
-      end
-
-      def visit_Mobility_Arel_Nodes_JsonbQuestion o, a
-        json_infix o, a, '?'
-      end
-
-      def visit_Mobility_Arel_Nodes_HstoreDashArrow o, a
-        json_infix o, a, '->'
-      end
-
-      def visit_Mobility_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

data/lib/mobility/arel/visitor.rb

@@ -1,61 +0,0 @@
-# frozen-string-literal: true
-module Mobility
-  module Arel
-    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
-  end
-end

data/lib/mobility/sequel/column_changes.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-  module Sequel
-=begin
-
-Internal class used to force Sequel model to notice changes when mobility
-setter method is called.
-
-=end
-    class ColumnChanges < Module
-      # @param [Array<String>] attributes Backend attributes
-      def initialize(attributes, column_affix: "%s")
-        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
-  end
-end

data/lib/mobility/sequel/hash_initializer.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-  module Sequel
-=begin
-
-Internal class used to initialize column value(s) by default to a hash.
-
-=end
-    class HashInitializer < Module
-      def initialize(*columns)
-        class_eval <<-EOM, __FILE__, __LINE__ + 1
-          def initialize_set(values)
-            #{columns.map { |c| "self[:#{c}] = {}" }.join(';')}
-            super
-          end
-        EOM
-      end
-    end
-  end
-end

data/lib/mobility/sequel/model_translation.rb

@@ -1,20 +0,0 @@
-module Mobility
-  module Sequel
-=begin
-
-Module included in translation class dynamically generated by
-{Backends::Sequel::Table} backend.
-
-=end
-    module ModelTranslation
-      def self.included(base)
-        base.plugin :validation_helpers
-      end
-
-      def validate
-        super
-        validates_presence [:locale]
-      end
-    end
-  end
-end

data/lib/mobility/sequel/sql.rb

@@ -1,16 +0,0 @@
-module Mobility
-  module Sequel
-    module SQL
-      class QualifiedIdentifier < ::Sequel::SQL::QualifiedIdentifier
-        attr_reader :backend_class, :locale, :attribute_name
-
-        def initialize(table, column, locale, backend_class, attribute_name: nil)
-          @backend_class = backend_class
-          @locale = locale
-          @attribute_name = attribute_name || column
-          super(table, column)
-        end
-      end
-    end
-  end
-end

data/lib/mobility/sequel/string_translation.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "mobility/sequel/translation"
-
-module Mobility
-  module Sequel
-    class StringTranslation < ::Sequel::Model(:mobility_string_translations)
-      include Translation
-    end
-  end
-end

data/lib/mobility/sequel/text_translation.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "mobility/sequel/translation"
-
-module Mobility
-  module Sequel
-    class TextTranslation < ::Sequel::Model(:mobility_text_translations)
-      include Translation
-    end
-  end
-end

data/lib/mobility/sequel/translation.rb

@@ -1,53 +0,0 @@
-module Mobility
-  module Sequel
-    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
-  end
-end