mobility 0.0.1 → 0.1.0

data/lib/mobility/backend/sequel/key_value/query_methods.rb

@@ -0,0 +1,48 @@
+module Mobility
+  module Backend
+    class Sequel::KeyValue::QueryMethods < Sequel::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+        association_name, translations_class = options[:association_name], options[:class_name]
+
+        define_method :"join_#{association_name}" do |*attributes, **options|
+          attributes.inject(self) do |relation, attribute|
+            join_type = options[:outer_join] ? :left_outer : :inner
+            relation.join_table(join_type,
+                                translations_class.table_name,
+                                {
+                                  key: attribute.to_s,
+                                  locale: Mobility.locale.to_s,
+                                  translatable_type: model.name,
+                                  translatable_id: ::Sequel[:"#{model.table_name}"][:id]
+                                },
+                                table_alias: "#{attribute}_#{association_name}")
+          end
+        end
+
+        # TODO: find a better way to do this that doesn't involve overriding
+        # a private method...
+        define_method :_filter_or_exclude do |invert, clause, *cond, &block|
+          if i18n_keys = attributes_extractor.call(cond.first)
+            cond = cond.first.dup
+            i18n_nulls = i18n_keys.select { |key| cond[key].nil? }
+            i18n_keys.each { |attr| cond[::Sequel[:"#{attr}_#{association_name}"][:value]] = cond.delete(attr) }
+            super(invert, clause, cond, &block).
+              send("join_#{association_name}", *(i18n_keys - i18n_nulls)).
+              send("join_#{association_name}", *i18n_nulls, outer_join: true)
+          else
+            super(invert, clause, *cond, &block)
+          end
+        end
+        private :_filter_or_exclude
+
+        attributes.each do |attribute|
+          define_method :"first_by_#{attribute}" do |value|
+            where(attribute => value).select_all(model.table_name).first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mobility/backend/sequel/query_methods.rb

@@ -0,0 +1,22 @@
+module Mobility
+  module Backend
+    module Sequel
+=begin
+
+Defines query method overrides to handle translated attributes for Sequel
+models. For details see backend-specific subclasses.
+
+=end
+      class QueryMethods < Module
+        # @param [Array<String>] attributes Translated attributes
+        # @param [Hash] options Backend options
+        def initialize(attributes, **options)
+          @attributes = attributes.map! &:to_sym
+          @attributes_extractor = lambda do |cond|
+            cond.is_a?(Hash) && (cond.keys & attributes).presence
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mobility/backend/sequel/serialized.rb

@@ -0,0 +1,133 @@
+module Mobility
+  module Backend
+=begin
+
+Implements {Mobility::Backend::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
+@see http://sequel.jeremyevans.net/rdoc-plugins/classes/Sequel/Plugins/SerializationModificationDetection.html Sequel serialization_modification_detection plugin
+
+@example Define attribute with serialized backend
+  class Post < Sequel::Model
+    include Mobility
+    translates :title, backend: :serialized, format: :yaml
+  end
+
+@example Read and write attribute translations
+  post = Post.create(title: "foo")
+  post.title
+  #=> "foo"
+  Mobility.locale = :ja
+  post.title = "あああ"
+  post.save
+  post.deserialized_values[:title]       # get deserialized value
+  #=> {:en=>"foo", :ja=>"あああ"}
+  post.title_before_mobility             # get serialized value
+  #=> "---\n:en: foo\n:ja: \"あああ\"\n"
+
+=end
+    class Sequel::Serialized
+      include Backend
+
+      autoload :QueryMethods, 'mobility/backend/sequel/serialized/query_methods'
+
+      # @!group Backend Accessors
+      #
+      # @!macro backend_reader
+      def read(locale, **options)
+        translations[locale]
+      end
+
+      # @!macro backend_reader
+      def write(locale, value, **options)
+        translations[locale] = value
+      end
+      # @!endgroup
+
+      # @!group Backend Configuration
+      # @option options [Symbol] format (:yaml) Serialization format
+      # @raise [ArgumentError] if a format other than +:yaml+ or +:json+ is passed in
+      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])
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        format = options[:format]
+        plugin :serialization
+        plugin :serialization_modification_detection
+
+        attributes.each do |_attribute|
+          attribute = _attribute.to_sym
+          self.serialization_map[attribute] = Serialized.serializer_for(format)
+          self.deserialization_map[attribute] = Serialized.deserializer_for(format)
+        end
+
+        method_overrides = Module.new do
+          define_method :initialize_set do |values|
+            attributes.each { |attribute| send(:"#{attribute}_before_mobility=", {}.send(:"to_#{format}")) }
+            super(values)
+          end
+        end
+        include method_overrides
+
+        extension = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().with_extend(QueryMethods.new(attributes, options))
+          end
+        end
+        extend extension
+
+        include SerializationModificationDetectionFix
+      end
+
+      # Returns deserialized column value
+      # @return [Hash]
+      def translations
+        _attribute = attribute.to_sym
+        if model.deserialized_values.has_key?(_attribute)
+          model.deserialized_values[_attribute]
+        elsif model.frozen?
+          deserialize_value(_attribute, serialized_value)
+        else
+          model.deserialized_values[_attribute] = deserialize_value(_attribute, serialized_value)
+        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()
+          @original_deserialized_values = {}
+        end
+      end
+
+      private
+
+      def deserialize_value(column, value)
+        model.send(:deserialize_value, column, value)
+      end
+
+      def serialized_value
+        model.send("#{attribute}_before_mobility")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Mobility
+  module Backend
+    class Sequel::Serialized::QueryMethods < Sequel::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+        cond_checker = @cond_checker = lambda do |cond|
+          if i18n_keys = attributes_extractor.call(cond)
+            raise ArgumentError,
+              "You cannot query on mobility attributes translated with the Serialized backend (#{i18n_keys.join(", ")})."
+          end
+        end
+
+        define_method :where do |*cond, &block|
+          cond_checker.call(cond.first) || super(*cond, &block)
+        end
+      end
+    end
+  end
+end

data/lib/mobility/backend/sequel/table.rb

@@ -0,0 +1,149 @@
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Table} backend for Sequel models.
+
+=end
+    class Sequel::Table
+      include Backend
+
+      autoload :QueryMethods, 'mobility/backend/sequel/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, **options)
+        translation_for(locale).send(attribute)
+      end
+
+      # @!macro backend_reader
+      def write(locale, value, **options)
+        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] 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
+      # @raise [CacheRequired] if cache option is false
+      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
+        else
+          options[:association_name] = :mobility_model_translations
+          options[:subclass_name] ||= :Translation
+        end
+        %i[table_name foreign_key association_name subclass_name].each { |key| options[key] = options[key].to_sym }
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        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)
+          else
+            const_set(subclass_name, Class.new(::Sequel::Model(options[:table_name]))).tap do |klass|
+              klass.include ::Mobility::Sequel::ModelTranslation
+            end
+          end
+
+        one_to_many association_name,
+          class:      translation_class.name,
+          key:        options[:foreign_key],
+          reciprocal: :translated_model
+
+        translation_class.many_to_one :translated_model,
+          class:      name,
+          key:        options[:foreign_key],
+          reciprocal: association_name
+
+        plugin :association_dependencies, association_name => :destroy
+
+        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)
+          end
+        end
+        include callback_methods
+
+        extension = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().with_extend(QueryMethods.new(attributes, options))
+          end
+        end
+        extend extension
+
+        include Mobility::Sequel::ColumnChanges.new(attributes)
+      end
+
+      # @!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 }
+        translation ||= translation_class.new(locale: locale)
+        translation
+      end
+
+      def translations
+        model.send(association_name)
+      end
+
+      def translation_class
+        @translation_class ||= options[:model_class].const_get(options[:subclass_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
+
+      class CacheRequired < ::StandardError; end
+    end
+  end
+end

data/lib/mobility/backend/sequel/table/query_methods.rb

@@ -0,0 +1,48 @@
+module Mobility
+  module Backend
+    class Sequel::Table::QueryMethods < Sequel::QueryMethods
+      def initialize(attributes, **options)
+        super
+        association_name     = options[:association_name]
+        @association_name    = association_name
+        foreign_key          = options[:foreign_key]
+        attributes_extractor = @attributes_extractor
+        translation_class    = options[:model_class].const_get(options[:subclass_name])
+        @translation_class   = translation_class
+        table_name           = options[:table_name]
+
+        define_method :"join_#{association_name}" do |**options|
+          return self if (@__mobility_table_joined || []).include?(table_name)
+          (@__mobility_table_joined ||= []) << table_name
+          join_type = options[:outer_join] ? :left_outer : :inner
+          join_table(join_type,
+                     translation_class.table_name,
+                     {
+                       locale: Mobility.locale.to_s,
+                       foreign_key => ::Sequel[model.table_name][:id]
+                     })
+        end
+
+        # See note in AR Table QueryMethods class about limitations of
+        # query methods on translated attributes when searching on nil values.
+        #
+        define_method :_filter_or_exclude do |invert, clause, *cond, &block|
+          if i18n_keys = attributes_extractor.call(cond.first)
+            cond = cond.first.dup
+            outer_join = i18n_keys.all? { |key| cond[key].nil? }
+            i18n_keys.each { |attr| cond[::Sequel[translation_class.table_name][attr]] = cond.delete(attr) }
+            super(invert, clause, cond, &block).send("join_#{association_name}", outer_join: outer_join)
+          else
+            super(invert, clause, *cond, &block)
+          end
+        end
+
+        attributes.each do |attribute|
+          define_method :"first_by_#{attribute}" do |value|
+            where(attribute => value).select_all(model.table_name).first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mobility/backend/serialized.rb

@@ -0,0 +1,53 @@
+module Mobility
+  module Backend
+=begin
+
+Stores translations as serialized attributes in a single text column. This
+implies that the translated values are not searchable, and thus this backend is
+not recommended unless specific constraints prevent use of other solutions.
+
+To use this backend, ensure that the model table has a text column on its table
+with the same name as the translated attribute.
+
+==Backend Options
+
+===+format+
+
+Format for serialization. Either +:yaml+ (default) or +:json+.
+
+@see Mobility::Backend::ActiveRecord::Serialized
+@see Mobility::Backend::Sequel::Serialized
+
+=end
+    module Serialized
+      include OrmDelegator
+
+      class << self
+        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
+              end
+            else
+              raise ArgumentError, "Attribute is supposed to be a Hash, but was a #{obj.class}. -- #{obj.inspect}"
+            end
+
+            obj.send("to_#{format}")
+          end
+        end
+
+        def deserializer_for(format)
+          case format
+          when :yaml
+            lambda { |v| YAML.load(v) }
+          when :json
+            lambda { |v| JSON.parse(v, symbolize_names: true) }
+          end
+        end
+      end
+    end
+  end
+end