mobility 0.0.1 → 0.1.0

data/lib/mobility/backend/active_record.rb

@@ -0,0 +1,13 @@
+module Mobility
+  module Backend
+    module ActiveRecord
+      autoload :Column,       'mobility/backend/active_record/column'
+      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'
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Column} backend for ActiveRecord models.
+
+@note This backend disables the +accessor_locales+ option, which would
+  otherwise interfere with column methods.
+
+@example
+  class Post < ActiveRecord::Base
+    translates :title, backend: :column
+  end
+
+  Mobility.locale = :en
+  post = Post.create(title: "foo")
+  post.title
+  #=> "foo"
+  post.title_en
+  #=> "foo"
+=end
+    class ActiveRecord::Column
+      include Backend
+      include Mobility::Backend::Column
+
+      autoload :QueryMethods, 'mobility/backend/active_record/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|
+        mod = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().extending(QueryMethods.new(attributes, options))
+          end
+        end
+        extend mod
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Mobility
+  module Backend
+    class ActiveRecord::Column::QueryMethods < Backend::ActiveRecord::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+
+        define_method :where! do |opts, *rest|
+          if i18n_keys = attributes_extractor.call(opts)
+            opts = opts.with_indifferent_access
+            i18n_keys.each { |attr| opts[Column.column_name_for(attr)] = opts.delete(attr) }
+          end
+          super(opts, *rest)
+        end
+
+        attributes.each do |attribute|
+          define_method :"find_by_#{attribute}" do |value|
+            find_by(Column.column_name_for(attribute) => value)
+          end
+        end
+      end
+
+      def extended(relation)
+        super
+        attributes_extractor = @attributes_extractor
+
+        mod = Module.new do
+          define_method :not do |opts, *rest|
+            if i18n_keys = attributes_extractor.call(opts)
+              opts = opts.with_indifferent_access
+              i18n_keys.each { |attr| opts[Column.column_name_for(attr)] = opts.delete(attr) }
+            end
+            super(opts, *rest)
+          end
+        end
+        relation.model.mobility_where_chain.prepend(mod)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Mobility
+  module Backend
+=begin
+
+Internal class used by ActiveRecord backends that store values as a hash.
+
+=end
+    class ActiveRecord::HashValued
+      include Backend
+
+      # @!group Backend Accessors
+      #
+      # @!macro backend_reader
+      def read(locale, **options)
+        translations[locale]
+      end
+
+      # @!macro backend_writer
+      def write(locale, value, **options)
+        translations[locale] = value
+      end
+      # @!endgroup
+
+      def translations
+        model.read_attribute(attribute)
+      end
+      alias_method :new_cache, :translations
+
+      def write_to_cache?
+        true
+      end
+
+      setup do |attributes, options|
+        attributes.each { |attribute| store attribute, coder: Coder }
+        before_validation do
+          attributes.each { |attribute| self.send(:"#{attribute}=", {}) if send(attribute).nil? }
+        end
+      end
+
+      class Coder
+        def self.dump(obj)
+          if obj.is_a? Hash
+            obj = obj.inject({}) do |translations, (locale, value)|
+              translations[locale] = value if value.present?
+              translations
+            end
+          else
+            raise ArgumentError, "Attribute is supposed to be a Hash, but was a #{obj.class}. -- #{obj.inspect}"
+          end
+        end
+
+        def self.load(obj)
+          obj
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+      autoload :QueryMethods, '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, **options)
+        translations[locale] = value && value.to_s
+      end
+      # @!endgroup
+
+      setup do |attributes, options|
+        query_methods = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().extending(QueryMethods.new(attributes, options))
+          end
+        end
+        extend query_methods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Mobility
+  module Backend
+    class ActiveRecord::Hstore::QueryMethods < ActiveRecord::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+
+        define_method :where! do |opts, *rest|
+          if i18n_keys = attributes_extractor.call(opts)
+            locale = Mobility.locale
+            opts = opts.with_indifferent_access
+
+            result = i18n_keys.inject(all) do |scope, attr|
+              value = opts.delete(attr)
+              if value.nil?
+                scope.where.not("#{table_name}.#{attr} ? '#{locale}'")
+              else
+                scope.where!("#{table_name}.#{attr} @> hstore('#{locale}', ?)", value.to_s)
+              end
+            end
+            result = result.where!(opts, *rest) if opts.present?
+            result
+          else
+            super(opts, *rest)
+          end
+        end
+      end
+
+      def extended(relation)
+        super
+        attributes_extractor = @attributes_extractor
+        table_name = relation.model.table_name
+
+        mod = Module.new do
+          define_method :not do |opts, *rest|
+            if i18n_keys = attributes_extractor.call(opts)
+              locale = Mobility.locale
+              opts = opts.with_indifferent_access
+
+              i18n_keys.inject(relation) { |scope, attr|
+                scope.where!("#{table_name}.#{attr} ? '#{locale}'").
+                  where.not("#{table_name}.#{attr} @> hstore('#{locale}', ?)", opts.delete(attr).to_s)
+              }.where.not(opts, *rest)
+            else
+              super(opts, *rest)
+            end
+          end
+        end
+        relation.model.mobility_where_chain.prepend(mod)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'mobility/backend/active_record/hash_valued'
+
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Jsonb} backend for ActiveRecord models.
+
+@see Mobility::Backend::ActiveRecord::HashValued
+
+=end
+    class ActiveRecord::Jsonb < ActiveRecord::HashValued
+      autoload :QueryMethods, 'mobility/backend/active_record/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|
+        query_methods = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().extending(QueryMethods.new(attributes, options))
+          end
+        end
+        extend query_methods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Mobility
+  module Backend
+    class ActiveRecord::Jsonb::QueryMethods < ActiveRecord::QueryMethods
+      def initialize(attributes, **options)
+        super
+        attributes_extractor = @attributes_extractor
+
+        define_method :where! do |opts, *rest|
+          if i18n_keys = attributes_extractor.call(opts)
+            locale = Mobility.locale
+            opts = opts.with_indifferent_access
+
+            result = i18n_keys.inject(all) do |scope, attr|
+              value = opts.delete(attr)
+              if value.nil?
+                scope.where.not("#{table_name}.#{attr} ? :locale", locale: locale)
+              else
+                scope.where!("#{table_name}.#{attr} @> (?)::jsonb", { locale => value }.to_json)
+              end
+            end
+            result = result.where!(opts, *rest) if opts.present?
+            result
+          else
+            super(opts, *rest)
+          end
+        end
+      end
+
+      def extended(relation)
+        super
+        attributes_extractor = @attributes_extractor
+        table_name = relation.model.table_name
+
+        mod = Module.new do
+          define_method :not do |opts, *rest|
+            if i18n_keys = attributes_extractor.call(opts)
+              locale = Mobility.locale
+              opts = opts.with_indifferent_access
+
+              i18n_keys.inject(relation) { |scope, attr|
+                scope.where!("#{table_name}.#{attr} ? :locale", locale: locale).
+                  where.not("#{table_name}.#{attr} @> (?)::jsonb", { locale => opts.delete(attr) }.to_json)
+              }.where.not(opts, *rest)
+            else
+              super(opts, *rest)
+            end
+          end
+        end
+        relation.model.mobility_where_chain.prepend(mod)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::KeyValue} backend for ActiveRecord models.
+
+@example
+  class Post < ActiveRecord::Base
+    translates :title, backend: :key_value, association_name: :translations, type: :string
+  end
+
+  post = Post.create(title: "foo")
+  post.translations
+  #=> #<ActiveRecord::Associations::CollectionProxy ... >
+  post.translations.first.value
+  #=> "foo"
+  post.translations.first.class
+  #=> Mobility::ActiveRercord::StringTranslation
+
+=end
+    class ActiveRecord::KeyValue
+      include Backend
+
+      autoload :QueryMethods, '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, **options)
+        translation_for(locale).value
+      end
+
+      # @!macro backend_reader
+      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] association_name (:mobility_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)
+        options[:type]             ||= :text
+        case type = options[:type].to_sym
+        when :text, :string
+          options[:class_name]     ||= Mobility::ActiveRecord.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]
+
+        # Track all attributes for this association, so that we can limit the scope
+        # of keys for the association to only these attributes. We need to track the
+        # attributes assigned to the association in case this setup code is called
+        # multiple times, so we don't "forget" earlier attributes.
+        #
+        attrs_method_name = :"__#{association_name}_attributes"
+        association_attributes = (instance_variable_get(:"@#{attrs_method_name}") || []) + attributes
+        instance_variable_set(:"@#{attrs_method_name}", association_attributes)
+
+        has_many association_name, ->{ where key: association_attributes },
+          as: :translatable,
+          class_name: translations_class,
+          dependent:  :destroy,
+          inverse_of: :translatable,
+          autosave:   true
+        before_save do
+          send(association_name).select { |t| t.value.blank? }.each do |translation|
+            send(association_name).destroy(translation)
+          end
+        end
+
+        mod = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().extending(QueryMethods.new(attributes, options))
+          end
+        end
+        extend mod
+      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 builds one if none is present.
+      # @param [Symbol] locale
+      # @return [Mobility::ActiveRecord::TextTranslation,Mobility::ActiveRecord::StringTranslation]
+      def translation_for(locale)
+        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