ransack 1.8.3 → 2.3.0

data/lib/ransack/adapters/active_record/3.0/compat.rb

@@ -1,179 +0,0 @@
-# UGLY, UGLY MONKEY PATCHES FOR BACKWARDS COMPAT!!! AVERT YOUR EYES!!
-if Arel::Nodes::And < Arel::Nodes::Binary
-  class Ransack::Visitor
-    def visit_Ransack_Nodes_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
-  end
-end
-
-class ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
-  def table
-    Arel::Table.new(
-      table_name,
-      :as      => aliased_table_name,
-      :engine  => active_record.arel_engine,
-      :columns => active_record.columns
-      )
-  end
-end
-
-module Arel
-
-  class Table
-    alias :table_name :name
-
-    def [] name
-      ::Arel::Attribute.new self, name.to_sym
-    end
-  end
-
-  module Nodes
-    class Node
-      def not
-        Nodes::Not.new self
-      end
-    end
-
-    remove_const :And
-    class And < Arel::Nodes::Node
-      attr_reader :children
-
-      def initialize children, right = nil
-        unless Array === children
-          children = [children, right]
-        end
-        @children = children
-      end
-
-      def left
-        children.first
-      end
-
-      def right
-        children[1]
-      end
-    end
-
-    class NamedFunction < Arel::Nodes::Function
-      attr_accessor :name, :distinct
-
-      include Arel::Predications
-
-      def initialize name, expr, aliaz = nil
-        super(expr, aliaz)
-        @name = name
-        @distinct = false
-      end
-    end
-
-    class InfixOperation < Binary
-      include Arel::Expressions
-      include Arel::Predications
-
-      attr_reader :operator
-
-      def initialize operator, left, right
-        super(left, right)
-        @operator = operator
-      end
-    end
-
-    class Multiplication < InfixOperation
-      def initialize left, right
-        super(:*, left, right)
-      end
-    end
-
-    class Division < InfixOperation
-      def initialize left, right
-        super(:/, left, right)
-      end
-    end
-
-    class Addition < InfixOperation
-      def initialize left, right
-        super(:+, left, right)
-      end
-    end
-
-    class Subtraction < InfixOperation
-      def initialize left, right
-        super(:-, left, right)
-      end
-    end
-  end
-
-  module Visitors
-    class ToSql
-      def column_for attr
-        name    = attr.name.to_s
-        table   = attr.relation.table_name
-
-        column_cache[table][name]
-      end
-
-      def column_cache
-        @column_cache ||= Hash.new do |hash, key|
-          hash[key] = Hash[
-            @engine.connection
-            .columns(key, "#{key} Columns")
-            .map { |c| [c.name, c] }
-          ]
-        end
-      end
-
-      def visit_Arel_Nodes_InfixOperation o
-        "#{visit o.left} #{o.operator} #{visit o.right}"
-      end
-
-      def visit_Arel_Nodes_NamedFunction o
-        "#{
-          o.name
-          }(#{
-          o.distinct ? Ransack::Constants::DISTINCT : ''.freeze
-          }#{
-          o.expressions.map { |x| visit x }.join(', '.freeze)
-          })#{
-          o.alias ? " AS #{visit o.alias}" : ''.freeze
-          }"
-      end
-
-      def visit_Arel_Nodes_And o
-        o.children.map { |x| visit x }.join(' AND '.freeze)
-      end
-
-      def visit_Arel_Nodes_Not o
-        "NOT (#{visit o.expr})"
-      end
-
-      def visit_Arel_Nodes_Values o
-        "VALUES (#{
-        o.expressions.zip(o.columns)
-        .map { |value, attr|
-          if Nodes::SqlLiteral === value
-            visit_Arel_Nodes_SqlLiteral value
-          else
-            quote(value, attr && column_for(attr))
-          end
-        }
-        .join(', '.freeze)
-        })"
-      end
-    end
-  end
-
-  module Predications
-    def as other
-      Nodes::As.new self, Nodes::SqlLiteral.new(other)
-    end
-  end
-
-end

data/lib/ransack/adapters/active_record/3.0/context.rb

@@ -1,203 +0,0 @@
-require 'ransack/context'
-require 'polyamorous'
-require 'ransack/adapters/active_record/3.0/compat'
-
-module Ransack
-
-  module Adapters
-    module ActiveRecord
-      class Context < ::Ransack::Context
-
-        # Because the AR::Associations namespace is insane
-        if defined? ::ActiveRecord::Associations::ClassMethods::JoinDependency
-          JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
-        end
-
-        # Redefine a few things for ActiveRecord 3.0.
-
-        def initialize(object, options = {})
-          super
-          @arel_visitor = Arel::Visitors.visitor_for @engine
-        end
-
-        def relation_for(object)
-          object.scoped
-        end
-
-        def evaluate(search, opts = {})
-          viz = Visitor.new
-          relation = @object.where(viz.accept(search.base))
-          if search.sorts.any?
-            relation = relation.except(:order)
-            .reorder(viz.accept(search.sorts))
-          end
-          if opts[:distinct]
-            relation.select(Constants::DISTINCT + @klass.quoted_table_name +
-              Constants::DOT_ASTERIX)
-          else
-            relation
-          end
-        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(Constants::UNDERSCORE)
-                )
-              if found_assoc = get_association(assoc, klass)
-                exists = attribute_method?(
-                  remainder.join(Constants::UNDERSCORE),
-                  poly_class || found_assoc.klass
-                  )
-              end
-            end
-          end
-
-          exists
-        end
-
-        def table_for(parent)
-          parent.table
-        end
-
-        def type_for(attr)
-          return nil unless attr && attr.valid?
-          klassify(attr.parent)
-          .columns_hash[attr.arel_attribute.name.to_s]
-          .type
-        end
-
-        # All dependent JoinAssociation items used in the search query
-        #
-        def join_associations
-          @join_dependency.join_associations
-        end
-
-        def join_sources
-          raise NotImplementedError,
-          "ActiveRecord 3.0 does not use join_sources or support joining relations with Arel::Join nodes. Use join_associations."
-        end
-
-        def alias_tracker
-          raise NotImplementedError,
-          "ActiveRecord 3.0 does not have an alias tracker"
-        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(Constants::UNDERSCORE)
-                )
-              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(Constants::UNDERSCORE), 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.detect { |a| a.name.to_s == str }
-        end
-
-        def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Polyamorous enables this
-            relation.join_dependency
-          else
-            build_join_dependency(relation)
-          end
-        end
-
-        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 ::ActiveRecord::Associations::ClassMethods::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(&:strip).uniq
-
-          join_list = relation.send :custom_join_sql, (string_joins + join_nodes)
-
-          join_dependency = JoinDependency.new(
-            relation.klass,
-            association_joins,
-            join_list
-          )
-
-          join_nodes.each do |join|
-            join_dependency.table_aliases[join.left.name.downcase] = 1
-          end
-
-          join_dependency.graft(*stashed_association_joins)
-        end
-
-        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
-
-            default_conditions = found_association.active_record.scoped.arel.constraints
-            if default_conditions.any?
-              and_default_conditions = "AND #{default_conditions.reduce(&:and).to_sql}"
-            end
-
-            # Leverage the stashed association functionality in AR
-            @object = @object.joins(found_association).joins(and_default_conditions)
-          end
-
-          found_association
-        end
-
-      end
-    end
-  end
-end

data/lib/ransack/adapters/active_record/3.1/context.rb

@@ -1,212 +0,0 @@
-require 'ransack/context'
-require 'ransack/adapters/active_record/compat'
-require 'polyamorous'
-
-module Ransack
-  module Adapters
-    module ActiveRecord
-      class Context < ::Ransack::Context
-
-        # Redefine a few things for ActiveRecord 3.1.
-
-        def initialize(object, options = {})
-          super
-          @arel_visitor = Arel::Visitors.visitor_for @engine
-        end
-
-        def relation_for(object)
-          object.scoped
-        end
-
-        def evaluate(search, opts = {})
-          viz = Visitor.new
-          relation = @object.where(viz.accept(search.base))
-          if search.sorts.any?
-            relation = relation.except(:order)
-              .reorder(viz.accept(search.sorts))
-          end
-          if opts[:distinct]
-            relation.select(Constants::DISTINCT + @klass.quoted_table_name +
-              Constants::DOT_ASTERIX)
-          else
-            relation
-          end
-        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(Constants::UNDERSCORE)
-                )
-              if found_assoc = get_association(assoc, klass)
-                exists = attribute_method?(
-                  remainder.join(Constants::UNDERSCORE),
-                  poly_class || found_assoc.klass
-                  )
-              end
-            end
-          end
-
-          exists
-        end
-
-        def table_for(parent)
-          parent.table
-        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
-
-          unless @engine.connection_pool.table_exists?(table)
-            raise "No table named #{table} exists"
-          end
-
-          @engine.connection_pool.columns_hash[table][name].type
-        end
-
-        def join_associations
-          @join_dependency.join_associations
-        end
-
-        # All dependent Arel::Join nodes used in the search query
-        #
-        # This could otherwise be done as `@object.arel.join_sources`, except
-        # that ActiveRecord's build_joins sets up its own JoinDependency.
-        # This extracts what we need to access the joins using our existing
-        # JoinDependency to track table aliases.
-        #
-        def join_sources
-          base = Arel::SelectManager.new(@object.engine, @object.table)
-          @object.joins_values.each do |assoc|
-            next unless assoc.is_a?(JoinDependency::JoinAssociation)
-            assoc.join_to(base)
-          end
-          base.join_sources
-        end
-
-        def alias_tracker
-          @join_dependency.alias_tracker
-        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(Constants::UNDERSCORE)
-                )
-              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(Constants::UNDERSCORE), 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.detect { |a| a.name.to_s == str }
-        end
-
-        def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Polyamorous enables this
-            relation.join_dependency
-          else
-            build_join_dependency(relation)
-          end
-        end
-
-        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::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(&: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.graft(*stashed_association_joins)
-        end
-
-        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
-
-            default_conditions = found_association.active_record.scoped.arel.constraints
-            if default_conditions.any?
-              and_default_conditions = "AND #{default_conditions.reduce(&:and).to_sql}"
-            end
-
-            # Leverage the stashed association functionality in AR
-            @object = @object.joins(found_association).joins(and_default_conditions)
-          end
-
-          found_association
-        end
-
-      end
-    end
-  end
-end

data/lib/ransack/adapters/active_record/3.2/context.rb

@@ -1,44 +0,0 @@
-require 'ransack/context'
-require 'ransack/adapters/active_record/3.1/context'
-require 'ransack/adapters/active_record/compat'
-require 'polyamorous'
-
-module Ransack
-  module Adapters
-    module ActiveRecord
-      class Context < ::Ransack::Context
-
-        # Redefine a few things for ActiveRecord 3.2.
-
-        def initialize(object, options = {})
-          super
-          @arel_visitor = @engine.connection.visitor
-        end
-
-        def relation_for(object)
-          object.scoped
-        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
-        end
-
-        def evaluate(search, opts = {})
-          viz = Visitor.new
-          relation = @object.where(viz.accept(search.base))
-          if search.sorts.any?
-            relation = relation.except(:order).reorder(viz.accept(search.sorts))
-          end
-          opts[:distinct] ? relation.uniq : relation
-        end
-
-      end
-    end
-  end
-end

data/lib/ransack/adapters/active_record/compat.rb

@@ -1,14 +0,0 @@
-module Arel
-
-  module Visitors
-
-    class DepthFirst < Visitor
-
-      unless method_defined?(:visit_Arel_Nodes_InfixOperation)
-        alias :visit_Arel_Nodes_InfixOperation :binary
-      end
-
-    end
-
-  end
-end

data/lib/ransack/adapters/mongoid/attributes/attribute.rb

@@ -1,37 +0,0 @@
-require 'ransack/adapters/mongoid/attributes/predications'
-require 'ransack/adapters/mongoid/attributes/order_predications'
-
-module Ransack
-  module Adapters
-    module Mongoid
-      module Attributes
-        class Attribute < Struct.new :relation, :name
-          # include Arel::Expressions
-          # include Arel::Predications
-          # include Arel::AliasPredication
-          # include Arel::OrderPredications
-          # include Arel::Math
-
-          include ::Ransack::Adapters::Mongoid::Attributes::Predications
-          include ::Ransack::Adapters::Mongoid::Attributes::OrderPredications
-
-          ###
-          # Create a node for lowering this attribute
-          def lower
-            relation.lower self
-          end
-        end
-
-        class String    < Attribute; end
-        class Time      < Attribute; end
-        class Boolean   < Attribute; end
-        class Decimal   < Attribute; end
-        class Float     < Attribute; end
-        class Integer   < Attribute; end
-        class Undefined < Attribute; end
-      end
-
-      Attribute = Attributes::Attribute
-    end # Attributes
-  end
-end

data/lib/ransack/adapters/mongoid/attributes/order_predications.rb

@@ -1,17 +0,0 @@
-module Ransack
-  module Adapters
-    module Mongoid
-      module Attributes
-        module OrderPredications
-          def asc
-            { name => :asc }
-          end
-
-          def desc
-            { name => :desc }
-          end
-        end
-      end
-    end
-  end
-end