mobility 0.8.13 → 1.0.0

data/lib/mobility/backend/orm_delegator.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-module Mobility
-  module Backend
-=begin
-
-Adds {#for} method to backend to return ORM-specific backend.
-
-@example KeyValue backend for AR model
-  class Post < ActiveRecord::Base
-    # ...
-  end
-  Mobility::Backends::KeyValue.for(Post)
-  #=> Mobility::Backends::ActiveRecord::KeyValue
-
-=end
-    module OrmDelegator
-      # @param [Class] model_class Class of model
-      # @return [Class] Class of backend to use for model
-      def for(model_class)
-        namespace = name.split('::')
-        if Loaded::ActiveRecord && model_class < ::ActiveRecord::Base
-          require_backend("active_record", namespace.last.underscore)
-          const_get(namespace.insert(-2, "ActiveRecord").join("::"))
-        elsif Loaded::Sequel && model_class < ::Sequel::Model
-          require_backend("sequel", namespace.last.underscore)
-          const_get(namespace.insert(-2, "Sequel").join("::"))
-        else
-          raise ArgumentError, "#{namespace.last} backend can only be used by ActiveRecord or Sequel models"
-        end
-      end
-
-      private
-
-      def require_backend(orm, backend)
-        begin
-          orm_backend = "mobility/backends/#{orm}/#{backend}"
-          require orm_backend
-        rescue LoadError => e
-          raise unless e.message =~ /#{orm_backend}/
-        end
-      end
-    end
-  end
-end

data/lib/mobility/backend_resetter.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-=begin
-
-Resets backend cache when reset events occur.
-
-@example Add trigger to call a method +my_backend_reset_method+ on backend instance when reset event(s) occurs on model
-  resetter = Mobility::BackendResetter.for(MyModel).new(attributes) { my_backend_reset_method }
-  MyModel.include(resetter)
-
-@see Mobility::ActiveRecord::BackendResetter
-@see Mobility::ActiveModel::BackendResetter
-@see Mobility::Sequel::BackendResetter
-
-=end
-  class BackendResetter < Module
-    # @param [Array<String>] attribute_names Names of attributes whose backends should be reset
-    # @yield Backend to reset as context for block
-    # @raise [ArgumentError] if no block is provided.
-    def initialize(attribute_names, &block)
-      raise ArgumentError, "block required" unless block_given?
-      names = attribute_names.map(&:to_sym)
-      @model_reset_method = Proc.new do
-        names.each do |name|
-          if @mobility_backends && @mobility_backends[name]
-            @mobility_backends[name].instance_eval(&block)
-          end
-        end
-      end
-    end
-
-    # Returns backend resetter class for model class
-    # @param [Class] model_class Class of model to which backend resetter will be applied
-    def self.for(model_class)
-      if Loaded::ActiveRecord && model_class < ::ActiveRecord::Base
-        require "mobility/active_record/backend_resetter"
-        ActiveRecord::BackendResetter
-      elsif Loaded::ActiveRecord && model_class.ancestors.include?(::ActiveModel::Dirty)
-        require "mobility/active_model/backend_resetter"
-        ActiveModel::BackendResetter
-      elsif Loaded::Sequel && model_class < ::Sequel::Model
-        require "mobility/sequel/backend_resetter"
-        Sequel::BackendResetter
-      else
-        self
-      end
-    end
-  end
-end

data/lib/mobility/configuration.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-=begin
-
-Stores shared Mobility configuration referenced by all backends.
-
-=end
-  class Configuration
-    RESERVED_OPTION_KEYS = %i[backend model_class].freeze
-
-    # Alias for mobility_accessor (defaults to +translates+)
-    # @return [Symbol]
-    attr_accessor :accessor_method
-
-    # Name of query scope/dataset method (defaults to +i18n+)
-    # @return [Symbol]
-    attr_accessor :query_method
-
-    # Default set of options. These will be merged with any backend options
-    # when defining translated attributes (with +translates+). Default options
-    # may not include the keys 'backend' or 'model_class'.
-    # @return [Hash]
-    attr_reader :default_options
-
-    # @deprecated The default_options= setter has been deprecated. Set each
-    #   option on the default_options hash instead.
-    def default_options=(options)
-      warn %{
-WARNING: The default_options= setter has been deprecated.
-Set each option on the default_options hash instead, like this:
-
-  config.default_options[:fallbacks] = { ... }
-  config.default_options[:dirty] = true
-}
-      if (keys = options.keys & RESERVED_OPTION_KEYS).present?
-        raise ReservedOptionKey,
-          "Default options may not contain the following reserved keys: #{keys.join(', ')}"
-      else
-        @default_options = options
-      end
-    end
-
-    # Plugins to apply. Order of plugins is important, as this becomes the
-    # order in which plugins modules are included into the backend class or
-    # attributes instance.
-    # @return [Array<Symbol>]
-    attr_accessor :plugins
-
-    # Generate new fallbacks instance
-    # @note This method will call the proc defined in the variable set by the
-    # +fallbacks_generator=+ setter, passing the first argument to its `call`
-    # method. By default the generator returns an instance of
-    # +I18n::Locale::Fallbacks+.
-    # @param fallbacks [Hash] Fallbacks hash passed to generator
-    # @return [I18n::Locale::Fallbacks]
-    def new_fallbacks(fallbacks = {})
-      @fallbacks_generator.call(fallbacks)
-    end
-
-    # Assign proc which, passed a set of fallbacks, returns a default fallbacks
-    # instance. By default this is a proc which takes fallbacks and returns an
-    # instance of +I18n::Locale::Fallbacks+.
-    # @param [Proc] fallbacks generator
-    attr_writer :fallbacks_generator
-
-    # @deprecated Use {#new_fallbacks} instead.
-    def default_fallbacks(fallbacks = {})
-      warn %{
-WARNING: The default_fallbacks configuration getter has been renamed
-new_fallbacks to avoid confusion. The original method default_fallbacks will be
-removed in the next major version of Mobility.
-}
-      new_fallbacks(fallbacks)
-    end
-
-    # @deprecated Use {#fallbacks_generator=} instead.
-    def default_fallbacks=(fallbacks)
-      warn %{
-WARNING: The default_fallbacks= configuration setter has been renamed
-fallbacks_generator= to avoid confusion. The original method
-default_fallbacks= will be removed in the next major version of Mobility.
-}
-      self.fallbacks_generator = fallbacks
-    end
-
-    # Default backend to use (can be symbol or actual backend class)
-    # @return [Symbol,Class]
-    attr_accessor :default_backend
-
-    # Returns set of default accessor locles to use (defaults to
-    # +I18n.available_locales+)
-    # @return [Array<Symbol>]
-    def default_accessor_locales
-      if @default_accessor_locales.is_a?(Proc)
-        @default_accessor_locales.call
-      else
-        @default_accessor_locales
-      end
-    end
-    attr_writer :default_accessor_locales
-
-    def initialize
-      @accessor_method = :translates
-      @query_method = :i18n
-      @fallbacks_generator = lambda { |fallbacks| Mobility::Fallbacks.build(fallbacks) }
-      @default_accessor_locales = lambda { Mobility.available_locales }
-      @default_options = Options[{
-        cache:    true,
-        presence: true,
-        query:    true,
-        default:  Plugins::OPTION_UNSET
-      }]
-      @plugins = %i[
-        query
-        cache
-        dirty
-        fallbacks
-        presence
-        default
-        attribute_methods
-        fallthrough_accessors
-        locale_accessors
-      ]
-    end
-
-    class ReservedOptionKey < Exception; end
-
-    class Options < Hash
-      def []=(key, _)
-        if RESERVED_OPTION_KEYS.include?(key)
-          raise Configuration::ReservedOptionKey, "Default options may not contain the following reserved key: #{key}"
-        end
-        super
-      end
-    end
-  end
-end

data/lib/mobility/fallbacks.rb

@@ -1,28 +0,0 @@
-module Mobility
-=begin
-
-Subclasses +I18n::Locale::Fallbacks+ such that instances of this class
-fall through to fallbacks defined in +I18n.fallbacks+. This allows models to
-customize fallbacks while still falling through to any fallbacks defined
-globally.
-
-=end
-  class Fallbacks < ::I18n::Locale::Fallbacks
-    # @param [Symbol] locale
-    # @return [Array] locales
-    def [](locale)
-      super | I18n.fallbacks[locale]
-    end
-
-    # For this set of fallbacks, return a new fallbacks hash.
-    # @param [Hash] fallbacks
-    # @return [I18n::Locale::Fallbacks,Mobility::Fallbacks] fallbacks hash
-    def self.build(fallbacks)
-      if I18n.respond_to?(:fallbacks)
-        new(fallbacks)
-      else
-        I18n::Locale::Fallbacks.new(fallbacks)
-      end
-    end
-  end
-end

data/lib/mobility/loaded.rb

@@ -1,4 +0,0 @@
-module Mobility
-  module Loaded
-  end
-end

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

@@ -1,38 +0,0 @@
-module Mobility
-  module Plugins
-    module ActiveRecord
-      module TranslatedAttributes
-        def translated_attributes
-          {}
-        end
-
-        def attributes
-          super.merge(translated_attributes)
-        end
-      end
-
-=begin
-
-Module builder adding translated attributes to #attributes hash on model
-instance. See {Mobility::Plugins::AttributeMethods} for further details.
-
-=end
-      class AttributeMethods < Module
-        def initialize(*attribute_names)
-          include TranslatedAttributes
-          define_method :translated_attributes do
-            super().merge(attribute_names.inject({}) do |attributes, name|
-              attributes.merge(name.to_s => send(name))
-            end)
-          end
-        end
-
-        def included(model_class)
-          model_class.class_eval do
-            define_method :untranslated_attributes, ::ActiveRecord::Base.instance_method(:attributes)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mobility/plugins/cache/translation_cacher.rb

@@ -1,40 +0,0 @@
-module Mobility
-  module Plugins
-    module Cache
-=begin
-
-Creates a module to cache a given translation fetch method. The cacher defines
-private methods +cache+ and +clear_cache+ to access and clear, respectively, a
-translations hash.
-
-This cacher is used to cache translation values in {Mobility::Plugins::Cache},
-and also to cache translation *records* in {Mobility::Backends::Table} and
-{Mobility::Backends::KeyValue}.
-
-=end
-      class TranslationCacher < Module
-        # @param [Symbol] fetch_method Name of translation fetch method to cache
-        def initialize(fetch_method)
-          class_eval <<-EOM, __FILE__, __LINE__ + 1
-            def #{fetch_method} locale, **options
-              return super(locale, options) if options.delete(:cache) == false
-              if cache.has_key?(locale)
-                cache[locale]
-              else
-                cache[locale] = super(locale, options)
-              end
-            end
-          EOM
-
-          include CacheMethods
-        end
-
-        module CacheMethods
-          private
-          def cache;       @cache ||= {}; end
-          def clear_cache; @cache = {};   end
-        end
-      end
-    end
-  end
-end

data/lib/mobility/sequel.rb

@@ -1,9 +0,0 @@
-module Mobility
-=begin
-
-Module loading Sequel-specific classes for Mobility models.
-
-=end
-  module Sequel
-  end
-end

data/lib/mobility/sequel/backend_resetter.rb

@@ -1,23 +0,0 @@
-module Mobility
-  module Sequel
-=begin
-
-Backend resetter for Sequel models. Triggers backend reset when +refresh+
-method is called.
-
-=end
-    class BackendResetter < Mobility::BackendResetter
-
-      # (see Mobility::BackendResetter#initialize)
-      def initialize(attribute_names, &block)
-        super
-
-        model_reset_method = @model_reset_method
-
-        define_method :refresh do
-          super().tap { instance_eval(&model_reset_method) }
-        end
-      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