mobility 0.8.10 → 1.0.0.beta2

data/lib/mobility/plugins/locale_accessors.rb

@@ -13,47 +13,30 @@ 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
 
-=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)
+              define_locale_writer(name, locale)
+            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 +44,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 +65,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

data/lib/mobility/plugins/reader.rb

@@ -0,0 +1,50 @@
+# frozen-string-literal: true
+
+module Mobility
+  module Plugins
+    module Reader
+=begin
+
+Defines attribute reader that delegates to +Mobility::Backend#read+.
+
+=end
+      extend Plugin
+
+      default true
+      requires :backend
+
+      initialize_hook do |*names, **|
+        if options[:reader]
+          names.each do |name|
+            class_eval <<-EOM, __FILE__, __LINE__ + 1
+              def #{name}(locale: nil, **options)
+                #{Reader.setup_source}
+                mobility_backends[:#{name}].read(locale, **options)
+              end
+            EOM
+            class_eval <<-EOM, __FILE__, __LINE__ + 1
+              def #{name}?(locale: nil, **options)
+                #{Reader.setup_source}
+                mobility_backends[:#{name}].present?(locale, **options)
+              end
+            EOM
+          end
+        end
+      end
+
+      def self.setup_source
+        <<-EOL
+        return super() if options[:super]
+        if (locale &&= locale.to_sym)
+          #{"Mobility.enforce_available_locales!(locale)" if I18n.enforce_available_locales}
+          options[:locale] = true
+        else
+          locale = Mobility.locale
+        end
+        EOL
+      end
+    end
+
+    register_plugin(:reader, Reader)
+  end
+end

data/lib/mobility/plugins/sequel.rb

@@ -1,6 +1,40 @@
+require "sequel"
+raise VersionNotSupportedError, "Mobility is only compatible with Sequel 4.0 and greater" if ::Sequel::MAJOR < 4
+require "sequel/plugins/mobility"
+unless defined?(ActiveSupport::Inflector)
+  # TODO: avoid automatically including the inflector extension
+  require "sequel/extensions/inflector"
+end
+require "sequel/plugins/dirty"
+require_relative "./sequel/backend"
+require_relative "./sequel/dirty"
+require_relative "./sequel/cache"
+require_relative "./sequel/query"
+
 module Mobility
   module Plugins
     module Sequel
+      extend Plugin
+
+      requires :sequel_backend, include: :after
+      requires :sequel_dirty
+      requires :sequel_cache
+      requires :sequel_query
+
+      included_hook do |klass|
+        unless sequel_class?(klass)
+          name = klass.name || klass.to_s
+          raise TypeError, "#{name} should be a subclass of Sequel::Model to use the sequel plugin"
+        end
+      end
+
+      private
+
+      def sequel_class?(klass)
+        klass < ::Sequel::Model
+      end
     end
+
+    register_plugin(:sequel, Sequel)
   end
 end

data/lib/mobility/plugins/sequel/backend.rb

@@ -0,0 +1,25 @@
+module Mobility
+  module Plugins
+    module Sequel
+      module Backend
+        extend Plugin
+
+        requires :backend, include: :before
+
+        def load_backend(backend)
+          if Symbol === backend
+            require "mobility/backends/sequel/#{backend}"
+            Backends.load_backend("sequel_#{backend}".to_sym)
+          else
+            super
+          end
+        rescue LoadError => e
+          raise unless e.message =~ /sequel\/#{backend}/
+          super
+        end
+      end
+    end
+
+    register_plugin(:sequel_backend, Sequel::Backend)
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+
+module Mobility
+  module Plugins
+    module Sequel
+=begin
+
+Adds hook to clear Mobility cache when +refresh+ is called on Sequel model.
+
+=end
+      module Cache
+        extend Plugin
+
+        requires :cache, include: false
+
+        included_hook do |klass|
+          define_cache_hooks(klass, :refresh) if options[:cache]
+        end
+      end
+    end
+
+    register_plugin(:sequel_cache, Sequel::Cache)
+  end
+end

data/lib/mobility/plugins/sequel/dirty.rb

@@ -13,29 +13,37 @@ Automatically includes dirty plugin in model class when enabled.
 =end
     module Sequel
       module Dirty
-        # Builds module which overrides dirty methods to handle translated as
-        # well as normal (untranslated) attributes.
-        class MethodsBuilder < Module
-          def initialize(*attribute_names)
-            # Although we load the plugin in the included callback method, we
-            # need to include this module here in advance to ensure that its
-            # instance methods are included *before* the ones defined here.
-            include ::Sequel::Plugins::Dirty::InstanceMethods
-
-            %w[initial_value column_change column_changed? reset_column].each do |method_name|
-              define_method method_name do |column|
-                if attribute_names.map(&:to_sym).include?(column)
-                  super(Mobility.normalize_locale_accessor(column).to_sym)
-                else
-                  super(column)
-                end
-              end
-            end
-          end
+        extend Plugin
+
+        requires :dirty, include: false
 
-          def included(model_class)
+        initialize_hook do
+          # Although we load the plugin in the included callback method, we
+          # need to include this module here in advance to ensure that its
+          # instance methods are included *before* the ones defined here.
+          include ::Sequel::Plugins::Dirty::InstanceMethods
+        end
+
+        included_hook do |klass, backend_class|
+          if options[:dirty]
             # this just adds Sequel::Plugins::Dirty to @plugins
-            model_class.plugin :dirty
+            klass.plugin :dirty
+            define_dirty_methods(names)
+            backend_class.include BackendMethods
+          end
+        end
+
+        private
+
+        def define_dirty_methods(names)
+          %w[initial_value column_change column_changed? reset_column].each do |method_name|
+            define_method method_name do |column|
+              if names.map(&:to_sym).include?(column)
+                super(Mobility.normalize_locale_accessor(column).to_sym)
+              else
+                super(column)
+              end
+            end
           end
         end
 
@@ -48,14 +56,17 @@ Automatically includes dirty plugin in model class when enabled.
             if model.column_changes.has_key?(locale_accessor) && model.initial_values[locale_accessor] == value
               super
               [model.changed_columns, model.initial_values].each { |h| h.delete(locale_accessor) }
-            elsif read(locale, options.merge(fallback: false)) != value
+            elsif read(locale, **options.merge(fallback: false)) != value
               model.will_change_column(locale_accessor)
               super
             end
           end
           # @!endgroup
         end
+
       end
     end
+
+    register_plugin(:sequel_dirty, Sequel::Dirty)
   end
 end

data/lib/mobility/plugins/sequel/query.rb

@@ -8,11 +8,18 @@ See ActiveRecord::Query plugin.
 =end
     module Sequel
       module Query
-        class << self
-          def apply(attributes)
-            attributes.model_class.class_eval do
+        extend Plugin
+
+        requires :query, include: false
+
+        included_hook do |klass, _|
+          plugin = self
+          if options[:query]
+            raise MissingBackend, "backend required for Query plugin" unless backend_class
+
+            klass.class_eval do
               extend QueryMethod
-              singleton_class.send :alias_method, Mobility.query_method, :__mobility_query_dataset__
+              singleton_class.send :alias_method, plugin.query_method, :__mobility_query_dataset__
             end
           end
         end
@@ -95,7 +102,7 @@ See ActiveRecord::Query plugin.
 
           class << self
             def build(dataset, query_method, query_conds, &block)
-              return yield unless Hash === query_conds.first
+              return yield unless ::Hash === query_conds.first
 
               cond = query_conds.first.dup
               locale = cond.delete(:locale) || Mobility.locale
@@ -109,7 +116,7 @@ See ActiveRecord::Query plugin.
               keys, predicates = cond.keys, []
               model = dataset.model
 
-              query_map = model.mobility_modules.inject(IDENTITY) do |qm, mod|
+              query_map = attribute_modules(model).inject(IDENTITY) do |qm, mod|
                 i18n_keys = mod.names.map(&:to_sym) & keys
                 next qm if i18n_keys.empty?
 
@@ -127,6 +134,10 @@ See ActiveRecord::Query plugin.
               query_map[dataset.public_send(query_method, ::Sequel.&(*predicates))]
             end
 
+            def attribute_modules(model)
+              model.ancestors.grep(::Mobility::Translations)
+            end
+
             def build_predicate(op, values)
               vals = values.is_a?(Array) ? values.uniq: [values]
               vals = vals.first if vals.size == 1
@@ -135,6 +146,10 @@ See ActiveRecord::Query plugin.
           end
         end
       end
+
+      class MissingBackend < Mobility::Error; end
     end
+
+    register_plugin(:sequel_query, Sequel::Query)
   end
 end