ransack 1.5.1 → 1.6.0

data/lib/ransack/adapters/mongoid/context.rb

@@ -0,0 +1,208 @@
+require 'ransack/context'
+require 'polyamorous'
+
+module Ransack
+  module Adapters
+    module Mongoid
+      class Context < ::Ransack::Context
+
+        # Because the AR::Associations namespace is insane
+        # JoinDependency = ::Mongoid::Associations::JoinDependency
+        # JoinPart = JoinDependency::JoinPart
+
+        def initialize(object, options = {})
+          super
+          # @arel_visitor = @engine.connection.visitor
+        end
+
+        def relation_for(object)
+          object.all
+        end
+
+        def type_for(attr)
+          return nil unless attr && attr.valid?
+          name    = attr.arel_attribute.name.to_s
+          # table   = attr.arel_attribute.relation.table_name
+
+          # schema_cache = @engine.connection.schema_cache
+          # raise "No table named #{table} exists" unless schema_cache.table_exists?(table)
+          # schema_cache.columns_hash(table)[name].type
+
+          # when :date
+          # when :datetime, :timestamp, :time
+          # when :boolean
+          # when :integer
+          # when :float
+          # when :decimal
+          # else # :string
+
+          name = '_id' if name == 'id'
+
+          t = object.klass.fields[name].type
+
+          t.to_s.demodulize.underscore.to_sym
+        end
+
+        def evaluate(search, opts = {})
+          viz = Visitor.new
+          relation = @object.where(viz.accept(search.base))
+          if search.sorts.any?
+            ary_sorting = viz.accept(search.sorts)
+            sorting = {}
+            ary_sorting.each do |s|
+              sorting.merge! Hash[s.map { |k, d| [k.to_s == 'id' ? '_id' : k, d] }]
+            end
+            relation = relation.order_by(sorting)
+            # relation = relation.except(:order)
+            # .reorder(viz.accept(search.sorts))
+          end
+          # -- mongoid has different distinct method
+          # opts[:distinct] ? relation.distinct : relation
+          relation
+        end
+
+        def attribute_method?(str, klass = @klass)
+          exists = false
+          if ransackable_attribute?(str, klass)
+            exists = true
+          elsif (segments = str.split(/_/)).size > 1
+            remainder = []
+            found_assoc = nil
+            while !found_assoc && remainder.unshift(
+              segments.pop) && segments.size > 0 do
+              assoc, poly_class = unpolymorphize_association(
+                segments.join('_')
+                )
+              if found_assoc = get_association(assoc, klass)
+                exists = attribute_method?(remainder.join('_'),
+                  poly_class || found_assoc.klass
+                )
+              end
+            end
+          end
+          exists
+        end
+
+        def table_for(parent)
+          # parent.table
+          Ransack::Adapters::Mongoid::Table.new(parent)
+        end
+
+        def klassify(obj)
+          if Class === obj && obj.ancestors.include?(::Mongoid::Document)
+            obj
+          elsif obj.respond_to? :klass
+            obj.klass
+          elsif obj.respond_to? :base_klass
+            obj.base_klass
+          else
+            raise ArgumentError, "Don't know how to klassify #{obj}"
+          end
+        end
+
+      private
+
+        def get_parent_and_attribute_name(str, parent = @base)
+          attr_name = nil
+
+          if ransackable_attribute?(str, klassify(parent))
+            attr_name = str
+          elsif (segments = str.split(/_/)).size > 1
+            remainder = []
+            found_assoc = nil
+            while remainder.unshift(
+              segments.pop) && segments.size > 0 && !found_assoc do
+              assoc, klass = unpolymorphize_association(segments.join('_'))
+              if found_assoc = get_association(assoc, parent)
+                join = build_or_find_association(found_assoc.name, parent, klass)
+                parent, attr_name = get_parent_and_attribute_name(
+                  remainder.join('_'), join
+                  )
+              end
+            end
+          end
+
+          [parent, attr_name]
+        end
+
+        def get_association(str, parent = @base)
+          klass = klassify parent
+          ransackable_association?(str, klass) &&
+            klass.reflect_on_all_associations_all.detect { |a| a.name.to_s == str }
+        end
+
+        def join_dependency(relation)
+          if relation.respond_to?(:join_dependency) # Squeel will enable this
+            relation.join_dependency
+          else
+            build_join_dependency(relation)
+          end
+        end
+
+        # Checkout active_record/relation/query_methods.rb +build_joins+ for
+        # reference. Lots of duplicated code maybe we can avoid it
+        def build_join_dependency(relation)
+          buckets = relation.joins_values.group_by do |join|
+            case join
+            when String
+              Constants::STRING_JOIN
+            when Hash, Symbol, Array
+              Constants::ASSOCIATION_JOIN
+            when JoinDependency, JoinDependency::JoinAssociation
+              Constants::STASHED_JOIN
+            when Arel::Nodes::Join
+              Constants::JOIN_NODE
+            else
+              raise 'unknown class: %s' % join.class.name
+            end
+          end
+
+          association_joins = buckets[Constants::ASSOCIATION_JOIN] || []
+
+          stashed_association_joins = buckets[Constants::STASHED_JOIN] || []
+
+          join_nodes = buckets[Constants::JOIN_NODE] || []
+
+          string_joins = (buckets[Constants::STRING_JOIN] || [])
+            .map { |x| x.strip }
+            .uniq
+
+          join_list = relation.send :custom_join_ast,
+            relation.table.from(relation.table), string_joins
+
+          join_dependency = JoinDependency.new(
+            relation.klass, association_joins, join_list
+          )
+
+          join_nodes.each do |join|
+            join_dependency.alias_tracker.aliases[join.left.name.downcase] = 1
+          end
+
+          join_dependency # ActiveRecord::Associations::JoinDependency
+        end
+
+        # ActiveRecord method
+        def build_or_find_association(name, parent = @base, klass = nil)
+          found_association = @join_dependency.join_associations
+          .detect do |assoc|
+            assoc.reflection.name == name &&
+            assoc.parent == parent &&
+            (!klass || assoc.reflection.klass == klass)
+          end
+          unless found_association
+            @join_dependency.send(
+              :build,
+              Polyamorous::Join.new(name, @join_type, klass),
+              parent
+             )
+            found_association = @join_dependency.join_associations.last
+            # Leverage the stashed association functionality in AR
+            @object = @object.joins(found_association)
+          end
+          found_association
+        end
+
+      end
+    end
+  end
+end

data/lib/ransack/adapters/mongoid/inquiry_hash.rb

@@ -0,0 +1,23 @@
+module Ransack
+  module Adapters
+    module Mongoid
+      class InquiryHash < Hash
+
+        def or(other)
+          { '$or' => [ self, other] }.to_inquiry
+        end
+
+        def and(other)
+          { '$and' => [ self, other] }.to_inquiry
+        end
+
+      end
+    end
+  end
+end
+
+class Hash
+  def to_inquiry
+    ::Ransack::Adapters::Mongoid::InquiryHash[self]
+  end
+end

data/lib/ransack/adapters/mongoid/ransack/constants.rb

@@ -0,0 +1,88 @@
+module Ransack
+  module Constants
+    DERIVED_PREDICATES = [
+      [CONT, {
+        :arel_predicate => 'matches',
+        :formatter => proc { |v| "#{escape_regex(v)}" }
+        }
+      ],
+      ['not_cont', {
+        :arel_predicate => 'does_not_match',
+        :formatter => proc { |v| "#{escape_regex(v)}" }
+        }
+      ],
+      ['start', {
+        :arel_predicate => 'matches',
+        :formatter => proc { |v| "\\A#{escape_regex(v)}" }
+        }
+      ],
+      ['not_start', {
+        :arel_predicate => 'does_not_match',
+        :formatter => proc { |v| "\\A#{escape_regex(v)}" }
+        }
+      ],
+      ['end', {
+        :arel_predicate => 'matches',
+        :formatter => proc { |v| "#{escape_regex(v)}\\Z" }
+        }
+      ],
+      ['not_end', {
+        :arel_predicate => 'does_not_match',
+        :formatter => proc { |v| "#{escape_regex(v)}\\Z" }
+        }
+      ],
+      ['true', {
+        :arel_predicate => 'eq',
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| TRUE_VALUES.include?(v) }
+        }
+      ],
+      ['false', {
+        :arel_predicate => 'eq',
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| TRUE_VALUES.include?(v) },
+        :formatter => proc { |v| !v }
+        }
+      ],
+      ['present', {
+        :arel_predicate => proc { |v| v ? 'not_eq_all' : 'eq_any' },
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| [nil, ''] }
+        }
+      ],
+      ['blank', {
+        :arel_predicate => proc { |v| v ? 'eq_any' : 'not_eq_all' },
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| [nil, ''] }
+        }
+      ],
+      ['null', {
+        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v)},
+        :formatter => proc { |v| nil }
+        }
+      ],
+      ['not_null', {
+        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| nil } }
+      ]
+    ]
+
+  module_function
+    # does nothing
+    def escape_regex(unescaped)
+      Regexp.escape(unescaped)
+    end
+  end
+end

data/lib/ransack/adapters/mongoid/ransack/context.rb

@@ -0,0 +1,60 @@
+require 'ransack/visitor'
+
+module Ransack
+  class Context
+    # attr_reader :arel_visitor
+
+    class << self
+
+      def for_class(klass, options = {})
+        if klass.ancestors.include?(::Mongoid::Document)
+          Adapters::Mongoid::Context.new(klass, options)
+        end
+      end
+
+      def for_object(object, options = {})
+        case object
+        when ActiveRecord::Relation
+          Adapters::ActiveRecord::Context.new(object.klass, options)
+        end
+      end
+
+    end # << self
+
+    def initialize(object, options = {})
+      @object = relation_for(object)
+      @klass = @object.klass
+      # @join_dependency = join_dependency(@object)
+      # @join_type = options[:join_type] || Arel::OuterJoin
+      @search_key = options[:search_key] || Ransack.options[:search_key]
+
+      @base = @object.klass
+      # @engine = @base.arel_engine
+
+      # @default_table = Arel::Table.new(
+      #   @base.table_name, :as => @base.aliased_table_name, :engine => @engine
+      #   )
+      @bind_pairs = Hash.new do |hash, key|
+        parent, attr_name = get_parent_and_attribute_name(key.to_s)
+        if parent && attr_name
+          hash[key] = [parent, attr_name]
+        end
+      end
+    end
+
+    def klassify(obj)
+      if Class === obj && ::ActiveRecord::Base > obj
+        obj
+      elsif obj.respond_to? :klass
+        obj.klass
+      elsif obj.respond_to? :active_record  # Rails 3
+        obj.active_record
+      elsif obj.respond_to? :base_klass     # Rails 4
+        obj.base_klass
+      else
+        raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
+      end
+    end
+
+  end
+end

data/lib/ransack/adapters/mongoid/ransack/nodes/condition.rb

@@ -0,0 +1,27 @@
+module Ransack
+  module Nodes
+    class Condition
+
+      def arel_predicate
+        predicates = attributes.map do |attr|
+          attr.attr.send(
+            arel_predicate_for_attribute(attr),
+            formatted_values_for_attribute(attr)
+          )
+        end
+
+        if predicates.size > 1
+          case combinator
+          when 'and'
+            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
+          when 'or'
+            predicates.inject(&:or)
+          end
+        else
+          predicates.first
+        end
+      end
+
+    end # Condition
+  end
+end

data/lib/ransack/adapters/mongoid/ransack/translate.rb

@@ -0,0 +1,13 @@
+module Ransack
+  module Translate
+
+    def self.i18n_key(klass)
+      # if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+      #   klass.model_name.i18n_key.to_s.tr('.', '/')
+      # else
+      #   klass.model_name.i18n_key.to_s
+      # end
+      klass.model_name.i18n_key.to_s
+    end
+  end
+end

data/lib/ransack/adapters/mongoid/ransack/visitor.rb

@@ -0,0 +1,24 @@
+module Ransack
+  class Visitor
+    def visit_and(object)
+      nodes = object.values.map { |o| accept(o) }.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        nodes.inject(&:and)
+      else
+        nodes.first
+      end
+    end
+
+    def quoted?(object)
+      case object
+      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+        false
+      else
+        true
+      end
+    end
+
+  end
+end