mobility 0.0.1 → 0.1.0

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

@@ -0,0 +1,63 @@
+module Mobility
+  module Backend
+    class ActiveRecord::KeyValue::QueryMethods < ActiveRecord::QueryMethods
+      def initialize(attributes, **options)
+        super
+        association_name, translations_class = options[:association_name], options[:class_name]
+        @association_name    = association_name
+        attributes_extractor = @attributes_extractor
+
+        define_method :"join_#{association_name}" do |*attributes, **options|
+          attributes.inject(self) do |relation, attribute|
+            t = translations_class.arel_table.alias(:"#{attribute}_#{association_name}")
+            m = arel_table
+            join_type = options[:outer_join] ? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
+            relation.joins(m.join(t, join_type).
+                           on(t[:key].eq(attribute).
+                              and(t[:locale].eq(Mobility.locale).
+                                  and(t[:translatable_type].eq(name).
+                                      and(t[:translatable_id].eq(m[:id]))))).join_sources)
+          end
+        end
+
+        define_method :where! do |opts, *rest|
+          if i18n_keys = attributes_extractor.call(opts)
+            opts = opts.with_indifferent_access
+            i18n_nulls = i18n_keys.select { |key| opts[key].nil? }
+            i18n_keys.each { |attr| opts["#{attr}_#{association_name}"] = { value: opts.delete(attr) }}
+            super(opts, *rest).
+              send("join_#{association_name}", *(i18n_keys - i18n_nulls)).
+              send("join_#{association_name}", *i18n_nulls, outer_join: true)
+          else
+            super(opts, *rest)
+          end
+        end
+
+        attributes.each do |attribute|
+          define_method :"find_by_#{attribute}" do |value|
+            find_by(attribute.to_sym => value)
+          end
+        end
+      end
+
+      def extended(relation)
+        super
+        association_name     = @association_name
+        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["#{attr}_#{association_name}"] = { value: opts.delete(attr) }}
+              super(opts, *rest).send(:"join_#{association_name}", *i18n_keys)
+            else
+              super(opts, *rest)
+            end
+          end
+        end
+        relation.model.mobility_where_chain.prepend(mod)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Mobility
+  module Backend
+    module ActiveRecord
+=begin
+
+Defines query method overrides to handle translated attributes for ActiveRecord
+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
+          @attributes_extractor = lambda do |opts|
+            opts.is_a?(Hash) && (opts.keys.map(&:to_s) & attributes).presence
+          end
+        end
+
+        # @param [ActiveRecord::Relation] relation Relation being extended
+        def extended(relation)
+          model_class = relation.model
+          unless model_class.respond_to?(:mobility_where_chain)
+            model_class.define_singleton_method(:mobility_where_chain) do
+              @mobility_where_chain ||= Class.new(::ActiveRecord::QueryMethods::WhereChain)
+            end
+
+            relation.define_singleton_method :where do |opts = :chain, *rest|
+              opts == :chain ? mobility_where_chain.new(spawn) : super(opts, *rest)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module Mobility
+  module Backend
+=begin
+
+Implements {Mobility::Backend::Serialized} backend for ActiveRecord models.
+
+@example Define attribute with serialized backend
+  class Post < ActiveRecord::Base
+    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.read_attribute(:title)      # get serialized value
+  #=> {:en=>"foo", :ja=>"あああ"}
+
+=end
+    class ActiveRecord::Serialized
+      include Backend
+
+      autoload :QueryMethods, 'mobility/backend/active_record/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|
+        coder = { yaml: YAMLCoder, json: JSONCoder }[options[:format]]
+        attributes.each { |attribute| serialize attribute, coder }
+
+        extension = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().extending(QueryMethods.new(attributes, options))
+          end
+        end
+        extend extension
+      end
+
+      # @!group Cache Methods
+      # Returns column value as a hash
+      # @return [Hash]
+      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
+          class #{format.upcase}Coder
+            def self.dump(obj)
+              Serialized.serializer_for(:#{format}).call(obj)
+            end
+
+            def self.load(obj)
+              return {} if obj.nil?
+              Serialized.deserializer_for(:#{format}).call(obj)
+            end
+          end
+        EOM
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Mobility
+  module Backend
+    class ActiveRecord::Serialized::QueryMethods < ActiveRecord::QueryMethods
+      def initialize(attributes, **options)
+        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
+
+        define_method :where! do |opts, *rest|
+          opts_checker.call(opts) || super(opts, *rest)
+        end
+      end
+
+      def extended(relation)
+        super
+        opts_checker = @opts_checker
+
+        mod = Module.new do
+          define_method :not do |opts, *rest|
+            opts_checker.call(opts) || super(opts, *rest)
+          end
+        end
+        relation.model.mobility_where_chain.prepend(mod)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+module Mobility
+  module Backend
+=begin
+
+Implements the {Mobility::Backend::Table} backend for ActiveRecord models.
+
+@example Model with table backend
+  class Post < ActiveRecord::Base
+    translates :title, backend: :table, association_name: :translations
+  end
+
+  post = Post.create(title: "foo")
+  #<Post:0x00... id: 1>
+
+  post.title
+  #=> "foo"
+
+  post.translations
+  #=> [#<Post::Translation:0x00...
+  #  id: 1,
+  #  locale: "en",
+  #  post_id: 1,
+  #  title: "foo">]
+
+  Post::Translation.first
+  #=> #<Post::Translation:0x00...
+  #  id: 1,
+  #  locale: "en",
+  #  post_id: 1,
+  #  title: "foo">
+
+@example Model with multiple translation tables
+  class Post < ActiveRecord::Base
+    translates :title,   backend: :table, table_name: :post_title_translations,   association_name: :title_translations
+    translates :content, backend: :table, table_name: :post_content_translations, association_name: :content_translations
+  end
+
+  post = Post.create(title: "foo", content: "bar")
+  #<Post:0x00... id: 1>
+
+  post.title
+  #=> "foo"
+
+  post.content
+  #=> "bar"
+
+  post.title_translations
+  #=> [#<Post::TitleTranslation:0x00...
+  #  id: 1,
+  #  locale: "en",
+  #  post_id: 1,
+  #  title: "foo">]
+
+  post.content_translations
+  #=> [#<Post::ContentTranslation:0x00...
+  #  id: 1,
+  #  locale: "en",
+  #  post_id: 1,
+  #  content: "bar">]
+
+  Post::TitleTranslation.first
+  #=> #<Post::TitleTranslation:0x00...
+  #  id: 1,
+  #  locale: "en",
+  #  post_id: 1,
+  #  title: "foo">
+
+  Post::ContentTranslation.first
+  #=> #<Post::ContentTranslation:0x00...
+  #  id: 1,
+  #  locale: "en",
+  #  post_id: 1,
+  #  title: "bar">
+=end
+    class ActiveRecord::Table
+      include Backend
+
+      autoload :QueryMethods, 'mobility/backend/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, **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
+      # @!endgroup
+
+      # @!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 (:Translation) Name of subclass
+      #   to append to model class to generate translation class
+      def self.configure!(options)
+        table_name = options[:model_class].table_name
+        options[:table_name]  ||= "#{table_name.singularize}_translations"
+        options[:foreign_key] ||= table_name.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[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]
+
+        attr_accessor :"__#{association_name}_cache"
+
+        translation_class =
+          if self.const_defined?(subclass_name, false)
+            const_get(subclass_name, false)
+          else
+            const_set(subclass_name, Class.new(Mobility::ActiveRecord::ModelTranslation))
+          end
+
+        translation_class.table_name = options[:table_name]
+
+        has_many association_name,
+          class_name:  translation_class.name,
+          foreign_key: options[:foreign_key],
+          dependent:   :destroy,
+          autosave:    true,
+          inverse_of:  :translated_model
+
+        translation_class.belongs_to :translated_model,
+          class_name:  name,
+          foreign_key: options[:foreign_key],
+          inverse_of:  association_name
+
+        query_methods = Module.new do
+          define_method :i18n do
+            @mobility_scope ||= super().extending(QueryMethods.new(attributes, options))
+          end
+        end
+        extend query_methods
+      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.try(:clear)
+      end
+      # @!endgroup
+
+      private
+
+      def translation_for(locale)
+        translation = translations.find { |t| t.locale == locale.to_s }
+        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/active_record/table/query_methods.rb

@@ -0,0 +1,91 @@
+module Mobility
+  module Backend
+    class ActiveRecord::Table::QueryMethods < ActiveRecord::QueryMethods
+      def initialize(attributes, **options)
+        super
+        association_name     = options[:association_name]
+        foreign_key          = options[:foreign_key]
+        @association_name    = association_name
+        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
+          t = translation_class.arel_table
+          m = arel_table
+          join_type = options[:outer_join] ? Arel::Nodes::OuterJoin : Arel::Nodes::InnerJoin
+          joins(m.join(t, join_type).
+                on(t[foreign_key].eq(m[:id]).
+                   and(t[:locale].eq(Mobility.locale))).join_sources)
+        end
+
+        # Note that Mobility will try to use inner/outer joins appropriate to the query,
+        # so for example:
+        #
+        # Article.where(title: nil, content: nil)   #=> OUTER JOIN (all nils)
+        # Article.where(title: "foo", content: nil) #=> INNER JOIN (one non-nil)
+        #
+        # In the first case, if we are in (say) the "en" locale, then we should match articles
+        # that have *no* article_translations with English locales (since no translation is
+        # equivalent to a nil value). If we used an inner join in the first case, an article
+        # with no English translations would be filtered out, so we use an outer join.
+        #
+        # However, if you call `where` multiple times, you may end up with an outer join
+        # when a (faster) inner join would have worked fine:
+        #
+        # Article.where(title: nil).where(content: "foo") #=> OUTER JOIN
+        #
+        # In this case, we are searching for a match on the article_translations table
+        # which has a NULL title and a content equal to "foo". Since we need a positive
+        # match for content, there must be an English translation on the article, thus
+        # we can use an inner join. However, Mobility will use an outer join since we don't
+        # want to modify the existing relation which has already been joined.
+        #
+        # To avoid this problem, simply make sure to either order your queries to place nil
+        # values last, or include all queried attributes in a single `where`:
+        #
+        # Article.where(title: nil, content: "foo") #=> INNER JOIN
+        #
+        define_method :where! do |opts, *rest|
+          if i18n_keys = attributes_extractor.call(opts)
+            opts = opts.with_indifferent_access
+            options = { outer_join: i18n_keys.all? { |attr| opts[attr].nil? } }
+            i18n_keys.each { |attr| opts["#{translation_class.table_name}.#{attr}"] = opts.delete(attr) }
+            super(opts, *rest).send("join_#{association_name}", options)
+          else
+            super(opts, *rest)
+          end
+        end
+
+        attributes.each do |attribute|
+          define_method :"find_by_#{attribute}" do |value|
+            find_by(attribute.to_sym => value)
+          end
+        end
+      end
+
+      def extended(relation)
+        super
+        association_name     = @association_name
+        attributes_extractor = @attributes_extractor
+        translation_class    = @translation_class
+
+        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["#{translation_class.table_name}.#{attr}"] = opts.delete(attr) }
+              super(opts, *rest).send("join_#{association_name}")
+            else
+              super(opts, *rest)
+            end
+          end
+        end
+        relation.model.mobility_where_chain.prepend(mod)
+      end
+    end
+  end
+end