mobility 0.8.13 → 1.0.0.alpha

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>
@@ -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
-
-  class Post
-    # Post will fallback from French to English by default
-    translates :title, fallbacks: true
-  end
+      default true
+      requires :backend, include: :before
 
-=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,33 +18,28 @@ 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
+
+      requires :reader
+      requires :writer
 
-=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] && options[:reader] && options[:writer]
+          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, *args, &block|
           if method_name =~ method_name_regex
@@ -52,9 +47,9 @@ model class is generated.
             locale, suffix = $2.split('_')
             locale = "#{locale}-#{suffix.upcase}" if suffix
             if $4 == '=' # writer
-              public_send(attribute_method, args[0], **(args[1] || {}), locale: locale.to_sym)
+              public_send(attribute_method, args[0], **(args[1] || {}), locale: locale)
             else         # reader
-              public_send(attribute_method, **(args[0] || {}), locale: locale.to_sym)
+              public_send(attribute_method, **(args[0] || {}), locale: locale)
             end
           else
             super(method_name, *args, &block)
@@ -66,5 +61,7 @@ model class is generated.
         end
       end
     end
+
+    register_plugin :fallthrough_accessors, FallthroughAccessors
   end
 end

data/lib/mobility/plugins/locale_accessors.rb

@@ -13,47 +13,33 @@ If no locales are passed as an option to the initializer,
 +Mobility.available_locales+ (i.e. +I18n.available_locales+, or Rails-set
 available locales for a Rails application) will be used by default.
 
-@example
-  class Post
-    def title
-      "title in #{Mobility.locale}"
-    end
-    include Mobility::Plugins::LocaleAccessors.new("title", locales: [:en, :fr])
-  end
+=end
+    module LocaleAccessors
+      extend Plugin
 
-  Mobility.locale = :en
-  post = Post.new
-  post.title
-  #=> "title in en"
-  post.title_fr
-  #=> "title in fr"
+      default true
+
+      requires :reader
+      requires :writer
 
-=end
-    class LocaleAccessors < Module
       # Apply locale accessors plugin to attributes.
-      # @param [Attributes] attributes
+      # @param [Translations] translations
       # @param [Boolean] option
-      def self.apply(attributes, option)
-        if accessor_locales = option
-          accessor_locales = Mobility.config.default_accessor_locales if accessor_locales == true
-          attributes.model_class.include new(*attributes.names, locales: accessor_locales)
-        end
-      end
-
-      # @param [String] One or more attribute names
-      # @param [Array<Symbol>] Locales
-      def initialize(*attribute_names, locales:)
-        attribute_names.each do |name|
-          locales.each do |locale|
-            define_reader(name, locale)
-            define_writer(name, locale)
+      initialize_hook do |*names|
+        if locales = options[:locale_accessors]
+          locales = Mobility.available_locales if locales == true
+          names.each do |name|
+            locales.each do |locale|
+              define_locale_reader(name, locale) if options[:reader]
+              define_locale_writer(name, locale) if options[:writer]
+            end
           end
         end
       end
 
       private
 
-      def define_reader(name, locale)
+      def define_locale_reader(name, locale)
         warning_message = "locale passed as option to locale accessor will be ignored"
         normalized_locale = Mobility.normalize_locale(locale)
 
@@ -61,18 +47,20 @@ available locales for a Rails application) will be used by default.
         def #{name}_#{normalized_locale}(options = {})
           return super() if options.delete(:super)
           warn "#{warning_message}" if options[:locale]
-          #{name}(**options, locale: :'#{locale}')
+          #{name}(**options, locale: #{locale.inspect})
         end
+        EOM
 
+        module_eval <<-EOM, __FILE__, __LINE__ + 1
         def #{name}_#{normalized_locale}?(options = {})
           return super() if options.delete(:super)
           warn "#{warning_message}" if options[:locale]
-          #{name}?(**options, locale: :'#{locale}')
+          #{name}?(**options, locale: #{locale.inspect})
         end
         EOM
       end
 
-      def define_writer(name, locale)
+      def define_locale_writer(name, locale)
         warning_message = "locale passed as option to locale accessor will be ignored"
         normalized_locale = Mobility.normalize_locale(locale)
 
@@ -80,10 +68,12 @@ available locales for a Rails application) will be used by default.
         def #{name}_#{normalized_locale}=(value, options = {})
           return super(value) if options.delete(:super)
           warn "#{warning_message}" if options[:locale]
-          public_send(:#{name}=, value, **options, locale: :'#{locale}')
+          public_send(:#{name}=, value, **options, locale: #{locale.inspect})
         end
         EOM
       end
     end
+
+    register_plugin(:locale_accessors, LocaleAccessors)
   end
 end

data/lib/mobility/plugins/presence.rb

@@ -6,43 +6,50 @@ module Mobility
 =begin
 
 Applies presence filter to values fetched from backend and to values set on
-backend. Included by default, but can be disabled with +presence: false+ option.
+backend.
 
 @note For performance reasons, the presence plugin filters only for empty
   strings, not other values continued "blank" like empty arrays.
 
 =end
     module Presence
+      extend Plugin
+
+      default true
+      requires :backend, include: :before
+
       # Applies presence plugin to attributes.
-      # @param [Attributes] attributes
-      # @param [Boolean] option
-      def self.apply(attributes, option)
-        attributes.backend_class.include(self) if option
+      included_hook do |_, backend_class|
+        backend_class.include(BackendMethods) if options[:presence]
       end
 
-      # @!group Backend Accessors
-      # @!macro backend_reader
-      # @option options [Boolean] presence
-      #   *false* to disable presence filter.
-      def read(locale, **options)
-        options.delete(:presence) == false ? super : Presence[super]
-      end
+      module BackendMethods
+        # @!group Backend Accessors
+        # @!macro backend_reader
+        # @option options [Boolean] presence
+        #   *false* to disable presence filter.
+        def read(locale, **options)
+          options.delete(:presence) == false ? super : Presence[super]
+        end
 
-      # @!macro backend_writer
-      # @option options [Boolean] presence
-      #   *false* to disable presence filter.
-      def write(locale, value, **options)
-        if options.delete(:presence) == false
-          super
-        else
-          super(locale, Presence[value], options)
+        # @!macro backend_writer
+        # @option options [Boolean] presence
+        #   *false* to disable presence filter.
+        def write(locale, value, **options)
+          if options.delete(:presence) == false
+            super
+          else
+            super(locale, Presence[value], options)
+          end
         end
+        # @!endgroup
       end
-      # @!endgroup
 
       def self.[](value)
         (value == "") ? nil : value
       end
     end
+
+    register_plugin(:presence, Presence)
   end
 end