ransack 1.8.8 → 1.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f61f4b16a29defa380a26e7c29e3470bb61eb98fee71fb2b506b1b7c377f4995
-  data.tar.gz: a08063d09eae00edf1f62dfdcb9df19db195fded6d951a0ddb6ff0dd63885095
+  metadata.gz: 07c532ea4c1ef918e082ef7877a6fe08fb1bb881860ab28223c3c88da1143883
+  data.tar.gz: 6313bf0d848b95b5eb4d6b653c19dbc88a119da2e5d4979b6fcc2ee9a466d00b
 SHA512:
-  metadata.gz: 7075b5593e9931a4f5df153e04e2069dbb3b7e65f6463941b5dcfed0abfe6c5eba685b6db246755a98c8268e412d8088855495d14badcb75630c9c9eec86bb81
-  data.tar.gz: 5243186d40445ea7e1087cf1e655139718eca9089b3de1a52780b4aee71a200f7ac241d27c93821703bbe17872f05e740f12669be8cf129d3f1869967f04e2e2
+  metadata.gz: 7e3a42c855d5e1918ed5dfb71e80d236cd5ac8b8e7b9a46d42d0b181e68ac1a6518a9f61f21f844175db2dba97dd66117a356e8a6feba1a8779f6eedc0cb13dc
+  data.tar.gz: b8d4bb5978ca13683932922a1ac80a619d2890f871ed56f11743e0aba863a229af33eb7ddf617650fb04fab7548c55703d73ddd77c9ef72fa6a5c34801d73c74

data/.travis.yml

@@ -11,6 +11,10 @@ env:
   - RAILS=5-2-stable DB=mysql
   - RAILS=5-2-stable DB=postgres
 
+  - RAILS=v5.2.0 DB=sqlite3
+  - RAILS=v5.2.0 DB=mysql
+  - RAILS=v5.2.0 DB=postgres
+
   - RAILS=5-0-stable DB=sqlite3
   - RAILS=5-0-stable DB=mysql
   - RAILS=5-0-stable DB=postgres
@@ -18,7 +22,11 @@ env:
   - RAILS=4-2-stable DB=sqlite3
   - RAILS=4-2-stable DB=mysql
   - RAILS=4-2-stable DB=postgres
-
+matrix:
+  allow_failures:
+    - env: RAILS=5-2-stable DB=sqlite3
+    - env: RAILS=5-2-stable DB=mysql
+    - env: RAILS=5-2-stable DB=postgres
 before_script:
   - mysql -e 'create database ransack collate utf8_general_ci;'
   - mysql -e 'use ransack;show variables like "%character%";show variables like "%collation%";'

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## Version 1.8.9 - 2018-08-09
+
+* Locked Active Record compatibiity at 5.1.0
+
 ## Version 1.8.8 - 2018-03-16
 * Fix multiple database support
   PR [#893](https://github.com/activerecord-hackery/ransack/pull/893)

data/Gemfile

@@ -5,12 +5,6 @@ gem 'rake'
 
 rails = ENV['RAILS'] || '5-0-stable'
 
-if rails == 'master'
-  gem 'polyamorous', github: 'activerecord-hackery/polyamorous'
-else
-  gem 'polyamorous', '~> 1.3'
-end
-
 gem 'pry'
 
 # Provide timezone information on Windows
@@ -28,6 +22,9 @@ when /^v/ # A tagged version
     gem 'activerecord', require: false
     gem 'actionpack'
   end
+  if rails == 'v5.2.0'
+    gem 'mysql2', '~> 0.4.4'
+  end
 else
   git 'git://github.com/rails/rails.git', :branch => rails do
     gem 'activesupport'

data/README.md

@@ -1,5 +1,28 @@
 # Ransack
 
+### Maintainer Wanted
+
+A note from [Sean](https://github.com/seanfcarroll).
+Ransack is a fantastic gem, and a key part of many Rails projects. It is also a core component of [ActiveAdmin](https://github.com/activeadmin/activeadmin) and generally a great way to add fairly complex search and filtering without having to resort to external services, such as Elasticsearch.
+
+In my humble opinion, Ransack can be much more, if it does a bit less. What I mean is that the API vector of Ransack is quite large, and really has been issue-driven. There are complications with Polymorphic relations, complex joins and MongoDB. It's not clear sometimes if there is a bug or not.
+
+I was hoping to lead Ransack to version 2.0, and in my opinion this would have included:
+
+- Absorbing Polyamorous
+- Splitting MongoDB support into a seperate gem
+- Dropping support for older Rails versions; strictly follow the [Rails support policy](http://guides.rubyonrails.org/maintenance_policy.html). This is important as the codebase is littered with code for de-supported Rails versions
+- Add a generator to build in Ransack with a scaffold
+- Generate tests for Ransack-enabled applications
+- Update the Wiki / docs with lots of examples of 'how-to', questions are the majority of issues on Ransack
+- Increase supported translations
+
+Unfortunately I am quite occupied at present with several projects, including [crowdAI](https://github.com/crowdAI/crowdai), and I will need to step down as a maintainer. I have also posted it [here](https://github.com/pickhardt/maintainers-wanted).
+
+If you want to step up, please contact me on gmail as **sfcarroll**
+
+
+
 [![Build Status](https://travis-ci.org/activerecord-hackery/ransack.svg)](https://travis-ci.org/activerecord-hackery/ransack)
 [![Gem Version](https://badge.fury.io/rb/ransack.svg)](http://badge.fury.io/rb/ransack)
 [![Code Climate](https://codeclimate.com/github/activerecord-hackery/ransack/badges/gpa.svg)](https://codeclimate.com/github/activerecord-hackery/ransack)
@@ -513,6 +536,20 @@ def index
 end
 ```
 
+Another method to approach this when using Postgresql is to use ActiveRecords's `.includes` in combination with `.group` instead of `distinct: true`.
+
+For example:
+```ruby
+def index
+  @q = Person.ransack(params[:q])
+  @people = @q.result
+              .group('persons.id')
+              .includes(:articles)
+              .page(params[:page])
+end
+
+```
+
 A final way of last resort is to call `to_a.uniq` on the collection at the end
 with the caveat that the de-duping is taking place in Ruby instead of in SQL,
 which is potentially slower and uses more memory, and that it may display

data/lib/polyamorous.rb

@@ -0,0 +1,55 @@
+if defined?(::ActiveRecord)
+  module Polyamorous
+    if defined?(Arel::InnerJoin)
+      InnerJoin = Arel::InnerJoin
+      OuterJoin = Arel::OuterJoin
+    else
+      InnerJoin = Arel::Nodes::InnerJoin
+      OuterJoin = Arel::Nodes::OuterJoin
+    end
+
+    if defined?(::ActiveRecord::Associations::JoinDependency)
+      JoinDependency  = ::ActiveRecord::Associations::JoinDependency
+      JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+      JoinBase = ::ActiveRecord::Associations::JoinDependency::JoinBase
+    else
+      JoinDependency  = ::ActiveRecord::Associations::ClassMethods::JoinDependency
+      JoinAssociation = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+      JoinBase = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
+    end
+  end
+
+  require 'polyamorous/tree_node'
+  require 'polyamorous/join'
+  require 'polyamorous/swapping_reflection_class'
+
+  ar_version = ::ActiveRecord::VERSION::STRING[0,3]
+  ar_version = '3_and_4.0' if ar_version < '4.1'
+  ar_version = ::ActiveRecord::VERSION::STRING[0,5] if ar_version == '5.2'
+
+  method, ruby_version =
+    if RUBY_VERSION >= '2.0' && ar_version >= '4.1'
+      # Ruby 2; we can use `prepend` to patch Active Record cleanly.
+      [:prepend, '2']
+    else
+      # Ruby 1.9; we must use `alias_method` to patch Active Record.
+      [:include, '1.9']
+    end
+
+  %w(join_association join_dependency).each do |file|
+    require "polyamorous/activerecord_#{ar_version}_ruby_#{ruby_version}/#{file}"
+  end
+
+  Polyamorous::JoinDependency.send(method, Polyamorous::JoinDependencyExtensions)
+  if method == :prepend
+    Polyamorous::JoinDependency.singleton_class
+    .send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
+  end
+  Polyamorous::JoinAssociation.send(method, Polyamorous::JoinAssociationExtensions)
+
+  Polyamorous::JoinBase.class_eval do
+    if method_defined?(:active_record)
+      alias_method :base_klass, :active_record
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# 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

@@ -0,0 +1,96 @@
+# 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

@@ -0,0 +1,2 @@
+# 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

@@ -0,0 +1,4 @@
+# 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

@@ -0,0 +1,2 @@
+# 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

@@ -0,0 +1,3 @@
+# 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,87 @@
+# 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