mobility 0.8.10 → 1.0.0.beta2

data/lib/mobility/plugins/backend_reader.rb

@@ -0,0 +1,34 @@
+# frozen-string-literal: true
+module Mobility
+  module Plugins
+=begin
+
+Defines convenience methods for accessing backends, of the form
+"<name>_backend". The format for this method can be customized by passing a
+different format string as the plugin option.
+
+=end
+    module BackendReader
+      extend Plugin
+
+      default true
+      requires :backend
+
+      initialize_hook do |*names|
+        if backend_reader = options[:backend_reader]
+          backend_reader = "%s_backend" if backend_reader == true
+
+          names.each do |name|
+            module_eval <<-EOM, __FILE__, __LINE__ + 1
+            def #{backend_reader % name}
+              mobility_backends[:#{name}]
+            end
+            EOM
+          end
+        end
+      end
+    end
+
+    register_plugin(:backend_reader, BackendReader)
+  end
+end

data/lib/mobility/plugins/cache.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "mobility/plugins/cache/translation_cacher"
 
 module Mobility
   module Plugins
@@ -8,8 +7,7 @@ module Mobility
 Caches values fetched from the backend so subsequent fetches can be performed
 more quickly. The cache stores cached values in a simple hash, which is not
 optimal for some storage strategies, so some backends (KeyValue, Table) use a
-custom module through the {Mobility::Backend::Setup#apply_plugin} hook. For
-details see the documentation for these backends.
+custom module by defining a method, +include_cache+, on the backend class.
 
 The cache is reset when one of a set of events happens (saving, reloading,
 etc.). See {BackendResetter} for details.
@@ -21,34 +19,78 @@ Values are added to the cache in two ways:
 
 =end
     module Cache
+      extend Plugin
+
+      default true
+      requires :backend, include: :before
+
       # Applies cache plugin to attributes.
-      # @param [Attributes] attributes
-      # @param [Boolean] option
-      def self.apply(attributes, option)
-        if option
-          backend_class = attributes.backend_class
-          backend_class.include(self) unless backend_class.apply_plugin(:cache)
-
-          model_class = attributes.model_class
-          model_class.include BackendResetter.for(model_class).new(attributes.names) { clear_cache }
+      included_hook do |_, backend_class|
+        if options[:cache]
+          if backend_class.respond_to?(:include_cache)
+            backend_class.include_cache
+          else
+            include_cache(backend_class)
+          end
         end
       end
 
-      # @group Backend Accessors
-      #
-      # @!macro backend_reader
-      # @!method read(locale, value, options = {})
-      #   @option options [Boolean] cache *false* to disable cache.
-      include TranslationCacher.new(:read)
-
-      # @!macro backend_writer
-      # @option options [Boolean] cache
-      #   *false* to disable cache.
-      def write(locale, value, **options)
-        return super if options.delete(:cache) == false
-        cache[locale] = super
+      private
+
+      def include_cache(backend_class)
+        backend_class.include BackendMethods
+      end
+
+      # Used in ORM cache plugins
+      def define_cache_hooks(klass, *reset_methods)
+        mod = self
+        private_methods = reset_methods & klass.private_instance_methods
+        reset_methods.each do |method_name|
+          define_method method_name do |*args|
+            super(*args).tap do
+              mod.names.each { |name| mobility_backends[name].clear_cache }
+            end
+          end
+        end
+        klass.class_eval { private(*private_methods) }
+      end
+
+      module BackendMethods
+        # @group Backend Accessors
+        #
+        # @!macro backend_reader
+        # @!method read(locale, value, options = {})
+        #   @option options [Boolean] cache *false* to disable cache.
+        def read(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
+
+        # @!macro backend_writer
+        # @option options [Boolean] cache
+        #   *false* to disable cache.
+        def write(locale, value, **options)
+          return super if options.delete(:cache) == false
+          cache[locale] = super
+        end
+        # @!endgroup
+
+        def clear_cache
+          @cache = {}
+        end
+
+        private
+
+        def cache
+          @cache ||= {}
+        end
       end
-      # @!endgroup
     end
+
+    register_plugin(:cache, Cache)
   end
 end

data/lib/mobility/plugins/default.rb

@@ -6,8 +6,7 @@ module Mobility
 
 Defines value or proc to fall through to if return value from getter would
 otherwise be nil. This plugin is disabled by default but will be enabled if any
-value (other than +Mobility::Plugins::OPTION_UNSET+) is passed as the +default+
-option key.
+value is passed as the +default+ option key.
 
 If default is a +Proc+, it will be called with the context of the model, and
 passed arguments:
@@ -63,11 +62,13 @@ The proc can accept zero to three arguments (see examples below)
   #=> "Post"
 =end
     module Default
+      extend Plugin
+
+      requires :backend, include: :before
+
       # Applies default plugin to attributes.
-      # @param [Attributes] attributes
-      # @param [Object] option
-      def self.apply(attributes, option)
-        attributes.backend_class.include(self) unless option == Plugins::OPTION_UNSET
+      included_hook do |_klass, backend_class|
+        backend_class.include(BackendMethods)
       end
 
       # Generate a default value for given parameters.
@@ -82,19 +83,23 @@ The proc can accept zero to three arguments (see examples below)
         model.instance_exec(*args, &default_value)
       end
 
-      # @!group Backend Accessors
-      # @!macro backend_reader
-      # @option accessor_options [Boolean] default
-      #   *false* to disable presence filter.
-      def read(locale, accessor_options = {})
-        default = accessor_options.has_key?(:default) ? accessor_options.delete(:default) : options[:default]
-        if (value = super(locale, accessor_options)).nil?
-          Default[default, locale: locale, accessor_options: accessor_options, model: model, attribute: attribute]
-        else
-          value
+      module BackendMethods
+        # @!group Backend Accessors
+        # @!macro backend_reader
+        # @option accessor_options [Boolean] default
+        #   *false* to disable presence filter.
+        def read(locale, accessor_options = {})
+          default = accessor_options.has_key?(:default) ? accessor_options.delete(:default) : options[:default]
+          if (value = super(locale, **accessor_options)).nil?
+            Default[default, locale: locale, accessor_options: accessor_options, model: model, attribute: attribute]
+          else
+            value
+          end
         end
+        # @!endgroup
       end
-      # @!endgroup
     end
+
+    register_plugin(:default, Default)
   end
 end

data/lib/mobility/plugins/dirty.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-require "mobility/backend_resetter"
-require "mobility/plugins/fallthrough_accessors"
 
 module Mobility
   module Plugins
@@ -20,40 +18,21 @@ details.
 
 =end
     module Dirty
-      class << self
-        # Applies dirty plugin to attributes for a given option value.
-        # @param [Attributes] attributes
-        # @param [Boolean] option Value of option
-        # @raise [ArgumentError] if model class does not support dirty tracking
-        def apply(attributes, option)
-          if option
-            FallthroughAccessors.apply(attributes, true)
-            include_dirty_module(attributes.backend_class, attributes.model_class, *attributes.names)
-          end
-        end
+      extend Plugin
+
+      default true
 
-        private
-
-        def include_dirty_module(backend_class, model_class, *attribute_names)
-          dirty_module =
-            if Loaded::ActiveRecord && model_class.ancestors.include?(::ActiveModel::Dirty)
-              if (model_class < ::ActiveRecord::Base)
-                require "mobility/plugins/active_record/dirty"
-                Plugins::ActiveRecord::Dirty
-              else
-                require "mobility/plugins/active_model/dirty"
-                Plugins::ActiveModel::Dirty
-              end
-            elsif Loaded::Sequel && model_class < ::Sequel::Model
-              require "mobility/plugins/sequel/dirty"
-              Plugins::Sequel::Dirty
-            else
-              raise ArgumentError, "#{model_class} does not support Dirty module."
-            end
-          backend_class.include dirty_module.const_get(:BackendMethods)
-          model_class.include dirty_module.const_get(:MethodsBuilder).new(*attribute_names)
+      requires :backend, include: :before
+      requires :fallthrough_accessors
+
+      initialize_hook do
+        if options[:dirty] && !options[:fallthrough_accessors]
+          warn 'The Dirty plugin depends on Fallthrough Accessors being enabled, '\
+            'but fallthrough_accessors option is falsey'
         end
       end
     end
+
+    register_plugin(:dirty, Dirty)
   end
 end

data/lib/mobility/plugins/fallbacks.rb

@@ -8,15 +8,14 @@ module Mobility
 Falls back to one or more alternative locales in case no value is defined for a
 given locale.
 
-For +fallbacks: true+, Mobility will use the value of
-{Mobility::Configuration#new_fallbacks} for the fallbacks instance. This
-defaults to an instance of +I18n::Locale::Fallbacks+, but can be
-configured (see {Mobility::Configuration}).
+For +fallbacks: true+, Mobility will use an instance of
++I18n::Locale::Fallbacks+, but this can be configured by overriding
++generate_fallbacks+ in the translations class.
 
 If a hash is passed to the +fallbacks+ option, a new fallbacks instance will be
 created for the model with the hash defining additional fallbacks. To set a
-default value for this hash, use set the value of `default_options[:fallbacks]`
-in your Mobility configuration (see below).
+default value for this hash, pass this value to the plugin in your Mobility
+configuration.
 
 In addition, fallbacks are disabled in certain situations. To explicitly disable
 fallbacks when reading and writing, you can pass the <tt>fallback: false</tt>
@@ -48,7 +47,7 @@ the current locale was +nil+.
   Mobility.locale = :ja
   post.title
   #=> "foo"
- 
+
   post.title = "bar"
   post.title
   #=> "bar"
@@ -108,58 +107,67 @@ the current locale was +nil+.
   #=> nil
   post.title_fr
   #=> nil
+=end
+    module Fallbacks
+      extend Plugin
 
-@example Setting default fallbacks across all models
-  Mobility.configure do |config|
-    # ...
-    config.default_options[:fallbacks] = { :'fr' => 'en' }
-    # ...
-  end
+      default true
+      requires :backend, include: :before
 
-  class Post
-    # Post will fallback from French to English by default
-    translates :title, fallbacks: true
-  end
-
-=end
-    class Fallbacks < Module
       # Applies fallbacks plugin to attributes. Completely disables fallbacks
       # on model if option is +false+.
-      # @param [Attributes] attributes
-      # @param [Boolean] option
-      def self.apply(attributes, option)
-        attributes.backend_class.include(new(option)) unless option == false
+      included_hook do |_, backend_class|
+        fallbacks = options[:fallbacks]
+        backend_class.include(BackendReader.new(fallbacks, method(:generate_fallbacks))) unless fallbacks == false
       end
 
-      def initialize(fallbacks_option)
-        define_read(convert_option_to_fallbacks(fallbacks_option))
+      private
+
+      def generate_fallbacks(fallbacks)
+        fallbacks_class = I18n.respond_to?(:fallbacks) ? I18nFallbacks : I18n::Locale::Fallbacks
+        fallbacks_class.new(fallbacks)
       end
 
-      private
+      class I18nFallbacks < ::I18n::Locale::Fallbacks
+        def [](locale)
+          super | I18n.fallbacks[locale]
+        end
+      end
 
-      def define_read(fallbacks)
-        define_method :read do |locale, fallback: true, **options|
-          return super(locale, options) if !fallback || options[:locale]
+      class BackendReader < Module
+        def initialize(fallbacks_option, fallbacks_generator)
+          @fallbacks_generator = fallbacks_generator
+          define_read(convert_option_to_fallbacks(fallbacks_option))
+        end
 
-          locales = fallback == true ? fallbacks[locale] : [locale, *fallback]
-          locales.each do |fallback_locale|
-            value = super(fallback_locale, options)
-            return value if Util.present?(value)
-          end
+        private
+
+        def define_read(fallbacks)
+          define_method :read do |locale, fallback: true, **options|
+            return super(locale, **options) if !fallback || options[:locale]
 
-          super(locale, options)
+            locales = fallback == true ? fallbacks[locale] : [locale, *fallback]
+            locales.each do |fallback_locale|
+              value = super(fallback_locale, **options)
+              return value if Util.present?(value)
+            end
+
+            super(locale, **options)
+          end
         end
-      end
 
-      def convert_option_to_fallbacks(option)
-        if option.is_a?(Hash)
-          Mobility.new_fallbacks(option)
-        elsif option == true
-          Mobility.new_fallbacks
-        else
-          Hash.new { [] }
+        def convert_option_to_fallbacks(option)
+          if option.is_a?(::Hash)
+            @fallbacks_generator[option]
+          elsif option == true
+            @fallbacks_generator[{}]
+          else
+            ::Hash.new { [] }
+          end
         end
       end
     end
+
+    register_plugin(:fallbacks, Fallbacks)
   end
 end

data/lib/mobility/plugins/fallthrough_accessors.rb

@@ -18,42 +18,40 @@ This is a less efficient (but more open-ended) implementation of locale
 accessors, for use in cases where the locales to be used are not known when the
 model class is generated.
 
-@example Using fallthrough locales on a plain old ruby class
-  class Post
-    def title
-      "title in #{Mobility.locale}"
-    end
-    include Mobility::FallthroughAccessors.new("title")
-  end
+=end
+    module FallthroughAccessors
+      extend Plugin
 
-  Mobility.locale = :en
-  post = Post.new
-  post.title
-  #=> "title in en"
-  post.title_fr
-  #=> "title in fr"
+      default true
 
-=end
-    class FallthroughAccessors < Module
       # Apply fallthrough accessors plugin to attributes.
-      # @param [Attributes] attributes
+      # @param [Translations] translations
       # @param [Boolean] option
-      def self.apply(attributes, option)
-        attributes.model_class.include new(*attributes.names) if option
+      initialize_hook do
+        if options[:fallthrough_accessors]
+          define_fallthrough_accessors(names)
+        end
       end
 
-      # @param [String] One or more attributes
-      def initialize(*attributes)
-        method_name_regex = /\A(#{attributes.join('|')})_([a-z]{2}(_[a-z]{2})?)(=?|\??)\z/.freeze
+      private
+
+      def define_fallthrough_accessors(*names)
+        method_name_regex = /\A(#{names.join('|')})_([a-z]{2}(_[a-z]{2})?)(=?|\??)\z/.freeze
 
-        define_method :method_missing do |method_name, *arguments, **options, &block|
+        define_method :method_missing do |method_name, *args, &block|
           if method_name =~ method_name_regex
-            attribute = $1.to_sym
+            attribute_method = "#{$1}#{$4}"
             locale, suffix = $2.split('_')
             locale = "#{locale}-#{suffix.upcase}" if suffix
-            public_send("#{attribute}#{$4}", *arguments, **options, locale: locale.to_sym)
+            if $4 == '=' # writer
+              kwargs = args[1].is_a?(Hash) ? args[1] : {}
+              public_send(attribute_method, args[0], **kwargs, locale: locale)
+            else         # reader
+              kwargs = args[0].is_a?(Hash) ? args[0] : {}
+              public_send(attribute_method, **kwargs, locale: locale)
+            end
           else
-            super(method_name, *arguments, &block)
+            super(method_name, *args, &block)
           end
         end
 
@@ -62,5 +60,7 @@ model class is generated.
         end
       end
     end
+
+    register_plugin :fallthrough_accessors, FallthroughAccessors
   end
 end