mobility 0.3.6 → 0.4.0

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

@@ -11,9 +11,6 @@ models. For details see backend-specific subclasses.
         # @param [Array<String>] attributes Translated attributes
         def initialize(attributes, _)
           @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
@@ -30,6 +27,10 @@ models. For details see backend-specific subclasses.
             end
           end
         end
+
+        def extract_attributes(opts)
+          opts.is_a?(Hash) && (opts.keys.map(&:to_s) & @attributes).presence
+        end
       end
     end
   end

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

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

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

@@ -20,7 +20,7 @@ columns to that table.
 
 @example Model with table backend
   class Post < ActiveRecord::Base
-    translates :title, backend: :table, association_name: :translations
+    translates :title, backend: :table
   end
 
   post = Post.create(title: "foo")
@@ -139,16 +139,20 @@ columns to that table.
           inverse_of:  association_name,
           touch: true
 
+        before_save { mobility_destroy_empty_table_translations(association_name) }
+
         module_name = "MobilityArTable#{association_name.to_s.camelcase}"
         unless const_defined?(module_name)
-          callback_methods = Module.new do
+          dupable = Module.new do
             define_method :initialize_dup do |source|
               super(source)
               self.send("#{association_name}=", source.send(association_name).map(&:dup))
             end
           end
-          include const_set(module_name, callback_methods)
+          include const_set(module_name, dupable)
         end
+
+        include DestroyEmptyTranslations
       end
 
       setup_query_methods(QueryMethods)
@@ -158,6 +162,17 @@ columns to that table.
         translation ||= translations.build(locale: locale)
         translation
       end
+
+      module DestroyEmptyTranslations
+        private
+
+        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
+        end
+      end
     end
   end
 end

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

@@ -21,13 +21,13 @@ module Mobility
 
       def extended(relation)
         super
-        association_name     = @association_name
-        attributes_extractor = @attributes_extractor
-        translation_class    = @translation_class
+        association_name  = @association_name
+        translation_class = @translation_class
+        q                 = self
 
         mod = Module.new do
           define_method :not do |opts, *rest|
-            if i18n_keys = attributes_extractor.call(opts)
+            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}")
@@ -43,8 +43,7 @@ module Mobility
 
       def define_join_method(association_name, translation_class, foreign_key: nil, table_name: nil, **)
         define_method :"join_#{association_name}" do |**options|
-          return self if (@__mobility_table_joined || []).include?(table_name)
-          (@__mobility_table_joined ||= []) << table_name
+          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
@@ -55,23 +54,31 @@ module Mobility
       end
 
       def define_query_methods(association_name, translation_class, **)
-        attributes_extractor = @attributes_extractor
+        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)
+        # 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:
+        # 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).where(content: "foo") #=> OUTER JOIN
+        # 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
@@ -85,9 +92,13 @@ module Mobility
         # Article.where(title: nil, content: "foo") #=> INNER JOIN
         #
         define_method :where! do |opts, *rest|
-          if i18n_keys = attributes_extractor.call(opts)
+          if i18n_keys = q.extract_attributes(opts)
             opts = opts.with_indifferent_access
-            options = { outer_join: i18n_keys.all? { |attr| opts[attr].nil? } }
+            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.wrap(v).all? }
+            }
             i18n_keys.each { |attr| opts["#{translation_class.table_name}.#{attr}"] = opts.delete(attr) }
             super(opts, *rest).send("join_#{association_name}", options)
           else

data/lib/mobility/backends/container.rb

@@ -0,0 +1,25 @@
+module Mobility
+  module Backends
+
+=begin
+
+Stores translations for multiple attributes on a single shared Postgres jsonb
+column (called a "container").
+
+==Backend Options
+
+===+column_name+
+
+Name of the column for the translations container (where translations are
+stored).
+
+@see Mobility::Backends::ActiveRecord::Container
+@see Mobility::Backends::Sequel::Container
+@see https://www.postgresql.org/docs/current/static/datatype-json.html PostgreSQL Documentation for JSON Types
+
+=end
+    module Container
+      extend Backend::OrmDelegator
+    end
+  end
+end

data/lib/mobility/backends/hash_valued.rb

@@ -10,12 +10,12 @@ Defines read and write methods that access the value at a key with value
       # @!group Backend Accessors
       #
       # @!macro backend_reader
-      def read(locale, _ = {})
+      def read(locale, _options = nil)
         translations[locale]
       end
 
       # @!macro backend_writer
-      def write(locale, value, _ = {})
+      def write(locale, value, _options = nil)
         translations[locale] = value
       end
       # @!endgroup

data/lib/mobility/backends/null.rb

@@ -10,10 +10,10 @@ Backend which does absolutely nothing. Mostly for testing purposes.
 
       # @!group Backend Accessors
       # @return [NilClass]
-      def read(_, _ = {}); end
+      def read(_locale, _options = nil); end
 
       # @return [NilClass]
-      def write(_, _, _ = {}); end
+      def write(_locale, _value, _options = nil); end
       # @!endgroup
 
       # @!group Backend Configuration

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

@@ -16,14 +16,14 @@ Implements the {Mobility::Backends::Column} backend for Sequel models.
 
       # @!group Backend Accessors
       # @!macro backend_reader
-      def read(locale, _ = {})
+      def read(locale, _options = nil)
         column = column(locale)
         model[column] if model.columns.include?(column)
       end
 
       # @!group Backend Accessors
       # @!macro backend_writer
-      def write(locale, value, _ = {})
+      def write(locale, value, _options = nil)
         column = column(locale)
         model[column] = value if model.columns.include?(column)
       end

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

@@ -5,11 +5,11 @@ module Mobility
     class Sequel::Column::QueryMethods < Sequel::QueryMethods
       def initialize(attributes, _)
         super
-        attributes_extractor = @attributes_extractor
+        q = self
 
         %w[exclude or where].each do |method_name|
           define_method method_name do |*conds, &block|
-            if keys = attributes_extractor.call(conds.first)
+            if keys = q.extract_attributes(conds.first)
               cond = conds.first.dup
               keys.each { |attr| cond[Column.column_name_for(attr)] = cond.delete(attr) }
               super(cond, &block)

data/lib/mobility/backends/sequel/container.rb

@@ -0,0 +1,99 @@
+module Mobility
+  module Backends
+=begin
+
+Implements the {Mobility::Backends::Container} backend for Sequel models.
+
+=end
+    class Sequel::Container
+      include Sequel
+
+      require 'mobility/backends/sequel/container/query_methods'
+
+      # @return [Symbol] name of container column
+      attr_reader :column_name
+
+      # @!macro backend_constructor
+      # @option options [Symbol] column_name Name of container column
+      def initialize(model, attribute, options = {})
+        super
+        @column_name = options[:column_name]
+      end
+
+      # @!group Backend Accessors
+      #
+      # @note Translation may be a string, integer, boolean, hash or array
+      #   since value is stored on a JSON hash.
+      # @param [Symbol] locale Locale to read
+      # @param [Hash] options
+      # @return [String,Integer,Boolean] Value of translation
+      def read(locale, _ = nil)
+        model_translations(locale)[attribute]
+      end
+
+      # @note Translation may be a string, integer, boolean, hash or array
+      #   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
+      def write(locale, value, _ = nil)
+        set_attribute_translation(locale, value)
+        model_translations(locale)[attribute]
+      end
+      # @!endgroup
+      #
+      # @!group Backend Configuration
+      # @option options [Symbol] column_name (:translations) Name of column on which to store translations
+      def self.configure(options)
+        options[:column_name] ||= :translations
+      end
+      # @!endgroup
+      #
+      # @!macro backend_iterator
+      def each_locale
+        model[column_name].each do |l, _|
+          yield l.to_sym unless read(l).nil?
+        end
+      end
+
+      setup do |attributes, options|
+        column_name = options[:column_name]
+        before_validation = Module.new do
+          define_method :before_validation do
+            self[column_name].each do |k, v|
+              v.delete_if { |_locale, translation| Util.blank?(translation) }
+              self[column_name].delete(k) if v.empty?
+            end
+            super()
+          end
+        end
+        include before_validation
+        include Mobility::Sequel::HashInitializer.new(column_name)
+
+        plugin :defaults_setter
+        attributes.each { |attribute| default_values[attribute.to_sym] = {} }
+      end
+
+      setup_query_methods(QueryMethods)
+
+      private
+
+      def model_translations(locale)
+        model[column_name][locale.to_s] ||= {}
+      end
+
+      def set_attribute_translation(locale, value)
+        translations = model[column_name] || {}
+        translations[locale.to_s] ||= {}
+        # Explicitly mark translations column as changed if value changed,
+        # otherwise Sequel will not detect it.
+        # TODO: Find a cleaner/easier way to do this.
+        if translations[locale.to_s][attribute] != value
+          model.instance_variable_set(:@changed_columns, model.changed_columns | [column_name])
+        end
+        translations[locale.to_s][attribute] = value
+      end
+    end
+  end
+end

data/lib/mobility/backends/sequel/container/query_methods.rb

@@ -0,0 +1,41 @@
+require "mobility/backends/sequel/pg_query_methods"
+require "mobility/backends/sequel/query_methods"
+
+Sequel.extension :pg_json, :pg_json_ops
+
+module Mobility
+  module Backends
+    class Sequel::Container::QueryMethods < Sequel::QueryMethods
+      include Sequel::PgQueryMethods
+      attr_reader :column_name
+
+      def initialize(attributes, options)
+        super
+        column_name = @column_name = options[:column_name]
+
+        define_query_methods
+
+        attributes.each do |attribute|
+          define_method :"first_by_#{attribute}" do |value|
+            where(::Sequel.pg_jsonb_op(column_name)[Mobility.locale.to_s].contains({ attribute => value })).
+              select_all(model.table_name).first
+          end
+        end
+      end
+
+      private
+
+      def contains_value(key, value, locale)
+        build_op(column_name)[locale].contains({ key.to_s => value }.to_json)
+      end
+
+      def has_locale(key, locale)
+        build_op(column_name).has_key?(locale) & build_op(column_name)[locale].has_key?(key.to_s)
+      end
+
+      def build_op(key)
+        ::Sequel.pg_jsonb_op(key)
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'mobility/backends/sequel/postgres_query_methods'
+require 'mobility/backends/sequel/pg_query_methods'
 require "mobility/backends/sequel/query_methods"
 
 Sequel.extension :pg_hstore, :pg_hstore_ops
@@ -6,12 +6,12 @@ Sequel.extension :pg_hstore, :pg_hstore_ops
 module Mobility
   module Backends
     class Sequel::Hstore::QueryMethods < Sequel::QueryMethods
-      include PostgresQueryMethods
+      include Sequel::PgQueryMethods
 
       def initialize(attributes, _)
         super
 
-        define_query_methods("hstore")
+        define_query_methods
 
         attributes.each do |attribute|
           define_method :"first_by_#{attribute}" do |value|
@@ -20,6 +20,20 @@ module Mobility
           end
         end
       end
+
+      private
+
+      def contains_value(key, value, locale)
+        build_op(key).contains(locale => value.to_s)
+      end
+
+      def has_locale(key, locale)
+        build_op(key).has_key?(locale)
+      end
+
+      def build_op(key)
+        ::Sequel.hstore_op(key)
+      end
     end
   end
 end