mobility 0.8.13 → 1.0.0

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/active_record/uniqueness_validator.rb

@@ -1,60 +0,0 @@
-module Mobility
-  module ActiveRecord
-=begin
-
-A backend-agnostic uniqueness validator for ActiveRecord translated attributes.
-To use the validator, you must +extend Mobility+ before calling +validates+
-(see example below).
-
-@note This validator does not support case sensitivity, since doing so would
-  significantly complicate implementation.
-
-@example Validating uniqueness on translated model
-  class Post < ActiveRecord::Base
-    extend Mobility
-    translates :title
-
-    # This must come *after* extending Mobility.
-    validates :title, uniqueness: true
-  end
-=end
-    class UniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
-      # @param [ActiveRecord::Base] record Translated model
-      # @param [String] attribute Name of attribute
-      # @param [Object] value Attribute value
-      def validate_each(record, attribute, value)
-        klass = record.class
-
-        if (([*options[:scope]] + [attribute]).map(&:to_s) & klass.mobility_attributes).present?
-          return unless value.present?
-          relation = klass.unscoped.__mobility_query_scope__ do |m|
-            node = m.__send__(attribute)
-            options[:case_sensitive] == false ? node.lower.eq(value.downcase) : node.eq(value)
-          end
-          relation = relation.where.not(klass.primary_key => record.id) if record.persisted?
-          relation = mobility_scope_relation(record, relation)
-          relation = relation.merge(options[:conditions]) if options[:conditions]
-
-          if relation.exists?
-            error_options = options.except(:case_sensitive, :scope, :conditions)
-            error_options[:value] = value
-
-            record.errors.add(attribute, :taken, error_options)
-          end
-        else
-          super
-        end
-      end
-
-      private
-
-      def mobility_scope_relation(record, relation)
-        [*options[:scope]].inject(relation) do |scoped_relation, scope_item|
-          scoped_relation.__mobility_query_scope__ do |m|
-            m.__send__(scope_item).eq(record.send(scope_item))
-          end
-        end
-      end
-    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/attributes.rb

@@ -1,324 +0,0 @@
-# frozen_string_literal: true
-require "mobility/util"
-
-module Mobility
-=begin
-
-Defines accessor methods to include on model class. Inspired by Traco's
-+Traco::Attributes+ class.
-
-Normally this class will be created through class methods defined using
-{Mobility::Translates} accessor methods, and need not be created directly.
-However, the class is central to how Mobility hooks into models to add
-accessors and other methods, and should be useful as a reference when
-understanding and designing backends.
-
-==Including Attributes in a Class
-
-Since {Attributes} is a subclass of +Module+, including an instance of it is
-like including a module. Creating an instance like this:
-
-  Attributes.new("title", backend: :my_backend, locale_accessors: [:en, :ja], cache: true, fallbacks: true)
-
-will generate an anonymous module that behaves approximately like this:
-
-  Module.new do
-    def mobility_backends
-      # Returns a memoized hash with attribute name keys and backend instance
-      # values.  When a key is fetched from the hash, the hash calls
-      # +self.class.mobility_backend_class(name)+ (where +name+ is the
-      # attribute name) to get the backend class, then instantiate it (passing
-      # the model instance and attribute name to its initializer) and return it.
-      #
-      # The backend class returned from the class method
-      # +mobility_backend_class+ returns a subclass of
-      # +Mobility::Backends::MyBackend+ and includes into it:
-      #
-      # - Mobility::Plugins::Cache (from the +cache: true+ option)
-      # - instance of Mobility::Plugins::Fallbacks (from the +fallbacks: true+ option)
-      # - Mobility::Plugins::Presence (by default, disabled by +presence: false+)
-    end
-
-    def title(locale: Mobility.locale)
-      mobility_backends[:title].read(locale)
-    end
-
-    def title?(locale: Mobility.locale)
-      mobility_backends[:title].read(locale).present?
-    end
-
-    def title=(value, locale: Mobility.locale)
-      mobility_backends[:title].write(locale, value)
-    end
-
-    # Start Locale Accessors
-    #
-    def title_en
-      title(locale: :en)
-    end
-
-    def title_en?
-      title?(locale: :en)
-    end
-
-    def title_en=(value)
-      public_send(:title=, value, locale: :en)
-    end
-
-    def title_ja
-      title(locale: :ja)
-    end
-
-    def title_ja?
-      title?(locale: :ja)
-    end
-
-    def title_ja=(value)
-      public_send(:title=, value, locale: :ja)
-    end
-    # End Locale Accessors
-  end
-
-Including this module into a model class will thus add the backend method, the
-reader, writer and presence methods, and the locale accessor so the model
-class. (These methods are in fact added to the model in an +included+ hook.)
-
-Note that some simplifications have been made above for readability. (In
-reality, all getters and setters accept an options hash which is passed along
-to the backend instance.)
-
-==Setting up the Model Class
-
-Accessor methods alone are of limited use without a hook to actually modify the
-model class. This hook is provided by the {Backend::Setup#setup_model} method,
-which is added to every backend class when it includes the {Backend} module.
-
-Assuming the backend has defined a setup block by calling +setup+, this block
-will be called when {Attributes} is {#included} in the model class, passed
-attributes and options defined when the backend was defined on the model class.
-This allows a backend to do things like (for example) define associations on a
-model class required by the backend, as happens in the {Backends::KeyValue} and
-{Backends::Table} backends.
-
-Since setup blocks are evaluated on the model class, it is possible that
-backends can conflict (for example, overwriting previously defined methods).
-Care should be taken to avoid defining methods on the model class, or where
-necessary, ensure that names are defined in such a way as to avoid conflicts
-with other backends.
-
-=end
-  class Attributes < Module
-
-    # Method (accessor, reader or writer)
-    # @return [Symbol] method
-    attr_reader :method
-
-    # Attribute names for which accessors will be defined
-    # @return [Array<String>] Array of names
-    attr_reader :names
-
-    # Backend options
-    # @return [Hash] Backend options
-    attr_reader :options
-
-    # Backend class
-    # @return [Class] Backend class
-    attr_reader :backend_class
-
-    # Name of backend
-    # @return [Symbol,Class] Name of backend, or backend class
-    attr_reader :backend_name
-
-    # Model class
-    # @return [Class] Class of model
-    attr_reader :model_class
-
-    # @param [Symbol] method One of: [reader, writer, accessor]
-    # @param [Array<String>] attribute_names Names of attributes to define backend for
-    # @param [Hash] backend_options Backend options hash
-    # @option backend_options [Class] model_class Class of model
-    # @raise [ArgumentError] if method is not reader, writer or accessor
-    def initialize(*attribute_names, method: :accessor, backend: Mobility.default_backend, **backend_options)
-      raise ArgumentError, "method must be one of: reader, writer, accessor" unless %i[reader writer accessor].include?(method)
-      @method = method
-      @options = Mobility.default_options.to_h.merge(backend_options)
-      @names = attribute_names.map(&:to_s).freeze
-      raise BackendRequired, "Backend option required if Mobility.config.default_backend is not set." if backend.nil?
-      @backend_name = backend
-    end
-
-    # Setup backend class, include modules into model class, include/extend
-    # shared modules and setup model with backend setup block (see
-    # {Mobility::Backend::Setup#setup_model}).
-    # @param klass [Class] Class of model
-    def included(klass)
-      @model_class = @options[:model_class] = klass
-      @backend_class = get_backend_class(backend_name).for(model_class).with_options(options)
-
-      Mobility.plugins.each do |name|
-        plugin = get_plugin_class(name)
-        plugin.apply(self, options[name])
-      end
-
-      each do |name|
-        define_backend(name)
-        define_reader(name) if %i[accessor reader].include?(method)
-        define_writer(name) if %i[accessor writer].include?(method)
-      end
-
-      klass.include InstanceMethods
-      klass.extend ClassMethods
-
-      backend_class.setup_model(model_class, names)
-    end
-
-    # Yield each attribute name to block
-    # @yieldparam [String] Attribute
-    def each &block
-      names.each(&block)
-    end
-
-    # Show useful information about this module.
-    # @return [String]
-    def inspect
-      "#<Attributes (#{backend_name}) @names=#{names.join(", ")}>"
-    end
-
-    private
-
-    def define_backend(attribute)
-      module_eval <<-EOM, __FILE__, __LINE__ + 1
-      def #{Backend.method_name(attribute)}
-        mobility_backends[:#{attribute}]
-      end
-      EOM
-    end
-
-    def define_reader(attribute)
-      class_eval <<-EOM, __FILE__, __LINE__ + 1
-        def #{attribute}(**options)
-          return super() if options.delete(:super)
-          #{set_locale_from_options_inline}
-          mobility_backends[:#{attribute}].read(locale, options)
-        end
-
-        def #{attribute}?(**options)
-          return super() if options.delete(:super)
-          #{set_locale_from_options_inline}
-          mobility_backends[:#{attribute}].present?(locale, options)
-        end
-      EOM
-    end
-
-    def define_writer(attribute)
-      class_eval <<-EOM, __FILE__, __LINE__ + 1
-        def #{attribute}=(value, **options)
-          return super(value) if options.delete(:super)
-          #{set_locale_from_options_inline}
-          mobility_backends[:#{attribute}].write(locale, value, options)
-        end
-      EOM
-    end
-
-    # This string is evaluated inline in order to optimize performance of
-    # getters and setters, avoiding extra steps where they are unneeded.
-    def set_locale_from_options_inline
-      <<-EOL
-if options[:locale]
-  #{"Mobility.enforce_available_locales!(options[:locale])" if I18n.enforce_available_locales}
-  locale = options[:locale].to_sym
-  options[:locale] &&= !!locale
-else
-  locale = Mobility.locale
-end
-EOL
-    end
-
-    def get_backend_class(backend)
-      return backend if Module === backend
-      require "mobility/backends/#{backend}"
-      get_class_from_key(Mobility::Backends, backend)
-    end
-
-    def get_plugin_class(plugin)
-      require "mobility/plugins/#{plugin}"
-      get_class_from_key(Mobility::Plugins, plugin)
-    end
-
-    def get_class_from_key(parent_class, key)
-      klass_name = key.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
-      parent_class.const_get(klass_name)
-    end
-
-    module InstanceMethods
-      # Return a new backend for an attribute name.
-      # @return [Hash] Hash of attribute names and backend instances
-      # @api private
-      def mobility_backends
-        @mobility_backends ||= Hash.new do |hash, name|
-          next hash[name.to_sym] if String === name
-          hash[name] = self.class.mobility_backend_class(name).new(self, name.to_s)
-        end
-      end
-
-      def initialize_dup(other)
-        @mobility_backends = nil
-        super
-      end
-    end
-
-    module ClassMethods
-      # Return all {Mobility::Attribute} module instances from among ancestors
-      # of this model.
-      # @return [Array<Mobility::Attributes>] Attribute modules
-      def mobility_modules
-        ancestors.grep(Attributes)
-      end
-
-      # Return translated attribute names on this model.
-      # @return [Array<String>] Attribute names
-      def mobility_attributes
-        mobility_modules.map(&:names).flatten.uniq
-      end
-
-      # Return true if attribute name is translated on this model.
-      # @param [String, Symbol] Attribute name
-      # @return [Boolean]
-      def mobility_attribute?(name)
-        mobility_attributes.include?(name.to_s)
-      end
-
-      # @!method translated_attribute_names
-      # @return (see #mobility_attributes)
-      alias translated_attribute_names mobility_attributes
-
-      # Return backend class for a given attribute name.
-      # @param [Symbol,String] Name of attribute
-      # @return [Class] Backend class
-      def mobility_backend_class(name)
-        @backends ||= BackendsCache.new(self)
-        @backends[name.to_sym]
-      end
-
-      class BackendsCache < Hash
-        def initialize(klass)
-          # Preload backend mapping
-          klass.mobility_modules.each do |mod|
-            mod.names.each { |name| self[name.to_sym] = mod.backend_class }
-          end
-
-          super() do |hash, name|
-            if mod = klass.mobility_modules.find { |m| m.names.include? name.to_s }
-              hash[name] = mod.backend_class
-            else
-              raise KeyError, "No backend for: #{name}."
-            end
-          end
-        end
-      end
-      private_constant :BackendsCache
-    end
-  end
-
-  class BackendRequired < ArgumentError; end
-end