ransack 1.8.10 → 2.0.0

data/lib/polyamorous/activerecord_3_and_4.0_ruby_1.9/join_association.rb

@@ -1,76 +0,0 @@
-# active_record_3_and_4.0_ruby_1.9/join_association.rb
-module Polyamorous
-  module JoinAssociationExtensions
-    include SwappingReflectionClass
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :initialize, :polymorphism
-        alias_method :equality_without_polymorphism, :==
-        alias_method :==, :equality_with_polymorphism
-        if base.method_defined?(:active_record)
-          alias_method :base_klass, :active_record
-        end
-
-        if ActiveRecord::VERSION::STRING =~ /^3\.0\./
-          alias_method_chain :association_join, :polymorphism
-        else
-          alias_method_chain :build_constraint, :polymorphism
-        end
-      end
-    end
-
-    def initialize_with_polymorphism(
-      reflection, join_dependency, parent = nil, polymorphic_class = nil
-    )
-      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
-        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
-          initialize_without_polymorphism(reflection, join_dependency, parent)
-          self.reflection.options[:polymorphic] = true
-        end
-      else
-        initialize_without_polymorphism(reflection, join_dependency, parent)
-      end
-    end
-
-    def equality_with_polymorphism(other)
-      equality_without_polymorphism(other) && base_klass == other.base_klass
-    end
-
-    def build_constraint_with_polymorphism(
-      reflection, table, key, foreign_table, foreign_key
-    )
-      if reflection.options[:polymorphic]
-        build_constraint_without_polymorphism(
-          reflection, table, key, foreign_table, foreign_key
-        )
-        .and(foreign_table[reflection.foreign_type].eq(reflection.klass.name))
-      else
-        build_constraint_without_polymorphism(
-          reflection, table, key, foreign_table, foreign_key
-        )
-      end
-    end
-
-    def association_join_with_polymorphism
-      return @join if @Join
-      @join = association_join_without_polymorphism
-      if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-        aliased_table = Arel::Table.new(
-          table_name,
-          as: @aliased_table_name,
-          engine: arel_engine,
-          columns: klass.columns
-        )
-        parent_table = Arel::Table.new(
-          parent.table_name,
-          as: parent.aliased_table_name,
-          engine: arel_engine,
-          columns: parent.base_klass.columns
-        )
-        @join << parent_table[reflection.options[:foreign_type]]
-                 .eq(reflection.klass.name)
-      end
-      @join
-    end
-  end
-end

data/lib/polyamorous/activerecord_3_and_4.0_ruby_1.9/join_dependency.rb

@@ -1,96 +0,0 @@
-# active_record_3_and_4.0_ruby_1.9/join_dependency.rb
-module Polyamorous
-  module JoinDependencyExtensions
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :build, :polymorphism
-        alias_method_chain :graft, :polymorphism
-        if base.method_defined?(:active_record)
-          alias_method :base_klass, :active_record
-        end
-      end
-    end
-
-    def graft_with_polymorphism(*associations)
-      associations.each do |association|
-        unless join_associations.detect { |a| association == a }
-          if association.reflection.options[:polymorphic]
-            build(
-              Join.new(
-                association.reflection.name,
-                association.join_type,
-                association.reflection.klass
-                ),
-              association.find_parent_in(self) || join_base,
-              association.join_type
-              )
-          else
-            build(
-              association.reflection.name,
-              association.find_parent_in(self) || join_base,
-              association.join_type
-              )
-          end
-        end
-      end
-      self
-    end
-
-    if ActiveRecord::VERSION::STRING =~ /^3\.0\./
-      def _join_parts
-        @joins
-      end
-    else
-      def _join_parts
-        @join_parts
-      end
-    end
-
-    def build_with_polymorphism(
-      associations, parent = nil, join_type = InnerJoin
-    )
-      case associations
-      when Join
-        parent ||= _join_parts.last
-        reflection = parent.reflections[associations.name] or
-          raise ::ActiveRecord::ConfigurationError,
-            "Association named '#{associations.name
-            }' was not found; perhaps you misspelled it?"
-
-        unless join_association = find_join_association_respecting_polymorphism(
-          reflection, parent, associations.klass
-        )
-          @reflections << reflection
-          join_association = build_join_association_respecting_polymorphism(
-            reflection, parent, associations.klass
-          )
-          join_association.join_type = associations.type
-          _join_parts << join_association
-          cache_joined_association(join_association)
-        end
-
-        join_association
-      else
-        build_without_polymorphism(associations, parent, join_type)
-      end
-    end
-
-    def find_join_association_respecting_polymorphism(reflection, parent, klass)
-      if association = find_join_association(reflection, parent)
-        unless reflection.options[:polymorphic]
-          association
-        else
-          association if association.base_klass == klass
-        end
-      end
-    end
-
-    def build_join_association_respecting_polymorphism(reflection, parent, klass)
-      if reflection.options[:polymorphic] && klass
-        JoinAssociation.new(reflection, self, parent, klass)
-      else
-        JoinAssociation.new(reflection, self, parent)
-      end
-    end
-  end
-end

data/lib/polyamorous/activerecord_4.1_ruby_1.9/join_association.rb

@@ -1,2 +0,0 @@
-# active_record_4.1_ruby_1.9/join_association.rb
-require 'polyamorous/activerecord_4.2_ruby_1.9/join_association'

data/lib/polyamorous/activerecord_4.1_ruby_1.9/join_dependency.rb

@@ -1,4 +0,0 @@
-# active_record_4.1_ruby_1.9/join_dependency.rb
-require 'polyamorous/activerecord_4.2_ruby_2/join_dependency'
-require 'polyamorous/activerecord_4.2_ruby_1.9/join_dependency'
-require 'polyamorous/activerecord_4.1_ruby_2/make_polyamorous_inner_joins'

data/lib/polyamorous/activerecord_4.1_ruby_2/join_association.rb

@@ -1,2 +0,0 @@
-# active_record_4.1_ruby_2/join_association.rb
-require 'polyamorous/activerecord_5.0_ruby_2/join_association'

data/lib/polyamorous/activerecord_4.1_ruby_2/join_dependency.rb

@@ -1,3 +0,0 @@
-# active_record_4.1_ruby_2/join_dependency.rb
-require 'polyamorous/activerecord_4.2_ruby_2/join_dependency'
-require 'polyamorous/activerecord_4.1_ruby_2/make_polyamorous_inner_joins'

data/lib/polyamorous/activerecord_4.1_ruby_2/make_polyamorous_inner_joins.rb

@@ -1,14 +0,0 @@
-module Polyamorous
-  module JoinDependencyExtensions
-    # Replaces ActiveRecord::Associations::JoinDependency#make_inner_joins
-    #
-    def make_polyamorous_inner_joins(parent, child)
-      make_constraints(
-        parent, child, child.tables, child.join_type || Arel::Nodes::InnerJoin
-      )
-      .concat child.children.flat_map { |c|
-        make_polyamorous_inner_joins(child, c)
-      }
-    end
-  end
-end

data/lib/polyamorous/activerecord_4.2_ruby_1.9/join_association.rb

@@ -1,46 +0,0 @@
-# active_record_4.2_ruby_1.9/join_association.rb
-module Polyamorous
-  module JoinAssociationExtensions
-    include SwappingReflectionClass
-    def self.included(base)
-      base.class_eval do
-        attr_reader :join_type
-        alias_method_chain :initialize, :polymorphism
-        alias_method_chain :build_constraint, :polymorphism
-      end
-    end
-
-    def initialize_with_polymorphism(reflection, children,
-      polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
-      @join_type = join_type
-      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
-        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
-          initialize_without_polymorphism(reflection, children)
-          self.reflection.options[:polymorphic] = true
-        end
-      else
-        initialize_without_polymorphism(reflection, children)
-      end
-    end
-
-    # Reference https://github.com/rails/rails/commit/9b15db51b78028bfecdb85595624de4b838adbd1
-    def ==(other)
-      base_klass == other.base_klass
-    end
-
-    def build_constraint_with_polymorphism(
-      klass, table, key, foreign_table, foreign_key
-    )
-      if reflection.polymorphic?
-        build_constraint_without_polymorphism(
-          klass, table, key, foreign_table, foreign_key
-        )
-        .and(foreign_table[reflection.foreign_type].eq(reflection.klass.name))
-      else
-        build_constraint_without_polymorphism(
-          klass, table, key, foreign_table, foreign_key
-        )
-      end
-    end
-  end
-end

data/lib/polyamorous/activerecord_4.2_ruby_1.9/join_dependency.rb

@@ -1,87 +0,0 @@
-# active_record_4.2_ruby_1.9/join_dependency.rb
-require 'polyamorous/activerecord_4.2_ruby_2/join_dependency'
-
-module Polyamorous
-  module JoinDependencyExtensions
-    def self.included(base)
-      base.extend ClassMethods
-      base.class_eval do
-        class << self
-          alias_method :walk_tree_without_polymorphism, :walk_tree
-          alias_method :walk_tree, :walk_tree_with_polymorphism
-        end
-
-        alias_method :build_without_polymorphism, :build
-        alias_method :build, :build_with_polymorphism
-
-        alias_method :join_constraints_without_polymorphism, :join_constraints
-        alias_method :join_constraints, :join_constraints_with_polymorphism
-      end
-    end
-
-    # Replaces ActiveRecord::Associations::JoinDependency#build
-    #
-    def build_with_polymorphism(associations, base_klass)
-      associations.map do |name, right|
-        if name.is_a? Join
-          reflection = find_reflection base_klass, name.name
-          reflection.check_validity!
-          klass = if reflection.polymorphic?
-            name.klass || base_klass
-          else
-            reflection.klass
-          end
-          JoinAssociation.new(reflection, build(right, klass), name.klass, name.type)
-        else
-          reflection = find_reflection base_klass, name
-          reflection.check_validity!
-          if reflection.polymorphic?
-            raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
-          end
-          JoinAssociation.new reflection, build(right, reflection.klass)
-        end
-      end
-    end
-
-    # Replaces ActiveRecord::Associations::JoinDependency#join_constraints
-    # to call #make_polyamorous_inner_joins instead of #make_inner_joins
-    #
-    def join_constraints_with_polymorphism(outer_joins)
-      joins = join_root.children.flat_map { |child|
-        make_polyamorous_inner_joins join_root, child
-      }
-      joins.concat outer_joins.flat_map { |oj|
-        if join_root.match? oj.join_root
-          walk(join_root, oj.join_root)
-        else
-          oj.join_root.children.flat_map { |child|
-            make_outer_joins(oj.join_root, child)
-          }
-        end
-      }
-    end
-
-    module ClassMethods
-      # Replaces ActiveRecord::Associations::JoinDependency#self.walk_tree
-      #
-      def walk_tree_with_polymorphism(associations, hash)
-        case associations
-        when TreeNode
-          associations.add_to_tree(hash)
-        when Hash
-          associations.each do |k, v|
-            cache =
-              if TreeNode === k
-                k.add_to_tree(hash)
-              else
-                hash[k] ||= {}
-              end
-            walk_tree(v, cache)
-         end
-        else
-          walk_tree_without_polymorphism(associations, hash)
-        end
-      end
-    end
-  end
-end

data/lib/polyamorous/activerecord_4.2_ruby_2/join_association.rb

@@ -1,2 +0,0 @@
-# active_record_4.2_ruby_2/join_association.rb
-require 'polyamorous/activerecord_5.0_ruby_2/join_association'

data/lib/polyamorous/activerecord_4.2_ruby_2/join_dependency.rb

@@ -1,24 +0,0 @@
-# active_record_4.2_ruby_2/join_dependency.rb
-require 'polyamorous/activerecord_5.0_ruby_2/join_dependency'
-
-module Polyamorous
-  module JoinDependencyExtensions
-    # Replaces ActiveRecord::Associations::JoinDependency#join_constraints
-    # to call #make_polyamorous_inner_joins instead of #make_inner_joins.
-    #
-    def join_constraints(outer_joins)
-      joins = join_root.children.flat_map { |child|
-        make_polyamorous_inner_joins join_root, child
-      }
-      joins.concat outer_joins.flat_map { |oj|
-        if join_root.match? oj.join_root
-          walk(join_root, oj.join_root)
-        else
-          oj.join_root.children.flat_map { |child|
-            make_outer_joins(oj.join_root, child)
-          }
-        end
-      }
-    end
-  end
-end

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

@@ -1,173 +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
-      nodes.inject(&:and)
-    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