mobility 0.1.20 → 0.2.0

data/lib/mobility.rb

@@ -2,14 +2,6 @@ require 'i18n'
 require 'request_store'
 require 'mobility/version'
 
-%w[object string].each do |type|
-  begin
-    require "active_support/core_ext/#{type}"
-  rescue LoadError
-    require "mobility/core_ext/#{type}"
-  end
-end
-
 =begin
 
 Mobility is a gem for storing and retrieving localized data through attributes
@@ -21,7 +13,7 @@ and define any attribute accessors using {Translates#mobility_accessor} (aliased
 value of {Mobility.accessor_method}, which defaults to +translates+).
 
   class MyClass
-    include Mobility
+    extend Mobility
     translates :title, backend: :key_value
   end
 
@@ -32,16 +24,15 @@ in backends to define gem-dependent behavior.
 
 =end
 module Mobility
-  autoload :Attributes,           "mobility/attributes"
-  autoload :Backend,              "mobility/backend"
-  autoload :BackendResetter,      "mobility/backend_resetter"
-  autoload :Configuration,        "mobility/configuration"
-  autoload :FallthroughAccessors, "mobility/fallthrough_accessors"
-  autoload :LocaleAccessors,      "mobility/locale_accessors"
-  autoload :Translates,           "mobility/translates"
-  autoload :Wrapper,              "mobility/wrapper"
-
-  require "mobility/orm"
+  require "mobility/attributes"
+  require "mobility/backend"
+  require "mobility/backends"
+  require "mobility/backend_resetter"
+  require "mobility/configuration"
+  require "mobility/loaded"
+  require "mobility/plugins"
+  require "mobility/translates"
+  require "mobility/wrapper"
 
   # General error for version compatibility conflicts
   class VersionNotSupportedError < ArgumentError; end
@@ -49,10 +40,11 @@ module Mobility
   begin
     require "active_record"
     raise VersionNotSupportedError, "Mobility is only compatible with ActiveRecord 4.2 and greater" if ::ActiveRecord::VERSION::STRING < "4.2"
-    autoload :ActiveModel,      "mobility/active_model"
-    autoload :ActiveRecord,     "mobility/active_record"
+    require "mobility/active_model"
+    require "mobility/active_record"
     Loaded::ActiveRecord = true
-  rescue LoadError
+  rescue LoadError => e
+    raise unless e.message =~ /active_record/
     Loaded::ActiveRecord = false
   end
 
@@ -60,7 +52,8 @@ module Mobility
     require "rails"
     Loaded::Rails = true
     require "rails/generators/mobility/generators"
-  rescue LoadError
+  rescue LoadError => e
+    raise unless e.message =~ /rails/
     Loaded::Rails = false
   end
 
@@ -68,32 +61,23 @@ module Mobility
     require "sequel"
     raise VersionNotSupportedError, "Mobility is only compatible with Sequel 4.0 and greater" if ::Sequel::MAJOR < 4
     require "sequel/plugins/mobility"
+    #TODO avoid automatically including the inflector extension
     require "sequel/extensions/inflector"
     require "sequel/plugins/dirty"
-    autoload :Sequel, "mobility/sequel"
+    require "mobility/sequel"
     Loaded::Sequel = true
-  rescue LoadError
+  rescue LoadError => e
+    raise unless e.message =~ /sequel/
     Loaded::Sequel = false
   end
 
   class << self
     def extended(model_class)
       return if model_class.respond_to? :mobility_accessor
-      mod = Module.new do
-        # Fetch backend for an attribute
-        # @param [String] attribute Attribute
-        def mobility_backend_for(attribute)
-          send(Backend.method_name(attribute))
-        end
-
-        def initialize_dup(other)
-          @mobility_backends = nil
-          super
-        end
-      end
-      model_class.include(mod)
 
+      model_class.include(InstanceMethods)
       model_class.extend(ClassMethods)
+
       if translates = Mobility.config.accessor_method
         model_class.singleton_class.send(:alias_method, translates, :mobility_accessor)
       end
@@ -109,7 +93,7 @@ module Mobility
     end
 
     # Extends model with this class so that +include Mobility+ is equivalent to
-    # +extend Mobility+
+    # +extend Mobility+ (but +extend+ is preferred).
     # @param model_class
     def included(model_class)
       model_class.extend self
@@ -167,9 +151,15 @@ module Mobility
     # (see Mobility::Configuration#default_backend)
     # @!method default_backend
 
+    # (see Mobility::Configuration#default_options)
+    # @!method default_options
+    #
+    # (see Mobility::Configuration#plugins)
+    # @!method plugins
+    #
     # (see Mobility::Configuration#default_accessor_locales)
     # @!method default_accessor_locales
-    %w[accessor_method query_method default_backend default_accessor_locales].each do |method_name|
+    %w[accessor_method query_method default_backend default_options plugins default_accessor_locales].each do |method_name|
       define_method method_name do
         config.public_send(method_name)
       end
@@ -234,6 +224,19 @@ module Mobility
     end
   end
 
+  module InstanceMethods
+    # Fetch backend for an attribute
+    # @param [String] attribute Attribute
+    def mobility_backend_for(attribute)
+      send(Backend.method_name(attribute))
+    end
+
+    def initialize_dup(other)
+      @mobility_backends = nil
+      super
+    end
+  end
+
   module ClassMethods
     include Translates
 

data/lib/mobility/active_model.rb

@@ -1,5 +1,4 @@
 module Mobility
   module ActiveModel
-    autoload :BackendResetter,  "mobility/active_model/backend_resetter"
   end
 end

data/lib/mobility/active_model/backend_resetter.rb

@@ -9,7 +9,7 @@ Backend resetter for ActiveModel models. Adds hook to reset backend when
     class BackendResetter < Mobility::BackendResetter
 
       # (see Mobility::BackendResetter#initialize)
-      def initialize(attributes)
+      def initialize(attribute_names)
         super
 
         model_reset_method = @model_reset_method

data/lib/mobility/active_record.rb

@@ -5,25 +5,18 @@ Module loading ActiveRecord-specific classes for Mobility models.
 
 =end
   module ActiveRecord
-    autoload :AttributeMethods,    "mobility/active_record/attribute_methods"
-    autoload :BackendResetter,     "mobility/active_record/backend_resetter"
-    autoload :ModelTranslation,    "mobility/active_record/model_translation"
-    autoload :StringTranslation,   "mobility/active_record/string_translation"
-    autoload :TextTranslation,     "mobility/active_record/text_translation"
-    autoload :Translation,         "mobility/active_record/translation"
-    autoload :UniquenessValidator, "mobility/active_record/uniqueness_validator"
+    require "mobility/active_record/attribute_methods"
+    require "mobility/active_record/uniqueness_validator"
 
     def self.included(model_class)
-      model_class.extend(ClassMethods)
+      query_method = Module.new do
+        define_method Mobility.query_method do
+          all
+        end
+      end
+      model_class.extend query_method
       model_class.const_set(:UniquenessValidator,
                             Class.new(::Mobility::ActiveRecord::UniquenessValidator))
     end
-
-    module ClassMethods
-      # @return [ActiveRecord::Relation] relation extended with Mobility query methods.
-      define_method ::Mobility.query_method do
-        all
-      end
-    end
   end
 end

data/lib/mobility/active_record/backend_resetter.rb

@@ -1,3 +1,5 @@
+require "mobility/active_model/backend_resetter"
+
 module Mobility
   module ActiveRecord
 =begin

data/lib/mobility/active_record/model_translation.rb

@@ -3,7 +3,7 @@ module Mobility
 =begin
 
 Subclassed dynamically to generate translation class in
-{Backend::ActiveRecord::Table} backend.
+{Backends::ActiveRecord::Table} backend.
 
 =end
     class ModelTranslation < ::ActiveRecord::Base

data/lib/mobility/active_record/string_translation.rb

@@ -1,3 +1,5 @@
+require "mobility/active_record/translation"
+
 module Mobility
   module ActiveRecord
     class StringTranslation < Translation

data/lib/mobility/active_record/text_translation.rb

@@ -1,3 +1,5 @@
+require "mobility/active_record/translation"
+
 module Mobility
   module ActiveRecord
     class TextTranslation < Translation

data/lib/mobility/attributes.rb

@@ -1,3 +1,5 @@
+require "mobility/util"
+
 module Mobility
 =begin
 
@@ -15,15 +17,16 @@ understanding and designing backends.
 Since {Attributes} is a subclass of +Module+, including an instance of it is
 like including a module. Creating an instance like this:
 
-  Attributes.new(:accessor, ["title"], backend: :my_backend, locale_accessors: [:en, :ja], cache: true, fallbacks: true)
+  Attributes.new("title", backend: :my_backend, locale_accessors: [:en, :ja], cache: true, fallbacks: true)
 
-will generate an anonymous module looking something like this:
+will generate an anonymous module that behaves like this:
 
   Module.new do
     def title_backend
-      # Create a subclass of Mobility::Backend::MyBackend and include in it:
-      # - Mobility::Cache (from the cache: true option)
-      # - Mobility::Fallbacks (from the fallbacks: true option)
+      # Create a subclass of Mobility::Backends::MyBackend and include in it:
+      # - Mobility::Plugins::Cache (from the +cache: true+ option)
+      # - Mobility::Plugins::Fallbacks (from the +fallbacks: true+ option)
+      # - Mobility::Plugins::Presence (by default, disabled by +presence: false+)
       # Then instantiate the backend, memoize it, and return it.
     end
 
@@ -67,9 +70,9 @@ will generate an anonymous module looking something like this:
     # End Locale Accessors
   end
 
-Including this module into a model class will then add the backend method, the
+Including this module into a model class will thus add the backend method, the
 reader, writer and presence methods, and the locale accessor so the model
-class.
+class. (These methods are in fact added to the model in an +included+ hook.)
 
 ==Setting up the Model Class
 
@@ -81,8 +84,8 @@ Assuming the backend has defined a setup block by calling +setup+, this block
 will be called when {Attributes} 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 {Backend::KeyValue} and
-{Backend::Table} backends.
+model class required by the backend, as happens in the {Backends::KeyValue} and
+{Backends::Table} backends.
 
 The +setup+ block is also used to extend the query scope/dataset (+i18n+ by
 default) with backend-specific query method support.
@@ -95,9 +98,14 @@ with other backends.
 
 =end
   class Attributes < Module
-    # Attributes for which accessors will be defined
-    # @return [Array<String>] Array of attributes
-    attr_reader :attributes
+
+    # Method (accessor, reader or writer)
+    # @return [Symbol] method
+    attr_reader :method
+
+    # Attribute names for which accessors will be defined
+    # @return [Array<String>] Array of names
+    attr_reader :names
 
     # Backend options
     # @return [Hash] Backend options
@@ -111,106 +119,101 @@ with other backends.
     # @return [Symbol,Class] Name of backend, or backend class
     attr_reader :backend_name
 
+    # Model class
+    # @return [Class] Class of model
+    attr_reader :model_class
+
     # @param [Symbol] method One of: [reader, writer, accessor]
-    # @param [Array<String>] attributes_ Attributes to define backend for
-    # @param [Hash] options_ Backend options hash
-    # @option options_ [Class] model_class Class of model
-    # @option options_ [Boolean] cache (true) Enable cache for this model backend
-    # @option options_ [Boolean] dirty Enable dirty tracking for this model
-    #   backend
-    # @option options_ [Boolean, Hash] fallbacks Enable fallbacks or specify
-    #   fallbacks for this model backend
-    # @option options_ [Boolean] fallthrough_accessors Enable fallthrough
-    #   locale accessors for this model backend
-    # @option options_ [Boolean, Array<Symbol>] locale_accessors Enable locale
-    #   accessors or specify locales for which accessors should be defined on
-    #   this model backend. Will default to +true+ if +dirty+ option is +true+.
-    # @option options_ [Boolean] presence (true) Enable presence filter on
-    #   reads and writes
+    # @param [Array<String>] attribute_names Names of attributes to define backend for
+    # @param [Hash] backend_options Backend options hash
+    # @option backend_options [Class] model_class Class of model
     # @raise [ArgumentError] if method is not reader, writer or accessor
-    def initialize(method, *attributes_, **options_)
+    def initialize(*attribute_names, method: :accessor, backend: Mobility.default_backend, **backend_options)
       raise ArgumentError, "method must be one of: reader, writer, accessor" unless %i[reader writer accessor].include?(method)
-      @options = options_
-      @attributes = attributes_.map(&:to_s)
-      model_class = options[:model_class]
-      @backend_name = options.delete(:backend) || Mobility.config.default_backend
-      @backend_class = Class.new(get_backend_class(backend:     @backend_name,
-                                                   model_class: model_class))
-      if (options[:dirty] && options[:fallthrough_accessors] != false)
-        options[:fallthrough_accessors] = true
-      end
-      include FallthroughAccessors.new(*attributes) if options[:fallthrough_accessors]
+      @method = method
+      @options = Mobility.default_options.merge(backend_options)
+      @names = attribute_names.map(&:to_s)
+      raise Mobility::BackendRequired, "Backend option required if Mobility.config.default_backend is not set." if backend.nil?
+      @backend_name = backend
+    end
 
-      @backend_class.configure(options) if @backend_class.respond_to?(:configure)
+    # Setup backend class, include modules into model class, add this
+    # attributes module to shared {Mobility::Wrapper} and setup model with
+    # backend setup block (see {Mobility::Backend::Setup#setup_model}).
+    # @param klass [Class] Class of model
+    def included(klass)
+      @model_class = @options[:model_class] = klass
+      @backend_class = Class.new(get_backend_class(backend_name).for(model_class))
 
-      include_backend_modules(@backend_class, options)
+      @backend_class.configure(options) if @backend_class.respond_to?(:configure)
 
-      @accessor_locales = options[:locale_accessors]
-      @accessor_locales = Mobility.config.default_accessor_locales if @accessor_locales == true
-      include LocaleAccessors.new(*attributes, locales: @accessor_locales) if @accessor_locales
+      Mobility.plugins.each do |name|
+        plugin = get_plugin_class(name)
+        plugin.apply(self, options[name])
+      end
 
-      attributes.each do |attribute|
-        define_backend(attribute)
-        define_reader(attribute) if %i[accessor reader].include?(method)
-        define_writer(attribute) if %i[accessor writer].include?(method)
+      names.each do |name|
+        define_backend(name)
+        define_reader(name) if %i[accessor reader].include?(method)
+        define_writer(name) if %i[accessor writer].include?(method)
       end
-    end
 
-    # Add this attributes module to shared {Mobility::Wrapper} and setup model
-    # with backend setup block (see {Mobility::Backend::Setup#setup_model}).
-    # @param model_class [Class] Class of model
-    def included(model_class)
       model_class.mobility << self
-      backend_class.setup_model(model_class, attributes, options)
+      backend_class.setup_model(model_class, names, options)
     end
 
-    # Yield each attribute to block
-    # @yield [String] Attribute
+    # Yield each attribute name to block
+    # @yieldparam [String] Attribute
     def each &block
-      attributes.each(&block)
+      names.each(&block)
     end
 
     private
 
-    # Include backend modules depending on value of options.
-    def include_backend_modules(backend_class, options)
-      backend_class.include(Backend::Cache)                            unless options[:cache] == false
-      backend_class.include(Backend::Dirty.for(options[:model_class])) if options[:dirty]
-      backend_class.include(Backend::Fallbacks)                        unless options[:fallbacks] == false
-      backend_class.include(Backend::Presence)                         unless options[:presence] == false
-    end
-
     def define_backend(attribute)
-      _backend_class, _options = backend_class, options
+      backend_class_, options_ = backend_class, options
       define_method Backend.method_name(attribute) do
         @mobility_backends ||= {}
-        @mobility_backends[attribute] ||= _backend_class.new(self, attribute, _options)
+        @mobility_backends[attribute] ||= backend_class_.new(self, attribute, options_)
       end
     end
 
     def define_reader(attribute)
       define_method attribute do |locale: Mobility.locale, **options|
+        return super() if options.delete(:super)
         Mobility.enforce_available_locales!(locale)
         mobility_backend_for(attribute).read(locale.to_sym, options)
       end
 
       define_method "#{attribute}?" do |locale: Mobility.locale, **options|
+        return super() if options.delete(:super)
         Mobility.enforce_available_locales!(locale)
-        mobility_backend_for(attribute).read(locale.to_sym, options).present?
+        mobility_backend_for(attribute).present?(locale.to_sym, options)
       end
     end
 
     def define_writer(attribute)
       define_method "#{attribute}=" do |value, locale: Mobility.locale, **options|
+        return super(value) if options.delete(:super)
         Mobility.enforce_available_locales!(locale)
         mobility_backend_for(attribute).write(locale.to_sym, value, options)
       end
     end
 
-    def get_backend_class(backend: nil, model_class: nil)
-      raise Mobility::BackendRequired, "Backend option required if Mobility.config.default_backend is not set." if backend.nil?
-      klass = Module === backend ? backend : Mobility::Backend.const_get(backend.to_s.camelize.gsub(/\s+/, ''.freeze).freeze)
-      model_class.nil? ? klass : klass.for(model_class)
+    def get_backend_class(backend)
+      return backend if Module === backend
+      require "mobility/backends/#{backend}"
+      get_class_from_key(Mobility::Backends, backend)
+    end
+
+    def get_plugin_class(plugin)
+      require "mobility/plugins/#{plugin}"
+      get_class_from_key(Mobility::Plugins, plugin)
+    end
+
+    def get_class_from_key(parent_class, key)
+      klass_name = key.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+      parent_class.const_get(klass_name)
     end
   end
 end