mobility 0.1.20 → 0.2.0

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

@@ -1,7 +1,9 @@
+require "mobility/backends/sequel/query_methods"
+
 module Mobility
-  module Backend
+  module Backends
     class Sequel::KeyValue::QueryMethods < Sequel::QueryMethods
-      def initialize(attributes, association_name: nil, class_name: nil, **_)
+      def initialize(attributes, association_name: nil, class_name: nil, **)
         super
 
         define_join_method(association_name, class_name)
@@ -34,9 +36,6 @@ module Mobility
       end
 
       def define_query_methods(association_name)
-        # TODO: find a better way to do this that doesn't involve overriding
-        # a private method...
-        #
         attributes_extractor = @attributes_extractor
 
         %w[exclude or where].each do |method_name|

data/lib/mobility/backends/sequel/pg_hash.rb

@@ -0,0 +1,46 @@
+require "mobility/util"
+require "mobility/backends/sequel"
+require "mobility/backends/hash_valued"
+require "mobility/backend/stringify_locale"
+
+module Mobility
+  module Backends
+=begin
+
+Internal class used by Sequel backends backed by a Postgres data type (hstore,
+jsonb).
+
+=end
+    class Sequel::PgHash
+      include Sequel
+      include HashValued
+      include StringifyLocale
+
+      # @!macro backend_iterator
+      def each_locale
+        super { |l| yield l.to_sym }
+      end
+
+      def translations
+        model[attribute.to_sym]
+      end
+
+      setup do |attributes|
+        method_overrides = Module.new do
+          define_method :initialize_set do |values|
+            attributes.each { |attribute| self[attribute.to_sym] = {} }
+            super(values)
+          end
+          define_method :before_validation do
+            attributes.each do |attribute|
+              self[attribute.to_sym].delete_if { |_, v| Util.blank?(v) }
+            end
+            super()
+          end
+        end
+        include method_overrides
+        include Mobility::Sequel::ColumnChanges.new(attributes)
+      end
+    end
+  end
+end

data/lib/mobility/{backend → backends}/sequel/postgres_query_methods.rb

@@ -1,6 +1,5 @@
-
 module Mobility
-  module Backend
+  module Backends
     module PostgresQueryMethods
       private
 

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

@@ -1,5 +1,7 @@
+require "mobility/util"
+
 module Mobility
-  module Backend
+  module Backends
     module Sequel
 =begin
 
@@ -9,10 +11,10 @@ models. For details see backend-specific subclasses.
 =end
       class QueryMethods < Module
         # @param [Array<String>] attributes Translated attributes
-        def initialize(attributes, **_)
-          @attributes = attributes.map! &:to_sym
+        def initialize(attributes, _)
+          @attributes = attributes.map!(&:to_sym)
           @attributes_extractor = lambda do |cond|
-            cond.is_a?(Hash) && (cond.keys & attributes).presence
+            cond.is_a?(Hash) && Util.presence(cond.keys & attributes)
           end
         end
       end

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

@@ -1,8 +1,12 @@
+require "mobility/backends/sequel"
+require "mobility/backends/hash_valued"
+require "mobility/backends/serialized"
+
 module Mobility
-  module Backend
+  module Backends
 =begin
 
-Implements {Mobility::Backend::Serialized} backend for Sequel models, using the
+Implements {Mobility::Backends::Serialized} backend for Sequel models, using the
 Sequel serialization plugin.
 
 @see http://sequel.jeremyevans.net/rdoc-plugins/classes/Sequel/Plugins/Serialization.html Sequel serialization plugin
@@ -10,7 +14,7 @@ Sequel serialization plugin.
 
 @example Define attribute with serialized backend
   class Post < Sequel::Model
-    include Mobility
+    extend Mobility
     translates :title, backend: :serialized, format: :yaml
   end
 
@@ -23,35 +27,22 @@ Sequel serialization plugin.
   post.save
   post.deserialized_values[:title]       # get deserialized value
   #=> {:en=>"foo", :ja=>"あああ"}
-  post.title_before_mobility             # get serialized value
+  post.title(super: true)                # get serialized value
   #=> "---\n:en: foo\n:ja: \"あああ\"\n"
 
 =end
     class Sequel::Serialized
       include Sequel
+      include HashValued
 
-      require 'mobility/backend/sequel/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/sequel/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
 
@@ -68,7 +59,7 @@ Sequel serialization plugin.
 
         method_overrides = Module.new do
           define_method :initialize_set do |values|
-            attributes.each { |attribute| send(:"#{attribute}_before_mobility=", {}.send(:"to_#{format}")) }
+            attributes.each { |attribute| self[attribute.to_sym] = {}.send(:"to_#{format}") }
             super(values)
           end
         end
@@ -92,24 +83,12 @@ Sequel serialization plugin.
         end
       end
 
-      # @!group Cache Methods
-      # @return [Hash]
-      def new_cache
-        translations
-      end
-
-      # @return [Boolean]
-      def write_to_cache?
-        true
-      end
-      # @!endgroup
-
       # @note The original serialization_modification_detection plugin sets
       #   +@original_deserialized_values+ to be +@deserialized_values+, which
       #   doesn't work. Setting it to a new empty hash seems to work better.
       module SerializationModificationDetectionFix
         def after_save
-          super()
+          super
           @original_deserialized_values = {}
         end
       end
@@ -121,7 +100,7 @@ Sequel serialization plugin.
       end
 
       def serialized_value
-        model.send("#{attribute}_before_mobility")
+        model[attribute.to_sym]
       end
     end
   end

data/lib/mobility/backends/sequel/serialized/query_methods.rb

@@ -0,0 +1,17 @@
+require "mobility/backends/sequel/query_methods"
+
+module Mobility
+  module Backends
+    class Sequel::Serialized::QueryMethods < Sequel::QueryMethods
+      def initialize(attributes, _)
+        super
+        attributes_extractor = @attributes_extractor
+        cond_checker = Backends::Serialized.attr_checker(attributes_extractor)
+
+        define_method :where do |*cond, &block|
+          cond_checker.call(cond.first) || super(*cond, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -1,14 +1,21 @@
+require "mobility/util"
+require "mobility/backends/sequel"
+require "mobility/backends/key_value"
+require "mobility/sequel/model_translation"
+
 module Mobility
-  module Backend
+  module Backends
 =begin
 
-Implements the {Mobility::Backend::Table} backend for Sequel models.
+Implements the {Mobility::Backends::Table} backend for Sequel models.
 
 =end
     class Sequel::Table
       include Sequel
+      include Table
+      include Util
 
-      require 'mobility/backend/sequel/table/query_methods'
+      require 'mobility/backends/sequel/table/query_methods'
 
       # @return [Symbol] name of the association method
       attr_reader :association_name
@@ -17,26 +24,13 @@ Implements the {Mobility::Backend::Table} backend for Sequel models.
       attr_reader :translation_class
 
       # @!macro backend_constructor
-      # @option options [Symbol] association_name Name of association
-      def initialize(model, attribute, **options)
+      def initialize(model, attribute, options = {})
         super
-        @association_name  = options[:association_name]
         @translation_class = options[:model_class].const_get(options[:subclass_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
-
       # @!group Backend Configuration
-      # @option options [Symbol] association_name (:mobility_model_translations) Name of association method
+      # @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
       # @option options [Symbol] subclass_name Name of subclass to append to model class to generate translation class
@@ -44,12 +38,12 @@ Implements the {Mobility::Backend::Table} backend for Sequel models.
       def self.configure(options)
         raise CacheRequired, "Cache required for Sequel::Table backend" if options[:cache] == false
         table_name = options[:model_class].table_name
-        options[:table_name]  ||= :"#{table_name.to_s.singularize}_translations"
-        options[:foreign_key] ||= table_name.to_s.downcase.singularize.camelize.foreign_key
-        if (association_name = options[:association_name]).present?
-          options[:subclass_name] ||= association_name.to_s.singularize.camelize
+        options[:table_name]  ||= :"#{singularize(table_name)}_translations"
+        options[:foreign_key] ||= foreign_key(camelize(singularize(table_name.to_s.downcase)))
+        if association_name = options[:association_name]
+          options[:subclass_name] ||= camelize(singularize(association_name))
         else
-          options[:association_name] = :mobility_model_translations
+          options[:association_name] = :translations
           options[:subclass_name] ||= :Translation
         end
         %i[table_name foreign_key association_name subclass_name].each { |key| options[key] = options[key].to_sym }
@@ -60,10 +54,6 @@ Implements the {Mobility::Backend::Table} backend for Sequel models.
         association_name = options[:association_name]
         subclass_name    = options[:subclass_name]
 
-        cache_accessor_name = :"__#{association_name}_cache"
-
-        attr_accessor cache_accessor_name
-
         translation_class =
           if self.const_defined?(subclass_name, false)
             const_get(subclass_name, false)
@@ -88,9 +78,10 @@ Implements the {Mobility::Backend::Table} backend for Sequel models.
         callback_methods = Module.new do
           define_method :after_save do
             super()
-            send(cache_accessor_name).each_value do |translation|
-              translation.id ? translation.save : send("add_#{association_name.to_s.singularize}", translation)
-            end if send(cache_accessor_name)
+            cache_accessor = instance_variable_get(:"@__mobility_#{association_name}_cache")
+            cache_accessor.each_value do |translation|
+              translation.id ? translation.save : send("add_#{Util.singularize(association_name)}", translation)
+            end if cache_accessor
           end
         end
         include callback_methods
@@ -100,42 +91,20 @@ Implements the {Mobility::Backend::Table} backend for Sequel models.
 
       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.clear if model_cache
-      end
-      # @!endgroup
-
-      private
-
-      def translation_for(locale)
-        translation = translations.find { |t| t.locale == locale.to_s }
+      def translation_for(locale, _)
+        translation = model.send(association_name).find { |t| t.locale == locale.to_s }
         translation ||= translation_class.new(locale: locale)
         translation
       end
 
-      def translations
-        model.send(association_name)
-      end
+      module Cache
+        include Table::Cache
 
-      def model_cache
-        model.send(:"__#{association_name}_cache")
-      end
+        private
 
-      def reset_model_cache
-        model.send(:"__#{association_name}_cache=",
-                   Table::TranslationsCache.new { |locale| translation_for(locale) })
+        def translations
+          (model.send(association_name) + cache.values).uniq
+        end
       end
 
       class CacheRequired < ::StandardError; end

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

@@ -1,5 +1,7 @@
+require "mobility/backends/sequel/query_methods"
+
 module Mobility
-  module Backend
+  module Backends
     class Sequel::Table::QueryMethods < Sequel::QueryMethods
       def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
         super
@@ -15,7 +17,7 @@ module Mobility
         end
       end
 
-      def define_join_method(association_name, translation_class, table_name: nil, foreign_key: nil, **_)
+      def define_join_method(association_name, translation_class, table_name: nil, foreign_key: nil, **)
         define_method :"join_#{association_name}" do |**options|
           return self if (@__mobility_table_joined || []).include?(table_name)
           (@__mobility_table_joined ||= []) << table_name
@@ -29,7 +31,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
 
         # See note in AR Table QueryMethods class about limitations of

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

@@ -1,5 +1,7 @@
+require "mobility/util"
+
 module Mobility
-  module Backend
+  module Backends
 =begin
 
 Stores translations as serialized attributes in a single text column. This
@@ -15,20 +17,31 @@ with the same name as the translated attribute.
 
 Format for serialization. Either +:yaml+ (default) or +:json+.
 
-@see Mobility::Backend::ActiveRecord::Serialized
-@see Mobility::Backend::Sequel::Serialized
+@see Mobility::Backends::ActiveRecord::Serialized
+@see Mobility::Backends::Sequel::Serialized
 
 =end
     module Serialized
-      include OrmDelegator
+      extend Backend::OrmDelegator
 
       class << self
+
+        # @!group Backend Configuration
+        # @option options [Symbol] format (:yaml) Serialization format
+        # @raise [ArgumentError] if a format other than +:yaml+ or +:json+ is passed in
+        def 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])
+        end
+        # @!endgroup
+
         def serializer_for(format)
           lambda do |obj|
             return if obj.nil?
             if obj.is_a? Hash
               obj = obj.inject({}) do |translations, (locale, value)|
-                translations[locale] = value.to_s if value.present?
+                translations[locale] = value.to_s if Util.present?(value)
                 translations
               end
             else
@@ -47,6 +60,15 @@ Format for serialization. Either +:yaml+ (default) or +:json+.
             lambda { |v| JSON.parse(v, symbolize_names: true) }
           end
         end
+
+        def attr_checker(attributes_extractor)
+          lambda do |cond|
+            if keys = attributes_extractor.call(cond)
+              raise ArgumentError,
+                "You cannot query on mobility attributes translated with the Serialized backend (#{keys.join(", ")})."
+            end
+          end
+        end
       end
     end
   end