mobility 0.1.20 → 0.2.0

data/lib/mobility/{backend → backends}/active_record/key_value.rb

@@ -1,10 +1,14 @@
 # frozen-string-literal: true
+require "mobility/backends/active_record"
+require "mobility/backends/key_value"
+require "mobility/active_record/string_translation"
+require "mobility/active_record/text_translation"
 
 module Mobility
-  module Backend
+  module Backends
 =begin
 
-Implements the {Mobility::Backend::KeyValue} backend for ActiveRecord models.
+Implements the {Mobility::Backends::KeyValue} backend for ActiveRecord models.
 
 @example
   class Post < ActiveRecord::Base
@@ -24,33 +28,11 @@ Implements the {Mobility::Backend::KeyValue} backend for ActiveRecord models.
       include ActiveRecord
       include KeyValue
 
-      require 'mobility/backend/active_record/key_value/query_methods'
-
-      # @return [Symbol] Name of the association
-      attr_reader :association_name
-
-      # @!macro backend_constructor
-      # @option options [Symbol] association_name Name of association
-      def initialize(model, attribute, **options)
-        super
-        @association_name = options[:association_name]
-      end
-
-      # @!group Backend Accessors
-      # @!macro backend_reader
-      def read(locale, **_)
-        translation_for(locale).value
-      end
-
-      # @!macro backend_reader
-      def write(locale, value, **_)
-        translation_for(locale).tap { |t| t.value = value }.value
-      end
-      # @!endgroup
+      require 'mobility/backends/active_record/key_value/query_methods'
 
       # @!group Backend Configuration
       # @option options [Symbol] type (:text) Column type to use
-      # @option options [Symbol] association_name (:mobility_text_translations) Name of association method
+      # @option options [Symbol] association_name (:text_translations) Name of association method
       # @option options [String,Class] class_name ({Mobility::ActiveRecord::TextTranslation}) Translation class
       # @raise [ArgumentError] if type is not either :text or :string
       def self.configure(options)
@@ -58,7 +40,7 @@ Implements the {Mobility::Backend::KeyValue} backend for ActiveRecord models.
         type = options[:type]
         options[:class_name] ||= Mobility::ActiveRecord.const_get("#{type.capitalize}Translation".freeze)
         options[:class_name] = options[:class_name].constantize if options[:class_name].is_a?(String)
-        options[:association_name] ||= options[:class_name].table_name.to_sym
+        options[:association_name] ||= :"#{options[:type]}_translations"
         %i[type association_name].each { |key| options[key] = options[key].to_sym }
       end
       # @!endgroup
@@ -101,30 +83,14 @@ Implements the {Mobility::Backend::KeyValue} backend for ActiveRecord models.
 
       setup_query_methods(QueryMethods)
 
-      # @!group Cache Methods
-      # @return [KeyValue::TranslationsCache]
-      def new_cache
-        KeyValue::TranslationsCache.new(self)
-      end
-
-      # @return [Boolean]
-      def write_to_cache?
-        true
-      end
-      # @!endgroup
-
       # Returns translation for a given locale, or builds one if none is present.
       # @param [Symbol] locale
       # @return [Mobility::ActiveRecord::TextTranslation,Mobility::ActiveRecord::StringTranslation]
-      def translation_for(locale)
+      def translation_for(locale, _options = {})
         translation = translations.find { |t| t.key == attribute && t.locale == locale.to_s }
         translation ||= translations.build(locale: locale, key: attribute)
         translation
       end
-
-      def translations
-        model.send(association_name)
-      end
     end
   end
 end

data/lib/mobility/{backend → backends}/active_record/key_value/query_methods.rb

@@ -1,7 +1,9 @@
+require "mobility/backends/active_record/query_methods"
+
 module Mobility
-  module Backend
+  module Backends
     class ActiveRecord::KeyValue::QueryMethods < ActiveRecord::QueryMethods
-      def initialize(attributes, association_name: nil, class_name: nil, **_)
+      def initialize(attributes, association_name: nil, class_name: nil, **)
         super
         @association_name = association_name
 

data/lib/mobility/{backend/active_record/hash_valued.rb → backends/active_record/pg_hash.rb}

@@ -1,43 +1,35 @@
+require "mobility/backends/active_record"
+require "mobility/backends/hash_valued"
+
 module Mobility
-  module Backend
+  module Backends
 =begin
 
-Internal class used by ActiveRecord backends that store values as a hash.
+Internal class used by ActiveRecord backends backed by a Postgres data type
+(hstore, jsonb).
 
 =end
-    class ActiveRecord::HashValued
+    class ActiveRecord::PgHash
       include ActiveRecord
+      include HashValued
 
-      # @!group Backend Accessors
-      #
-      # @!macro backend_reader
-      def read(locale, **_)
-        translations[locale]
-      end
-
-      # @!macro backend_writer
-      def write(locale, value, **_)
-        translations[locale] = value
+      # @!macro backend_iterator
+      def each_locale
+        super { |l| yield l.to_sym }
       end
-      # @!endgroup
 
       def translations
         model.read_attribute(attribute)
       end
-      alias_method :new_cache, :translations
-
-      def write_to_cache?
-        true
-      end
 
-      setup do |attributes, options|
+      setup do |attributes|
         attributes.each { |attribute| store attribute, coder: Coder }
       end
 
       class Coder
         def self.dump(obj)
           if obj.is_a? Hash
-            obj = obj.inject({}) do |translations, (locale, value)|
+            obj.inject({}) do |translations, (locale, value)|
               translations[locale] = value if value.present?
               translations
             end

data/lib/mobility/{backend → backends}/active_record/query_methods.rb

@@ -1,5 +1,5 @@
 module Mobility
-  module Backend
+  module Backends
     module ActiveRecord
 =begin
 
@@ -9,7 +9,7 @@ models. For details see backend-specific subclasses.
 =end
       class QueryMethods < Module
         # @param [Array<String>] attributes Translated attributes
-        def initialize(attributes, **_)
+        def initialize(attributes, _)
           @attributes = attributes
           @attributes_extractor = lambda do |opts|
             opts.is_a?(Hash) && (opts.keys.map(&:to_s) & attributes).presence

data/lib/mobility/{backend → backends}/active_record/serialized.rb

@@ -1,8 +1,12 @@
+require "mobility/backends/active_record"
+require "mobility/backends/hash_valued"
+require "mobility/backends/serialized"
+
 module Mobility
-  module Backend
+  module Backends
 =begin
 
-Implements {Mobility::Backend::Serialized} backend for ActiveRecord models.
+Implements {Mobility::Backends::Serialized} backend for ActiveRecord models.
 
 @example Define attribute with serialized backend
   class Post < ActiveRecord::Base
@@ -22,29 +26,16 @@ Implements {Mobility::Backend::Serialized} backend for ActiveRecord models.
 =end
     class ActiveRecord::Serialized
       include ActiveRecord
+      include HashValued
 
-      require 'mobility/backend/active_record/serialized/query_methods'
-
-      # @!group Backend Accessors
-      #
-      # @!macro backend_reader
-      def read(locale, **_)
-        translations[locale]
-      end
-
-      # @!macro backend_reader
-      def write(locale, value, **_)
-        translations[locale] = value
-      end
-      # @!endgroup
+      require 'mobility/backends/active_record/serialized/query_methods'
 
       # @!group Backend Configuration
-      # @option options [Symbol] format (:yaml) Serialization format
-      # @raise [ArgumentError] if a format other than +:yaml+ or +:json+ is passed in
+      # @param (see Backends::Serialized.configure)
+      # @option (see Backends::Serialized.configure)
+      # @raise (see Backends::Serialized.configure)
       def self.configure(options)
-        options[:format] ||= :yaml
-        options[:format] = options[:format].downcase.to_sym
-        raise ArgumentError, "Serialized backend only supports yaml or json formats." unless [:yaml, :json].include?(options[:format])
+        Serialized.configure(options)
       end
       # @!endgroup
 
@@ -61,13 +52,6 @@ Implements {Mobility::Backend::Serialized} backend for ActiveRecord models.
       def translations
         model.read_attribute(attribute)
       end
-      alias_method :new_cache, :translations
-
-      # @return [Boolean]
-      def write_to_cache?
-        true
-      end
-      # @!endgroup
 
       %w[yaml json].each do |format|
         class_eval <<-EOM, __FILE__, __LINE__ + 1

data/lib/mobility/{backend → backends}/active_record/serialized/query_methods.rb

@@ -1,15 +1,12 @@
+require "mobility/backends/active_record/query_methods"
+
 module Mobility
-  module Backend
+  module Backends
     class ActiveRecord::Serialized::QueryMethods < ActiveRecord::QueryMethods
-      def initialize(attributes, **)
+      def initialize(attributes, _)
         super
         attributes_extractor = @attributes_extractor
-        opts_checker = @opts_checker = lambda do |opts|
-          if keys = attributes_extractor.call(opts)
-            raise ArgumentError,
-              "You cannot query on mobility attributes translated with the Serialized backend (#{keys.join(", ")})."
-          end
-        end
+        opts_checker = @opts_checker = Backends::Serialized.attr_checker(attributes_extractor)
 
         define_method :where! do |opts, *rest|
           opts_checker.call(opts) || super(opts, *rest)

data/lib/mobility/{backend → backends}/active_record/table.rb

@@ -1,10 +1,13 @@
 # frozen-string-literal: true
+require "mobility/backends/active_record"
+require "mobility/backends/table"
+require "mobility/active_record/model_translation"
 
 module Mobility
-  module Backend
+  module Backends
 =begin
 
-Implements the {Mobility::Backend::Table} backend for ActiveRecord models.
+Implements the {Mobility::Backends::Table} backend for ActiveRecord models.
 
 To generate a translation table for a model +Post+, you can use the included
 +mobility:translations+ generator:
@@ -85,33 +88,15 @@ columns to that table.
 =end
     class ActiveRecord::Table
       include ActiveRecord
+      include Table
 
-      require 'mobility/backend/active_record/table/query_methods'
+      require 'mobility/backends/active_record/table/query_methods'
 
       # @return [Symbol] name of the association method
       attr_reader :association_name
 
-      # @!macro backend_constructor
-      # @option options [Symbol] association_name Name of association
-      def initialize(model, attribute, **options)
-        super
-        @association_name = options[:association_name]
-      end
-
-      # @!group Backend Accessors
-      # @!macro backend_reader
-      def read(locale, **_)
-        translation_for(locale).send(attribute)
-      end
-
-      # @!macro backend_reader
-      def write(locale, value, **_)
-        translation_for(locale).tap { |t| t.send("#{attribute}=", value) }.send(attribute)
-      end
-      # @!endgroup
-
       # @!group Backend Configuration
-      # @option options [Symbol] association_name (:mobility_model_translations)
+      # @option options [Symbol] association_name (:translations)
       #   Name of association method
       # @option options [Symbol] table_name Name of translation table
       # @option options [Symbol] foreign_key Name of foreign key
@@ -124,10 +109,10 @@ columns to that table.
         if (association_name = options[:association_name]).present?
           options[:subclass_name] ||= association_name.to_s.singularize.camelize.freeze
         else
-          options[:association_name] = :mobility_model_translations
+          options[:association_name] = :translations
           options[:subclass_name] ||= :Translation
         end
-        %i[foreign_key association_name subclass_name].each { |key| options[key] = options[key].to_sym }
+        %i[foreign_key association_name subclass_name table_name].each { |key| options[key] = options[key].to_sym }
       end
       # @!endgroup
 
@@ -135,8 +120,6 @@ columns to that table.
         association_name = options[:association_name]
         subclass_name    = options[:subclass_name]
 
-        attr_accessor :"__#{association_name}_cache"
-
         translation_class =
           if self.const_defined?(subclass_name, false)
             const_get(subclass_name, false)
@@ -161,43 +144,11 @@ columns to that table.
 
       setup_query_methods(QueryMethods)
 
-      # @!group Cache Methods
-      # @return [Table::TranslationsCache]
-      def new_cache
-        reset_model_cache unless model_cache
-        model_cache.for(attribute)
-      end
-
-      # @return [Boolean]
-      def write_to_cache?
-        true
-      end
-
-      def clear_cache
-        model_cache.try(:clear)
-      end
-      # @!endgroup
-
-      private
-
-      def translation_for(locale)
+      def translation_for(locale, _)
         translation = translations.find { |t| t.locale == locale.to_s.freeze }
         translation ||= translations.build(locale: locale)
         translation
       end
-
-      def translations
-        model.send(association_name)
-      end
-
-      def model_cache
-        model.send(:"__#{association_name}_cache")
-      end
-
-      def reset_model_cache
-        model.send(:"__#{association_name}_cache=",
-                   Table::TranslationsCache.new { |locale| translation_for(locale) })
-      end
     end
   end
 end

data/lib/mobility/{backend → backends}/active_record/table/query_methods.rb

@@ -1,5 +1,7 @@
+require "mobility/backends/active_record/query_methods"
+
 module Mobility
-  module Backend
+  module Backends
     class ActiveRecord::Table::QueryMethods < ActiveRecord::QueryMethods
       def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
         super
@@ -39,7 +41,7 @@ module Mobility
 
       private
 
-      def define_join_method(association_name, translation_class, foreign_key: nil, table_name: nil, **_)
+      def define_join_method(association_name, translation_class, foreign_key: nil, table_name: nil, **)
         define_method :"join_#{association_name}" do |**options|
           return self if (@__mobility_table_joined || []).include?(table_name)
           (@__mobility_table_joined ||= []) << table_name
@@ -52,7 +54,7 @@ module Mobility
         end
       end
 
-      def define_query_methods(association_name, translation_class, **_)
+      def define_query_methods(association_name, translation_class, **)
         attributes_extractor = @attributes_extractor
 
         # Note that Mobility will try to use inner/outer joins appropriate to the query,

data/lib/mobility/{backend → backends}/column.rb

@@ -1,5 +1,5 @@
 module Mobility
-  module Backend
+  module Backends
 =begin
 
 Stores translated attribute as a column on the model table. To use this
@@ -20,12 +20,12 @@ or locales.)
 There are no options for this backend. Also, the +locale_accessors+ option will
 be ignored if set, since it would cause a conflict with column accessors.
 
-@see Mobility::Backend::ActiveRecord::Column
-@see Mobility::Backend::Sequel::Column
+@see Mobility::Backends::ActiveRecord::Column
+@see Mobility::Backends::Sequel::Column
 
 =end
     module Column
-      include OrmDelegator
+      extend Backend::OrmDelegator
 
       # Returns name of column where translated attribute is stored
       # @param [Symbol] locale
@@ -42,6 +42,10 @@ be ignored if set, since it would cause a conflict with column accessors.
         normalized_locale = Mobility.normalize_locale(locale)
         "#{attribute}_#{normalized_locale}".to_sym
       end
+
+      def self.included(base)
+        base.extend Backend::OrmDelegator
+      end
     end
   end
 end

data/lib/mobility/backends/hash_valued.rb

@@ -0,0 +1,29 @@
+module Mobility
+  module Backends
+=begin
+
+Defines read and write methods that access the value at a key with value
++locale+ on a +translations+ hash.
+
+=end
+    module HashValued
+      # @!group Backend Accessors
+      #
+      # @!macro backend_reader
+      def read(locale, _ = {})
+        translations[locale]
+      end
+
+      # @!macro backend_writer
+      def write(locale, value, _ = {})
+        translations[locale] = value
+      end
+      # @!endgroup
+
+      # @!macro backend_iterator
+      def each_locale
+        translations.each { |l, _| yield l }
+      end
+    end
+  end
+end