mobility 0.5.1 → 0.6.0

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

@@ -3,29 +3,32 @@ require "mobility/backends/active_record/query_methods"
 
 module Mobility
   module Backends
-    class ActiveRecord::Serialized::QueryMethods < ActiveRecord::QueryMethods
-      include Serialized
+    module ActiveRecord
+      class Serialized::QueryMethods < QueryMethods
+        include Backends::Serialized
 
-      def initialize(attributes, _)
-        super
-        q = self
+        def initialize(attributes, _)
+          super
+          q = self
 
-        define_method :where! do |opts, *rest|
-          q.check_opts(opts) || super(opts, *rest)
+          define_method :where! do |opts, *rest|
+            q.check_opts(opts) || super(opts, *rest)
+          end
         end
-      end
 
-      def extended(relation)
-        super
-        q = self
+        def extended(relation)
+          super
+          q = self
 
-        mod = Module.new do
-          define_method :not do |opts, *rest|
-            q.check_opts(opts) || super(opts, *rest)
+          mod = Module.new do
+            define_method :not do |opts, *rest|
+              q.check_opts(opts) || super(opts, *rest)
+            end
           end
+          relation.mobility_where_chain.include(mod)
         end
-        relation.mobility_where_chain.include(mod)
       end
+      Serialized.private_constant :QueryMethods
     end
   end
 end

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

@@ -20,6 +20,7 @@ columns to that table.
 
 @example Model with table backend
   class Post < ActiveRecord::Base
+    extend Mobility
     translates :title, backend: :table
   end
 
@@ -45,6 +46,7 @@ columns to that table.
 
 @example Model with multiple translation tables
   class Post < ActiveRecord::Base
+    extend Mobility
     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
@@ -131,7 +133,8 @@ columns to that table.
           foreign_key: options[:foreign_key],
           dependent:   :destroy,
           autosave:    true,
-          inverse_of:  :translated_model
+          inverse_of:  :translated_model,
+          extend:      TranslationsHasManyExtension
 
         translation_class.belongs_to :translated_model,
           class_name:  name,
@@ -139,7 +142,10 @@ columns to that table.
           inverse_of:  association_name,
           touch: true
 
-        before_save { mobility_destroy_empty_table_translations(association_name) }
+        before_save do
+          required_attributes = self.class.translated_attribute_names & translation_class.attribute_names
+          send(association_name).destroy_empty_translations(required_attributes)
+        end
 
         module_name = "MobilityArTable#{association_name.to_s.camelcase}"
         unless const_defined?(module_name)
@@ -151,26 +157,29 @@ columns to that table.
           end
           include const_set(module_name, dupable)
         end
-
-        include DestroyEmptyTranslations
       end
 
       setup_query_methods(QueryMethods)
 
+      # Returns translation for a given locale, or builds one if none is present.
+      # @param [Symbol] locale
       def translation_for(locale, _)
-        translation = translations.find { |t| t.locale == locale.to_s }
+        translation = translations.in_locale(locale)
         translation ||= translations.build(locale: locale)
         translation
       end
 
-      module DestroyEmptyTranslations
-        private
+      module TranslationsHasManyExtension
+        # Returns translation in a given locale, or nil if none exist
+        # @param [Symbol, String] locale
+        def in_locale(locale)
+          locale = locale.to_s
+          find { |t| t.locale == locale }
+        end
 
-        def mobility_destroy_empty_table_translations(association_name)
-          send(association_name).each do |t|
-            attrs = t.attribute_names & self.class.translated_attribute_names
-            send(association_name).destroy(t) if attrs.map(&t.method(:send)).none?
-          end
+        # Destroys translations with all empty values
+        def destroy_empty_translations(required_attributes)
+          each { |t| destroy(t) if required_attributes.map(&t.method(:send)).none? }
         end
       end
     end

data/lib/mobility/backends/active_record/table/query_methods.rb

@@ -3,104 +3,103 @@ require "mobility/backends/active_record/query_methods"
 
 module Mobility
   module Backends
-    class ActiveRecord::Table::QueryMethods < ActiveRecord::QueryMethods
-      def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
-        super
+    module ActiveRecord
+      class Table::QueryMethods < QueryMethods
+        def initialize(attributes, association_name: nil, model_class: nil, subclass_name: nil, **options)
+          super
 
-        @association_name  = association_name
-        @translation_class = translation_class = model_class.const_get(subclass_name)
+          @association_name  = association_name
+          @translation_class = translation_class = model_class.const_get(subclass_name)
 
-        define_join_method(association_name, translation_class, **options)
-        define_query_methods(association_name, translation_class, **options)
-      end
+          define_join_method(association_name, translation_class, **options)
+          define_query_methods(association_name, translation_class, **options)
+        end
 
-      def extended(relation)
-        super
-        association_name  = @association_name
-        translation_class = @translation_class
-        q                 = self
+        def extended(relation)
+          super
+          association_name  = @association_name
+          translation_class = @translation_class
+          q                 = self
 
-        mod = Module.new do
-          define_method :not do |opts, *rest|
-            if i18n_keys = q.extract_attributes(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)
+          mod = Module.new do
+            define_method :not do |opts, *rest|
+              if i18n_keys = q.extract_attributes(opts)
+                opts = opts.with_indifferent_access
+                i18n_keys.each do |attr|
+                  opts["#{translation_class.table_name}.#{attr}"] = q.collapse opts.delete(attr)
+                end
+                super(opts, *rest).send("join_#{association_name}")
+              else
+                super(opts, *rest)
+              end
             end
           end
+          relation.mobility_where_chain.include(mod)
         end
-        relation.mobility_where_chain.include(mod)
-      end
 
-      private
+        private
 
-      def define_join_method(association_name, translation_class, foreign_key: nil, table_name: nil, **)
-        define_method :"join_#{association_name}" do |**options|
-          return self if joins_values.any? { |v| v.left.name == table_name.to_s }
-          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)
+        def define_join_method(association_name, translation_class, foreign_key: nil, table_name: nil, **)
+          define_method :"join_#{association_name}" do |**options|
+            if join = joins_values.find { |v| (Arel::Nodes::Join === v) && (v.left.name == table_name.to_s) }
+              return self if (options[:outer_join] || Arel::Nodes::InnerJoin === join)
+              self.joins_values = joins_values - [join]
+            end
+            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
         end
-      end
 
-      def define_query_methods(association_name, translation_class, **)
-        q = self
+        def define_query_methods(association_name, translation_class, **)
+          q = self
 
-        # 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.
-        #
-        # When deciding whether to use an outer or inner join, array-valued
-        # conditions are treated as nil if they have any values.
-        #
-        # Article.where(title: nil, content: ["foo", nil])            #=> OUTER JOIN (all nil or array with nil)
-        # Article.where(title: "foo", content: ["foo", nil])          #=> INNER JOIN (one non-nil)
-        # Article.where(title: ["foo", "bar"], content: ["foo", nil]) #=> INNER JOIN (one non-nil array)
-        #
-        # Note that 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
-        # Article.where(title: [nil, "foo"]).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 = q.extract_attributes(opts)
-            opts = opts.with_indifferent_access
-            options = {
-              # We only need an OUTER JOIN if every value is either nil, or an
-              # array with at least one nil value.
-              outer_join: opts.values_at(*i18n_keys).compact.all? { |v| !Array(v).all? }
-            }
-            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)
+          # 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.
+          #
+          # When deciding whether to use an outer or inner join, array-valued
+          # conditions are treated as nil if they have any values.
+          #
+          # Article.where(title: nil, content: ["foo", nil])                  #=> OUTER JOIN (all nil or array with nil)
+          # Article.where(title: "foo", content: ["foo", nil])                #=> INNER JOIN (one non-nil)
+          # Article.where(title: ["foo", "bar"], content: ["foo", nil])       #=> INNER JOIN (one non-nil array)
+          #
+          # The logic also applies when a query has more than one where clause.
+          #
+          # Article.where(title: nil).where(content: nil)    #=> OUTER JOIN (all nils)
+          # Article.where(title: nil).where(content: "foo")  #=> INNER JOIN (one non-nil)
+          # Article.where(title: "foo").where(content: nil)  #=> INNER JOIN (one non-nil)
+          #
+          define_method :where! do |opts, *rest|
+            if i18n_keys = q.extract_attributes(opts)
+              opts = opts.with_indifferent_access
+              options = {
+                # We only need an OUTER JOIN if every value is either nil, or an
+                # array with at least one nil value.
+                outer_join: opts.values_at(*i18n_keys).compact.all? { |v| ![*v].all? }
+              }
+              i18n_keys.each do |attr|
+                opts["#{translation_class.table_name}.#{attr}"] = q.collapse opts.delete(attr)
+              end
+              super(opts, *rest).send("join_#{association_name}", options)
+            else
+              super(opts, *rest)
+            end
           end
         end
       end
+      Table.private_constant :QueryMethods
     end
   end
 end

data/lib/mobility/backends/hash_valued.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Mobility
   module Backends
 =begin
@@ -7,6 +8,16 @@ Defines read and write methods that access the value at a key with value
 
 =end
     module HashValued
+      # @!macro backend_constructor
+      # @option options [Symbol] column_prefix Prefix added to generate column
+      #   name from attribute name
+      # @option options [Symbol] column_suffix Suffix added to generate column
+      #   name from attribute name
+      def initialize(_model, _attribute, options = {})
+        super
+        @column_affix = "#{options[:column_prefix]}%s#{options[:column_suffix]}"
+      end
+
       # @!group Backend Accessors
       #
       # @!macro backend_reader
@@ -24,6 +35,14 @@ Defines read and write methods that access the value at a key with value
       def each_locale
         translations.each { |l, _| yield l }
       end
+
+      private
+
+      def column_name
+        @column_name ||= (@column_affix % attribute)
+      end
     end
+
+    private_constant :HashValued
   end
 end

data/lib/mobility/backends/hstore.rb

@@ -7,7 +7,9 @@ Stores translations as hash on Postgres hstore column.
 
 ==Backend Options
 
-This backend has no options.
+===+column_prefix+ and +column_suffix+
+
+Prefix and suffix to add to attribute name to generate hstore column name.
 
 @see Mobility::Backends::ActiveRecord::Hstore
 @see Mobility::Backends::Sequel::Hstore

data/lib/mobility/backends/json.rb

@@ -6,7 +6,9 @@ Stores translations as hash on Postgres json column.
 
 ==Backend Options
 
-This backend has no options.
+===+column_prefix+ and +column_suffix+
+
+Prefix and suffix to add to attribute name to generate json column name.
 
 @see Mobility::Backends::ActiveRecord::Json
 @see Mobility::Backends::Sequel::Json

data/lib/mobility/backends/jsonb.rb

@@ -6,7 +6,9 @@ Stores translations as hash on Postgres jsonb column.
 
 ==Backend Options
 
-This backend has no options.
+===+prefix+ and +suffix+
+
+Prefix and suffix to add to attribute name to generate jsonb column name.
 
 @see Mobility::Backends::ActiveRecord::Jsonb
 @see Mobility::Backends::Sequel::Jsonb

data/lib/mobility/backends/key_value.rb

@@ -15,19 +15,12 @@ string-valued translations (the only difference being the column type of the
 
 ==Backend Options
 
-===+association_name+
-
-Name of association on model. Defaults to +text_translations+ (if +type+ is
-+:text+) or +string_translations+ (if +type+ is +:string+). If specified,
-ensure name does not overlap with other methods on model or with the
-association name used by other backends on model (otherwise one will overwrite
-the other).
-
 ===+type+
 
-Currently, either +:text+ or +:string+ is supported. Determines which class to
-use for translations, which in turn determines which table to use to store
-translations (by default +text_translations+ for text type,
+Currently, either +:text+ or +:string+ is supported, but any value is allowed
+as long as a corresponding +class_name+ can be found (see below). Determines
+which class to use for translations, which in turn determines which table to
+use to store translations (by default +text_translations+ for text type,
 +string_translations+ for string type).
 
 ===+class_name+
@@ -38,6 +31,14 @@ Class to use for translations when defining association. By default,
 for Sequel models). If string is passed in, it will be constantized to get the
 class.
 
+===+association_name+
+
+Name of association on model. Defaults to +<type>_translations+, which will
+typically be either +:text_translations+ (if +type+ is +:text+) or
++:string_translations (if +type+ is +:string+). If specified, ensure name does
+not overlap with other methods on model or with the association name used by
+other backends on model (otherwise one will overwrite the other).
+
 @see Mobility::Backends::ActiveRecord::KeyValue
 @see Mobility::Backends::Sequel::KeyValue
 
@@ -84,11 +85,27 @@ class.
 
       module ClassMethods
         # @!group Backend Configuration
-        # @option options [Symbol,String] type (:text) Column type to use
-        # @raise [ArgumentError] if type is not either :text or :string
+        # @option options [Symbol,String] type Column type to use
+        # @option options [Symbol] associaiton_name (:<type>_translations) Name
+        #   of association method, defaults to +<type>_translations+
+        # @option options [Symbol] class_name Translation class, defaults to
+        #   +Mobility::<ORM>::<type>Translation+
+        # @raise [ArgumentError] if +type+ is not set, and both +class_name+
+        #   and +association_name+ are also not set
         def configure(options)
-          options[:type] = (options[:type] || :text).to_sym
-          raise ArgumentError, "type must be one of: [text, string]" unless [:text, :string].include?(options[:type])
+          options[:type]             &&= options[:type].to_sym
+          options[:association_name] &&= options[:association_name].to_sym
+          options[:class_name]       &&= Util.constantize(options[:class_name])
+          if !(options[:type] || (options[:class_name] && options[:association_name]))
+            # TODO: Remove warning and raise ArgumentError in v1.0
+            warn %{
+WARNING: In previous versions, the Mobility KeyValue backend defaulted to a
+text type column, but this behavior is now deprecated and will be removed in
+the next release. Either explicitly specify the type by passing type: :text in
+each translated model, or set a default option in your configuration.
+  }
+            options[:type] = :text
+          end
         end
 
         # Apply custom processing for plugin