mobility 0.8.8 → 1.0.0.alpha

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,47 +13,60 @@ Automatically includes dirty plugin in model class when enabled.
 =end
     module Sequel
       module Dirty
-        # @!group Backend Accessors
-        # @!macro backend_writer
-        # @param [Hash] options
-        def write(locale, value, options = {})
-          locale_accessor = Mobility.normalize_locale_accessor(attribute, locale).to_sym
-          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
-            model.will_change_column(locale_accessor)
-            super
+        extend Plugin
+
+        requires :dirty, include: false
+
+        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
+            klass.plugin :dirty
+            define_dirty_methods(names)
+            backend_class.include BackendMethods
           end
         end
-        # @!endgroup
-
-        # 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
+
+        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
 
-          def included(model_class)
-            # this just adds Sequel::Plugins::Dirty to @plugins
-            model_class.plugin :dirty
+        module BackendMethods
+          # @!group Backend Accessors
+          # @!macro backend_writer
+          # @param [Hash] options
+          def write(locale, value, options = {})
+            locale_accessor = Mobility.normalize_locale_accessor(attribute, locale).to_sym
+            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
+              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

data/lib/mobility/plugins/writer.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+
+module Mobility
+  module Plugins
+    module Writer
+=begin
+
+Defines attribute writer that delegates to +Mobility::Backend#write+.
+
+=end
+      extend Plugin
+
+      default true
+      requires :backend
+
+      initialize_hook do |*names|
+        if options[:writer]
+          names.each do |name|
+            class_eval <<-EOM, __FILE__, __LINE__ + 1
+              def #{name}=(value, locale: nil, **options)
+                #{Writer.setup_source}
+                mobility_backends[:#{name}].write(locale, value, options)
+              end
+            EOM
+          end
+        end
+      end
+
+      def self.setup_source
+        <<-EOL
+        return super(value) 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(:writer, Writer)
+  end
+end

data/lib/mobility/translations.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+require "mobility/pluggable"
+
+module Mobility
+=begin
+
+Module containing translation accessor methods and other methods for accessing
+translations.
+
+Normally this class will be created by calling +translates+ on the model class,
+added when extending {Mobility}, but it can also be used independent of that
+macro.
+
+==Including Translations in a Class
+
+Since {Translations} is a subclass of +Module+, including an instance of it is
+like including a module. Options passed to the initializer are passed to
+plugins (if those plugins have been enabled).
+
+We can first enable plugins by subclassing `Mobility::Translations`, and
+calling +plugins+ to enable any plugins we want to use. We want reader and
+writer methods for accessing translations, so we enable those plugins:
+
+  class Translations < Mobility::Translations
+    plugins do
+      reader
+      writer
+    end
+  end
+
+Both `reader` and `writer` depend on the `backend` plugin, so this is also enabled.
+
+Then create an instance like this:
+
+  Translations.new("title", backend: :my_backend)
+
+This will generate an anonymous module that behaves approximately like this:
+
+  Module.new do
+    # From Mobility::Plugins::Backend module
+    #
+    def mobility_backends
+      # Returns a memoized hash with attribute name keys and backend instance
+      # values.  When a key is fetched from the hash, the hash calls
+      # +self.class.mobility_backend_class(name)+ (where +name+ is the
+      # attribute name) to get the backend class, then instantiate it (passing
+      # the model instance and attribute name to its initializer) and return it.
+    end
+
+    # From Mobility::Plugins::Reader module
+    #
+    def title(locale: Mobility.locale)
+      mobility_backends[:title].read(locale)
+    end
+
+    def title?(locale: Mobility.locale)
+      mobility_backends[:title].read(locale).present?
+    end
+
+    # From Mobility::Plugins::Writer module
+    def title=(value, locale: Mobility.locale)
+      mobility_backends[:title].write(locale, value)
+    end
+  end
+
+Including this module into a model class will thus add the backends method and
+reader and writer methods for accessing translations. Other plugins (e.g.
+fallbacks, cache) modify the result returned by the backend, by hooking into
+the +included+ callback method on the module, see {Mobility::Plugin} for
+details.
+
+==Setting up the Model Class
+
+Accessor methods alone are of limited use without a hook to actually modify the
+model class. This hook is provided by the {Backend::Setup#setup_model} method,
+which is added to every backend class when it includes the {Backend} module.
+
+Assuming the backend has defined a setup block by calling +setup+, this block
+will be called when {Translations} is {#included} in the model class, passed
+attributes and options defined when the backend was defined on the model class.
+This allows a backend to do things like (for example) define associations on a
+model class required by the backend, as happens in the {Backends::KeyValue} and
+{Backends::Table} backends.
+
+Since setup blocks are evaluated on the model class, it is possible that
+backends can conflict (for example, overwriting previously defined methods).
+Care should be taken to avoid defining methods on the model class, or where
+necessary, ensure that names are defined in such a way as to avoid conflicts
+with other backends.
+
+=end
+  class Translations < Pluggable
+    include Plugins.load_plugin(:attributes)
+  end
+end

data/lib/mobility/version.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
 module Mobility
-  VERSION = "0.8.8"
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY = 0
+    PRE = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
 end