mobility 0.1.20 → 0.2.0

data/lib/mobility/backend/active_model.rb

@@ -1,7 +0,0 @@
-module Mobility
-  module Backend
-    module ActiveModel
-      autoload :Dirty, 'mobility/backend/active_model/dirty'
-    end
-  end
-end

data/lib/mobility/backend/active_model/dirty.rb

@@ -1,95 +0,0 @@
-module Mobility
-  module Backend
-=begin
-
-Dirty tracking for models which include the +ActiveModel::Dirty+ module.
-
-Assuming we have an attribute +title+, this module will add support for the
-following methods:
-- +title_changed?+
-- +title_change+
-- +title_was+
-- +title_will_change!+
-- +title_previously_changed?+
-- +title_previous_change+
-- +restore_title!+
-
-In addition, the private method +restore_attribute!+ will also restore the
-value of the translated attribute if passed to it.
-
-@see http://api.rubyonrails.org/classes/ActiveModel/Dirty.html Rails documentation for Active Model Dirty module
-
-=end
-    module ActiveModel::Dirty
-      # @!group Backend Accessors
-      # @!macro backend_writer
-      # @param [Hash] options
-      def write(locale, value, **options)
-        locale_accessor = Mobility.normalize_locale_accessor(attribute, locale)
-        if model.changed_attributes.has_key?(locale_accessor) && model.changed_attributes[locale_accessor] == value
-          model.attributes_changed_by_setter.except!(locale_accessor)
-        elsif read(locale, options.merge(fallback: false)) != value
-          model.send(:attribute_will_change!, locale_accessor)
-        end
-        super
-      end
-      # @!endgroup
-
-      # @param [Class] backend_class Class of backend
-      def self.included(backend_class)
-        backend_class.extend(ClassMethods)
-      end
-
-      # Adds hook after {Backend::Setup#setup_model} to add dirty-tracking
-      # methods for translated attributes onto model class.
-      module ClassMethods
-        # (see Mobility::Backend::Setup#setup_model)
-        def setup_model(model_class, attributes, **options)
-          super
-          model_class.class_eval do
-            Mobility::Backend::ActiveModel::Dirty.method_suffixes.each do |suffix|
-              attributes.each do |attribute|
-                class_eval <<-EOM, __FILE__, __LINE__ + 1
-                  def #{attribute}#{suffix}
-                    attribute#{suffix}(Mobility.normalize_locale_accessor("#{attribute}"))
-                  end
-                EOM
-              end
-            end
-          end
-
-          restore_methods = Module.new do
-            attributes.each do |attribute|
-              define_method "restore_#{attribute}!" do
-                locale_accessor = Mobility.normalize_locale_accessor(attribute)
-                if attribute_changed?(locale_accessor)
-                  __send__("#{attribute}=", changed_attributes[locale_accessor])
-                end
-              end
-            end
-
-            define_method :restore_attribute! do |attr|
-              if attributes.include?(attr.to_s)
-                send("restore_#{attr}!")
-              else
-                super(attr)
-              end
-            end
-            private :restore_attribute!
-          end
-          model_class.include restore_methods
-        end
-      end
-
-      # Get method suffixes. Creating an object just to get the list of
-      # suffixes is not very efficient, but the most reliable way given that
-      # they change from Rails version to version.
-      def self.method_suffixes
-        @method_suffixes ||=
-          Class.new do
-            include ::ActiveModel::Dirty
-          end.attribute_method_matchers.map(&:suffix).select { |m| m =~ /\A_/ }
-      end
-    end
-  end
-end

data/lib/mobility/backend/active_record.rb

@@ -1,29 +0,0 @@
-module Mobility
-  module Backend
-    module ActiveRecord
-      autoload :Column,       'mobility/backend/active_record/column'
-      autoload :Dirty,        'mobility/backend/active_record/dirty'
-      autoload :Hstore,       'mobility/backend/active_record/hstore'
-      autoload :Jsonb,        'mobility/backend/active_record/jsonb'
-      autoload :KeyValue,     'mobility/backend/active_record/key_value'
-      autoload :Serialized,   'mobility/backend/active_record/serialized'
-      autoload :QueryMethods, 'mobility/backend/active_record/query_methods'
-      autoload :Table,        'mobility/backend/active_record/table'
-
-      def setup_query_methods(query_methods)
-        setup do |attributes, options|
-          extend(Module.new do
-            define_method ::Mobility.query_method do
-              super().extending(query_methods.new(attributes, options))
-            end
-          end)
-        end
-      end
-
-      def self.included(backend_class)
-        backend_class.include(Backend)
-        backend_class.extend(self)
-      end
-    end
-  end
-end

data/lib/mobility/backend/active_record/dirty.rb

@@ -1,54 +0,0 @@
-module Mobility
-  module Backend
-=begin
-
-Dirty tracking for AR models. See {Mobility::Backend::ActiveModel::Dirty} for
-details on usage.
-
-=end
-    module ActiveRecord::Dirty
-      include ActiveModel::Dirty
-
-      # @param [Class] backend_class Class of backend
-      def self.included(backend_class)
-        backend_class.extend(ActiveModel::Dirty::ClassMethods)
-        backend_class.extend(ClassMethods)
-      end
-
-      # Adds hook after {Backend::Setup#setup_model} to patch AR so that it
-      # handles changes to translated attributes just like normal attributes.
-      module ClassMethods
-        # (see Mobility::Backend::Setup#setup_model)
-        def setup_model(model_class, attributes, **options)
-          super
-
-          method_name_regex = /\A(#{attributes.join('|'.freeze)})_([a-z]{2}(_[a-z]{2})?)(=?|\??)\z/.freeze
-          has_attribute = Module.new do
-            define_method :has_attribute? do |attr_name|
-              super(attr_name) || !!method_name_regex.match(attr_name)
-            end
-          end
-          model_class.extend has_attribute
-
-          changes_applied_method = ::ActiveRecord::VERSION::STRING < '5.1' ? :changes_applied : :changes_internally_applied
-          mod = Module.new do
-            define_method changes_applied_method do
-              @previously_changed = changes
-              super()
-            end
-
-            def clear_changes_information
-              @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-              super
-            end
-
-            def previous_changes
-              (@previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new).merge(super)
-            end
-          end
-          model_class.include mod
-        end
-      end
-    end
-  end
-end

data/lib/mobility/backend/active_record/hstore.rb

@@ -1,29 +0,0 @@
-require 'mobility/backend/active_record/hash_valued'
-
-module Mobility
-  module Backend
-=begin
-
-Implements the {Mobility::Backend::Hstore} backend for ActiveRecord models.
-
-@see Mobility::Backend::ActiveRecord::HashValued
-
-=end
-    class ActiveRecord::Hstore < ActiveRecord::HashValued
-      require 'mobility/backend/active_record/hstore/query_methods'
-
-      # @!group Backend Accessors
-      # @!macro backend_reader
-      # @!method read(locale, **options)
-
-      # @!group Backend Accessors
-      # @!macro backend_writer
-      def write(locale, value, **_)
-        translations[locale] = value && value.to_s
-      end
-      # @!endgroup
-
-      setup_query_methods(QueryMethods)
-    end
-  end
-end

data/lib/mobility/backend/cache.rb

@@ -1,117 +0,0 @@
-module Mobility
-  module Backend
-=begin
-
-Caches values fetched from the backend so subsequent fetches can be performed
-more quickly.
-
-By default, the cache stores cached values in a simple hash, returned from the
-{new_cache} method added to the including backend instance class. To use a
-different cache class, simply define a +new_cache+ method in the backend and
-return a new instance of the cache class (many backends do this, see
-{Mobility::Backend::KeyValue} for one example.)
-
-The cache is reset by the {clear_cache} method, which by default simply assigns
-the result of {new_cache} to the +@cache+ instance variable. This behaviour can
-also be customized by defining a +new_cache+ method on the backend class (see
-{Mobility::Backend::ActiveRecord::Table#new_cache} for an example of a backend that does this).
-
-The cache is reset when one of a set of events happens (saving, reloading,
-etc.). See {BackendResetter} for details.
-
-Values are added to the cache in two ways:
-
-1. first read from backend
-2. any write to backend
-
-The latter can be customized by defining the {write_to_cache?} method, which by
-default returns +false+. If set to +true+, then writes will only update the
-cache and not hit the backend. This is a sensible setting in case the cache is
-actually an object which directly stores the translation (see one of the
-ORM-specific implementations of {Mobility::Backend::KeyValue} for examples of
-this).
-
-=end
-    module Cache
-      # @group Backend Accessors
-      # @!macro backend_reader
-      # @param [Hash] options
-      # @param [Boolean] cache
-      #   *false* to disable cache.
-      def read(locale, **options)
-        return super if options.delete(:cache) == false
-        if write_to_cache? || cache.has_key?(locale)
-          cache[locale]
-        else
-          cache[locale] = super
-        end
-      end
-
-      # @!macro backend_writer
-      # @param [Hash] options
-      # @param [Boolean] cache
-      #   *false* to disable cache.
-      def write(locale, value, **options)
-        return super if options.delete(:cache) == false
-        cache[locale] = write_to_cache? ? value : super
-      end
-      # @!endgroup
-
-      # Adds hook to {Backend::Setup#setup_model} to include instance of
-      # model-specific {BackendResetter} subclass when setting up
-      # model class, to trigger cache resetting at specific events (saving,
-      # reloading, etc.)
-      module Setup
-        # @param model_class Model class
-        # @param [Array<String>] attributes Backend attributes
-        def setup_model(model_class, attributes, **_)
-          super
-          model_class.include BackendResetter.for(model_class).new(attributes) { clear_cache }
-        end
-      end
-
-      # @!group Cache Methods
-      # @!parse
-      #   def new_cache
-      #     {}
-      #   end
-      #
-      # @!parse
-      #   def write_to_cache?
-      #     false
-      #   end
-      #
-      # @!parse
-      #   def clear_cache
-      #     @cache = new_cache
-      #   end
-      # @!endgroup
-
-      # Includes cache methods to backend (unless they are already defined) and
-      # extends backend class with {Mobility::Cache::Setup} for backend resetting.
-      def self.included(backend_class)
-        backend_class.class_eval do
-          extend Setup
-
-          def new_cache
-            {}
-          end unless method_defined?(:new_cache)
-
-          def write_to_cache?
-            false
-          end unless method_defined?(:write_to_cache?)
-
-          def clear_cache
-            @cache = new_cache
-          end unless method_defined?(:clear_cache)
-        end
-      end
-
-      private
-
-      def cache
-        @cache ||= new_cache
-      end
-    end
-  end
-end

data/lib/mobility/backend/dirty.rb

@@ -1,38 +0,0 @@
-module Mobility
-  module Backend
-=begin
-
-Dirty tracking for Mobility attributes. See class-specific implementations for
-details.
-
-@see Mobility::Backend::ActiveModel::Dirty
-@see Mobility::Backend::Sequel::Dirty
-
-@note Dirty tracking can have unexpected results when combined with fallbacks.
-  A change in the fallback locale value will not mark an attribute falling
-  through to that locale as changed, even though it may look like it has
-  changed. However, when the value for the current locale is changed from nil
-  or blank to a new value, the change will be recorded as a change from that
-  fallback value, rather than from the nil or blank value. The specs are the
-  most reliable source of information on the interaction between dirty tracking
-  and fallbacks.
-
-=end
-    module Dirty
-      # @param model_class Class of model this backend is defined on.
-      # @return [Backend]
-      # @raise [ArgumentError] if model class does not support dirty tracking
-      def self.for(model_class)
-        model_class ||= Object
-        if Loaded::ActiveRecord && model_class.ancestors.include?(::ActiveModel::Dirty)
-          (model_class < ::ActiveRecord::Base) ?
-            Backend::ActiveRecord::Dirty : Backend::ActiveModel::Dirty
-        elsif Loaded::Sequel && model_class < ::Sequel::Model
-          Backend::Sequel::Dirty
-        else
-          raise ArgumentError, "#{model_class.to_s} does not support Dirty module."
-        end
-      end
-    end
-  end
-end

data/lib/mobility/backend/key_value.rb

@@ -1,85 +0,0 @@
-module Mobility
-  module Backend
-=begin
-
-Stores attribute translation as attribute/value pair on a shared translations
-table, using a polymorphic relationship between a translation class and models
-using the backend. By default, two tables are assumed to be present supporting
-string and text translations: a +mobility_text_translations+ table for text-valued translations and a
-+mobility_string_translations+ table for string-valued translations (the only
-difference being the column type of the +value+ column on the table).
-
-==Backend Options
-
-===+association_name+
-
-Name of association on model. Defaults to +mobility_text_translations+ (if
-+type+ is +:text+) or +mobility_string_translations+ (if +type+ is +:string+).
-If specified, ensure name does not overlap with other methods on model or with
-the association name used by other backends on model (otherwise one will
-overwrite the other).
-
-===+type+
-
-Currently, either +:text+ or +:string+ is supported. Determines which class to
-use for translations, which in turn determines which table to use to store
-translations (by default +mobility_text_translations+ for text type,
-+mobility_string_translations+ for string type).
-
-===+class_name+
-
-Class to use for translations when defining association. By default,
-{Mobility::ActiveRecord::TextTranslation} or
-{Mobility::ActiveRecord::StringTranslation} for ActiveRecord models (similar
-for Sequel models). If string is passed in, it will be constantized to get the
-class.
-
-@see Mobility::Backend::ActiveRecord::KeyValue
-@see Mobility::Backend::Sequel::KeyValue
-
-=end
-    module KeyValue
-      include OrmDelegator
-
-      def self.included(backend)
-        backend.extend ClassMethods
-      end
-
-      module ClassMethods
-        # @!group Backend Configuration
-        # @option options [Symbol,String] type (:text) Column type to use
-        # @raise [ArgumentError] if type is not either :text or :string
-        def configure(options)
-          options[:type] = (options[:type] || :text).to_sym
-          raise ArgumentError, "type must be one of: [text, string]" unless [:text, :string].include?(options[:type])
-        end
-      end
-
-      # Simple cache to memoize translations as a hash so they can be fetched
-      # quickly.
-      class TranslationsCache
-        # @param backend Instance of KeyValue backend to cache
-        # @return [TranslationsCache]
-        def initialize(backend)
-          @cache = Hash.new { |hash, locale| hash[locale] = backend.translation_for(locale) }
-        end
-
-        # @param locale [Symbol] Locale to fetch
-        def [](locale)
-          @cache[locale].value
-        end
-
-        # @param locale [Symbol] Locale to set
-        # @param value [String] Value to set
-        def []=(locale, value)
-          @cache[locale].value = value
-        end
-
-        # @yield [locale, translation]
-        def each_translation &block
-          @cache.each_value &block
-        end
-      end
-    end
-  end
-end