mobility 0.0.1 → 0.1.0

data/lib/mobility/backend/sequel.rb

@@ -0,0 +1,14 @@
+module Mobility
+  module Backend
+    module Sequel
+      autoload :Column,       'mobility/backend/sequel/column'
+      autoload :Dirty,        'mobility/backend/sequel/dirty'
+      autoload :Hstore,       'mobility/backend/sequel/hstore'
+      autoload :Jsonb,        'mobility/backend/sequel/jsonb'
+      autoload :KeyValue,     'mobility/backend/sequel/key_value'
+      autoload :Serialized,   'mobility/backend/sequel/serialized'
+      autoload :Table,        'mobility/backend/sequel/table'
+      autoload :QueryMethods, 'mobility/backend/sequel/query_methods'
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Column} backend for Sequel models.
+
+@note This backend disables the +accessor_locales+ option, which would
+  otherwise interfere with column methods.
+=end
+    class Sequel::Column
+      include Backend
+      include Mobility::Backend::Column
+
+      autoload :QueryMethods, 'mobility/backend/sequel/column/query_methods'
+
+      # @!group Backend Accessors
+      # @!macro backend_reader
+      # @!method read(locale, **options)
+
+      # @!group Backend Accessors
+      # @!macro backend_writer
+      # @!method write(locale, value, **options)
+
+      # @!group Backend Configuration
+      def self.configure!(options)
+        options[:locale_accessors] = false
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        extension = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().with_extend(QueryMethods.new(attributes, options))
+          end
+        end
+        extend extension
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Mobility
+  module Backend
+    class Sequel::Column::QueryMethods < Backend::Sequel::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+
+        define_method :_filter_or_exclude do |invert, clause, cond, &block|
+          if keys = attributes_extractor.call(cond)
+            cond = cond.dup
+            keys.each { |attr| cond[Column.column_name_for(attr)] = cond.delete(attr) }
+          end
+          super(invert, clause, cond, &block)
+        end
+
+        attributes.each do |attribute|
+          define_method :"first_by_#{attribute}" do |value|
+            where(attribute.to_sym => value).first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Mobility
+  module Backend
+=begin
+
+Dirty tracking for Sequel models which use the +Sequel::Plugins::Dirty+ plugin.
+
+@see http://sequel.jeremyevans.net/rdoc-plugins/index.html Sequel dirty plugin
+
+=end
+    module Sequel::Dirty
+      # @!group Backend Accessors
+      # @!macro backend_writer
+      def write(locale, value, **options)
+        locale_accessor = "#{attribute}_#{locale}".to_sym
+        if model.column_changes.has_key?(locale_accessor) && model.initial_values[locale_accessor] == value
+          super
+          [model.changed_columns, model.initial_values].each { |h| h.delete(locale_accessor) }
+        else
+          model.will_change_column("#{attribute}_#{locale}".to_sym)
+          super
+        end
+      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
+            mod = Module.new do
+              %w[initial_value column_change column_changed? reset_column].each do |method_name|
+                define_method method_name do |column|
+                  if attributes.map(&:to_sym).include?(column)
+                    super("#{column}_#{Mobility.locale}".to_sym)
+                  else
+                    super(column)
+                  end
+                end
+              end
+            end
+            include mod
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Mobility
+  module Backend
+=begin
+
+Internal class used by Sequel backends that store values as a hash.
+
+=end
+    class Sequel::HashValued
+      include Backend
+
+      # @!macro backend_reader
+      def read(locale, **options)
+        translations[locale.to_s]
+      end
+
+      # @!macro backend_writer
+      def write(locale, value, **options)
+        translations[locale.to_s] = value
+      end
+
+      # @!group Cache Methods
+      def translations
+        model.send("#{attribute}_before_mobility")
+      end
+      alias_method :new_cache, :translations
+
+      # @return [Boolean]
+      def write_to_cache?
+        true
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        method_overrides = Module.new do
+          define_method :initialize_set do |values|
+            attributes.each { |attribute| send(:"#{attribute}_before_mobility=", {}) }
+            super(values)
+          end
+          define_method :before_validation do
+            attributes.each do |attribute|
+              send("#{attribute}_before_mobility").delete_if { |_, v| v.blank? }
+            end
+            super()
+          end
+        end
+        include method_overrides
+        include Mobility::Sequel::ColumnChanges.new(attributes)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'mobility/backend/sequel/hash_valued'
+
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Hstore} backend for Sequel models.
+
+@see Mobility::Backend::Sequel::HashValued
+
+=end
+    class Sequel::Hstore < Sequel::HashValued
+      autoload :QueryMethods, 'mobility/backend/sequel/hstore/query_methods'
+
+      # @!group Backend Accessors
+      # @!macro backend_reader
+      # @!method read(locale, **options)
+
+      # @!group Backend Accessors
+      # @!macro backend_writer
+      def write(locale, value, **options)
+        translations[locale.to_s] = value && value.to_s
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        extension = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().with_extend(QueryMethods.new(attributes, options))
+          end
+        end
+        extend extension
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+Sequel.extension :pg_hstore, :pg_hstore_ops
+
+module Mobility
+  module Backend
+    class Sequel::Hstore::QueryMethods < Sequel::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+
+        define_method :_filter_or_exclude do |invert, clause, *conds, &block|
+          if (clause == :where) && i18n_keys = attributes_extractor.call(conds.first)
+            locale = Mobility.locale.to_s
+            table_name = model.table_name
+            cond = conds.first
+
+            i18n_query = i18n_keys.inject(::Sequel.expr(!invert)) do |expr, attr|
+              value = cond.delete(attr)
+              attr_hstore = ::Sequel.hstore_op(attr)
+              contains_value = attr_hstore.contains({ locale => value.to_s })
+              has_key = attr_hstore.has_key?(locale)
+              if invert
+                expr.|(has_key & ~contains_value)
+              else
+                expr.&(value.nil? ? ~has_key : contains_value)
+              end
+            end
+            super(invert, clause, *conds, &block).where(i18n_query)
+          else
+            super(invert, clause, *conds, &block)
+          end
+        end
+
+        attributes.each do |attribute|
+          define_method :"first_by_#{attribute}" do |value|
+            where(::Sequel.hstore(attribute.to_sym).contains(::Sequel.hstore({ Mobility.locale.to_s => value }))).
+              select_all(model.table_name).first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'mobility/backend/sequel/hash_valued'
+
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Jsonb} backend for Sequel models.
+
+@see Mobility::Backend::Sequel::HashValued
+
+=end
+    class Sequel::Jsonb < Sequel::HashValued
+      autoload :QueryMethods, 'mobility/backend/sequel/jsonb/query_methods'
+
+      # @!group Backend Accessors
+      #
+      # @note Translation may be string, integer or boolean-valued since
+      #   value is stored on a JSON hash.
+      # @param [Symbol] locale Locale to read
+      # @param [Hash] options
+      # @return [String,Integer,Boolean] Value of translation
+      # @!method read(locale, **options)
+
+      # @!group Backend Accessors
+      # @note Translation may be string, integer or boolean-valued since
+      #   value is stored on a JSON hash.
+      # @param [Symbol] locale Locale to write
+      # @param [String,Integer,Boolean] value Value to write
+      # @param [Hash] options
+      # @return [String,Integer,Boolean] Updated value
+      # @!method write(locale, value, **options)
+
+      setup do |attributes, options|
+        extension = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().with_extend(QueryMethods.new(attributes, options))
+          end
+        end
+        extend extension
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+Sequel.extension :pg_json, :pg_json_ops
+
+module Mobility
+  module Backend
+    class Sequel::Jsonb::QueryMethods < Sequel::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+
+        define_method :_filter_or_exclude do |invert, clause, *conds, &block|
+          if (clause == :where) && i18n_keys = attributes_extractor.call(conds.first)
+            locale = Mobility.locale.to_s
+            table_name = model.table_name
+            cond = conds.first
+
+            i18n_query = i18n_keys.inject(::Sequel.expr(!invert)) do |expr, attr|
+              value = cond.delete(attr)
+              attr_jsonb = ::Sequel.pg_jsonb_op(attr)
+              contains_value = attr_jsonb.contains({ locale => value })
+              has_key = attr_jsonb.has_key?(locale)
+              if invert
+                expr.|(has_key & ~contains_value)
+              else
+                expr.&(value.nil? ? ~has_key : contains_value)
+              end
+            end
+            super(invert, clause, *conds, &block).where(i18n_query)
+          else
+            super(invert, clause, *conds, &block)
+          end
+        end
+
+        attributes.each do |attribute|
+          define_method :"first_by_#{attribute}" do |value|
+            where(::Sequel.pg_jsonb_op(attribute).contains({ Mobility.locale => value })).
+              select_all(model.table_name).first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::KeyValue} backend for Sequel models.
+
+@note This backend requires the cache to be enabled in order to track
+  and store changed translations, since Sequel does not support +build+-type
+  methods on associations like ActiveRecord.
+
+=end
+    class Sequel::KeyValue
+      include Backend
+
+      autoload :QueryMethods, 'mobility/backend/sequel/key_value/query_methods'
+
+      # @return [Symbol] name of the association
+      attr_reader :association_name
+
+      # @return [Class] translation model class
+      attr_reader :class_name
+
+      # @!macro backend_constructor
+      # @option options [Symbol] association_name Name of association
+      # @option options [Class] class_name Translation model class
+      def initialize(model, attribute, **options)
+        super
+        @association_name = options[:association_name]
+        @class_name       = options[:class_name]
+      end
+
+      # @!group Backend Accessors
+      # @!macro backend_reader
+      def read(locale, **options)
+        translation_for(locale).value
+      end
+
+      # @!macro backend_writer
+      def write(locale, value, **options)
+        translation_for(locale).tap { |t| t.value = value }.value
+      end
+      # @!endgroup
+
+      # @!group Backend Configuration
+      # @option options [Symbol] type (:text) Column type to use
+      # @option options [Symbol] associaiton_name (:mobility_text_translations) Name of association method
+      # @option options [Symbol] class_name ({Mobility::Sequel::TextTranslation}) Translation class
+      # @raise [CacheRequired] if cache is disabled
+      # @raise [ArgumentError] if type is not either :text or :string
+      def self.configure!(options)
+        raise CacheRequired, "Cache required for Sequel::KeyValue backend" if options[:cache] == false
+        options[:type]             ||= :text
+        case type = options[:type].to_sym
+        when :text, :string
+          options[:class_name]     ||= Mobility::Sequel.const_get("#{type.capitalize}Translation")
+        else
+          raise ArgumentError, "type must be one of: [text, string]"
+        end
+        options[:class_name] = options[:class_name].constantize if options[:class_name].is_a?(String)
+        options[:association_name] ||= options[:class_name].table_name.to_sym
+        %i[type association_name].each { |key| options[key] = options[key].to_sym }
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        association_name   = options[:association_name]
+        translations_class = options[:class_name]
+
+        attrs_method_name = :"#{association_name}_attributes"
+        association_attributes = (instance_variable_get(:"@#{attrs_method_name}") || []) + attributes
+        instance_variable_set(:"@#{attrs_method_name}", association_attributes)
+
+        one_to_many association_name,
+          reciprocal:      :translatable,
+          key:             :translatable_id,
+          reciprocal_type: :one_to_many,
+          conditions:      { translatable_type: self.to_s, key: association_attributes },
+          adder:           proc { |translation| translation.update(translatable_id: pk, translatable_type: self.class.to_s) },
+          remover:         proc { |translation| translation.update(translatable_id: nil, translatable_type: nil) },
+          clearer:         proc { send(:"#{association_name}_dataset").update(translatable_id: nil, translatable_type: nil) },
+          class:           translations_class
+
+        plugin :association_dependencies, association_name => :destroy
+
+        callback_methods = Module.new do
+          define_method :before_save do
+            super()
+            send(association_name).select { |t| attributes.include?(t.key) && t.value.blank? }.each(&:destroy)
+          end
+          define_method :after_save do
+            super()
+            attributes.each { |attribute| mobility_backend_for(attribute).save_translations }
+          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 [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 initializes one if none is present.
+      # @param [Symbol] locale
+      # @return [Mobility::Sequel::TextTranslation,Mobility::Sequel::StringTranslation]
+      def translation_for(locale)
+        translation = model.send(association_name).find { |t| t.key == attribute && t.locale == locale.to_s }
+        translation ||= class_name.new(locale: locale, key: attribute)
+        translation
+      end
+
+      # Saves translation which have been built and which have non-blank values.
+      def save_translations
+        cache.each_translation do |translation|
+          next unless translation.value.present?
+          translation.id ? translation.save : model.send("add_#{association_name.to_s.singularize}", translation)
+        end
+      end
+
+      class CacheRequired < ::StandardError; end
+    end
+  end
+end