mobility 0.8.8 → 1.0.0.alpha

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
-          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,42 +18,41 @@ 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
 
-        define_method :method_missing do |method_name, *arguments, **options, &block|
+      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
-            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
+              public_send(attribute_method, args[0], **(args[1] || {}), locale: locale)
+            else         # reader
+              public_send(attribute_method, **(args[0] || {}), locale: locale)
+            end
           else
-            super(method_name, *arguments, &block)
+            super(method_name, *args, &block)
           end
         end
 
@@ -62,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

data/lib/mobility/plugins/query.rb

@@ -3,29 +3,20 @@ module Mobility
   module Plugins
 =begin
 
-@see {Mobility::Plugins::ActiveRecord::Query}
+@see {Mobility::Plugins::ActiveRecord::Query} or {Mobility::Plugins::Sequel::Query}.
 
 =end
     module Query
-      class << self
-        def apply(attributes, option)
-          if option
-            include_query_module(attributes)
-          end
-        end
+      extend Plugin
 
-        private
+      default :i18n
+      requires :backend, include: :before
 
-        def include_query_module(attributes)
-          if Loaded::ActiveRecord && attributes.model_class < ::ActiveRecord::Base
-            require "mobility/plugins/active_record/query"
-            ActiveRecord::Query.apply(attributes)
-          elsif Loaded::Sequel && attributes.model_class < ::Sequel::Model
-            require "mobility/plugins/sequel/query"
-            Sequel::Query.apply(attributes)
-          end
-        end
+      def query_method
+        (options[:query] == true) ? self.class.defaults[:query] : options[:query]
       end
     end
+
+    register_plugin(:query, Query)
   end
 end