ransack 2.1.1 → 2.5.0

data/lib/ransack/search.rb

@@ -15,9 +15,11 @@ module Ransack
              :translate, :to => :base
 
     def initialize(object, params = {}, options = {})
+      strip_whitespace = options.fetch(:strip_whitespace, Ransack.options[:strip_whitespace])
       params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
       if params.is_a? Hash
         params = params.dup
+        params = params.transform_values { |v| v.is_a?(String) && strip_whitespace ? v.strip : v }
         params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
       else
         params = {}
@@ -29,6 +31,7 @@ module Ransack
         )
       @scope_args = {}
       @sorts ||= []
+      @ignore_unknown_conditions = options[:ignore_unknown_conditions] == false ? false : true
       build(params.with_indifferent_access)
     end
 
@@ -44,7 +47,7 @@ module Ransack
           base.send("#{key}=", value)
         elsif @context.ransackable_scope?(key, @context.object)
           add_scope(key, value)
-        elsif !Ransack.options[:ignore_unknown_conditions]
+        elsif !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
           raise ArgumentError, "Invalid search term #{key}"
         end
       end

data/lib/ransack/translate.rb

@@ -6,151 +6,151 @@ I18n.load_path += Dir[
 
 module Ransack
   module Translate
-    def self.word(key, options = {})
-      I18n.translate(:"ransack.#{key}", :default => key.to_s)
-    end
-
-    def self.predicate(key, options = {})
-      I18n.translate(:"ransack.predicates.#{key}", :default => key.to_s)
-    end
-
-    def self.attribute(key, options = {})
-      unless context = options.delete(:context)
-        raise ArgumentError, "A context is required to translate attributes"
+    class << self
+      def word(key, options = {})
+        I18n.translate(:"ransack.#{key}", default: key.to_s)
       end
 
-      original_name = key.to_s
-      base_class = context.klass
-      base_ancestors = base_class.ancestors.select {
-        |x| x.respond_to?(:model_name)
-      }
-      attributes_str = original_name.dup # will be modified by ⬇
-      predicate = Predicate.detect_and_strip_from_string!(attributes_str)
-      attribute_names = attributes_str.split(/_and_|_or_/)
-      combinator = attributes_str.match(/_and_/) ? :and : :or
-      defaults = base_ancestors.map do |klass|
-        "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
+      def predicate(key, options = {})
+        I18n.translate(:"ransack.predicates.#{key}", default: key.to_s)
       end
 
-      translated_names = attribute_names.map do |name|
-        attribute_name(context, name, options[:include_associations])
-      end
+      def attribute(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate attributes"
+        end
 
-      interpolations = {
-        :attributes => translated_names.join(" #{Translate.word(combinator)} ")
-      }
+        original_name = key.to_s
+        base_class = context.klass
+        base_ancestors = base_class.ancestors.select {
+          |x| x.respond_to?(:model_name)
+        }
+        attributes_str = original_name.dup # will be modified by ⬇
+        predicate = Predicate.detect_and_strip_from_string!(attributes_str)
+        attribute_names = attributes_str.split(/_and_|_or_/)
+        combinator = attributes_str =~ /_and_/ ? :and : :or
+        defaults = base_ancestors.map do |klass|
+          "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
+        end
+        defaults << options.delete(:default) if options[:default]
 
-      if predicate
-        defaults << "%{attributes} %{predicate}".freeze
-        interpolations[:predicate] = Translate.predicate(predicate)
-      else
-        defaults << "%{attributes}".freeze
-      end
+        translated_names = attribute_names.map do |name|
+          attribute_name(context, name, options[:include_associations])
+        end
 
-      defaults << options.delete(:default) if options[:default]
-      options.reverse_merge! :count => 1, :default => defaults
-      I18n.translate(defaults.shift, options.merge(interpolations))
-    end
+        interpolations = {
+          attributes: translated_names.join(" #{Translate.word(combinator)} ")
+        }
 
-    def self.association(key, options = {})
-      unless context = options.delete(:context)
-        raise ArgumentError, "A context is required to translate associations"
+        if predicate
+          defaults << "%{attributes} %{predicate}".freeze
+          interpolations[:predicate] = Translate.predicate(predicate)
+        else
+          defaults << "%{attributes}".freeze
+        end
+
+        options.reverse_merge! count: 1, default: defaults
+        I18n.translate(defaults.shift, **options.merge(interpolations))
       end
 
-      defaults =
-        if key.blank?
-          [:"ransack.models.#{i18n_key(context.klass)}",
-           :"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"]
-        else
-          [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+      def association(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate associations"
         end
-      defaults << context.traverse(key).model_name.human
-      options = { :count => 1, :default => defaults }
-      I18n.translate(defaults.shift, options)
-    end
 
-  private
+        defaults =
+          if key.blank?
+            [:"ransack.models.#{i18n_key(context.klass)}",
+             :"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"]
+          else
+            [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+          end
+        defaults << context.traverse(key).model_name.human
+        options = { :count => 1, :default => defaults }
+        I18n.translate(defaults.shift, **options)
+      end
 
-    def self.attribute_name(context, name, include_associations = nil)
-      @context, @name = context, name
-      @assoc_path = context.association_path(name)
-      @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
-      associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
-      @include_associated = include_associations && associated_class
+      private
 
-      defaults = default_attribute_name << fallback_args
-      options = { :count => 1, :default => defaults }
-      interpolations = build_interpolations(associated_class)
+      def attribute_name(context, name, include_associations = nil)
+        @context, @name = context, name
+        @assoc_path = context.association_path(name)
+        @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
+        associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
+        @include_associated = include_associations && associated_class
 
-      I18n.translate(defaults.shift, options.merge(interpolations))
-    end
+        defaults = default_attribute_name << fallback_args
+        options = { count: 1, default: defaults }
+        interpolations = build_interpolations(associated_class)
 
-    def self.default_attribute_name
-      ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
-    end
+        I18n.translate(defaults.shift, **options.merge(interpolations))
+      end
 
-    def self.fallback_args
-      if @include_associated
-        '%{association_name} %{attr_fallback_name}'.freeze
-      else
-        '%{attr_fallback_name}'.freeze
+      def default_attribute_name
+        ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
       end
-    end
 
-    def self.build_interpolations(associated_class)
-      {
-        :attr_fallback_name => attr_fallback_name(associated_class),
-        :association_name   => association_name
-      }
-      .reject { |_, value| value.nil? }
-    end
+      def fallback_args
+        if @include_associated
+          '%{association_name} %{attr_fallback_name}'.freeze
+        else
+          '%{attr_fallback_name}'.freeze
+        end
+      end
 
-    def self.attr_fallback_name(associated_class)
-      I18n.t(
-        :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
-        :default => default_interpolation(associated_class)
+      def build_interpolations(associated_class)
+        {
+          attr_fallback_name: attr_fallback_name(associated_class),
+          association_name: association_name
+        }.reject { |_, value| value.nil? }
+      end
+
+      def attr_fallback_name(associated_class)
+        I18n.t(
+          :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
+          default: default_interpolation(associated_class)
         )
-    end
+      end
 
-    def self.fallback_class(associated_class)
-      i18n_key(associated_class || @context.klass)
-    end
+      def fallback_class(associated_class)
+        i18n_key(associated_class || @context.klass)
+      end
 
-    def self.association_name
-      association(@assoc_path, :context => @context) if @include_associated
-    end
+      def association_name
+        association(@assoc_path, context: @context) if @include_associated
+      end
 
-    def self.default_interpolation(associated_class)
-      [
-        associated_attribute(associated_class),
-        ".attributes.#{@attr_name}".to_sym,
-        @attr_name.humanize
-      ]
-      .flatten
-    end
+      def default_interpolation(associated_class)
+        [
+          associated_attribute(associated_class),
+          ".attributes.#{@attr_name}".to_sym,
+          @attr_name.humanize
+        ].flatten
+      end
 
-    def self.associated_attribute(associated_class)
-      if associated_class
-        translated_attribute(associated_class)
-      else
-        translated_ancestor_attributes
+      def associated_attribute(associated_class)
+        if associated_class
+          translated_attribute(associated_class)
+        else
+          translated_ancestor_attributes
+        end
       end
-    end
 
-    def self.translated_attribute(associated_class)
-      key = "#{associated_class.i18n_scope}.attributes.#{
+      def translated_attribute(associated_class)
+        key = "#{associated_class.i18n_scope}.attributes.#{
         i18n_key(associated_class)}.#{@attr_name}"
-      ["#{key}.one".to_sym, key.to_sym]
-    end
+        ["#{key}.one".to_sym, key.to_sym]
+      end
 
-    def self.translated_ancestor_attributes
-      @context.klass.ancestors
-      .select { |ancestor| ancestor.respond_to?(:model_name) }
-      .map { |ancestor| translated_attribute(ancestor) }
-    end
+      def translated_ancestor_attributes
+        @context.klass.ancestors
+          .select { |ancestor| ancestor.respond_to?(:model_name) }
+          .map { |ancestor| translated_attribute(ancestor) }
+      end
 
-    def self.i18n_key(klass)
-      raise "not implemented"
+      def i18n_key(klass)
+        raise "not implemented"
+      end
     end
   end
 end

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '2.1.1'
+  VERSION = '2.5.0'
 end

data/lib/ransack.rb

@@ -1,12 +1,13 @@
 require 'active_support/core_ext'
 require 'ransack/configuration'
 require 'ransack/adapters'
+require 'polyamorous/polyamorous'
 
 Ransack::Adapters.object_mapper.require_constants
 
 module Ransack
   extend Configuration
-  class UntraversableAssociationError < StandardError; end;
+  class UntraversableAssociationError < StandardError; end
 end
 
 Ransack.configure do |config|
@@ -20,12 +21,11 @@ end
 
 require 'ransack/search'
 require 'ransack/ransacker'
-require 'ransack/helpers'
-require 'action_controller'
 require 'ransack/translate'
 
 Ransack::Adapters.object_mapper.require_adapter
 
 ActiveSupport.on_load(:action_controller) do
+  require 'ransack/helpers'
   ActionController::Base.helper Ransack::Helpers::FormHelper
 end

data/ransack.gemspec

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+
 $:.push File.expand_path("../lib", __FILE__)
 require "ransack/version"
 
@@ -6,36 +7,20 @@ Gem::Specification.new do |s|
   s.name        = "ransack"
   s.version     = Ransack::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ernie Miller", "Ryan Bigg", "Jon Atack","Sean Carroll"]
-  s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com", "jonnyatack@gmail.com","sfcarroll@gmail.com"]
+  s.authors     = ["Ernie Miller", "Ryan Bigg", "Jon Atack", "Sean Carroll"]
+  s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com", "jonnyatack@gmail.com", "sfcarroll@gmail.com"]
   s.homepage    = "https://github.com/activerecord-hackery/ransack"
   s.summary     = %q{Object-based searching for Active Record and Mongoid (currently).}
   s.description = %q{Ransack is the successor to the MetaSearch gem. It improves and expands upon MetaSearch's functionality, but does not have a 100%-compatible API.}
-  s.required_ruby_version = '>= 1.9'
+  s.required_ruby_version = '>= 2.6'
   s.license     = 'MIT'
 
-  s.rubyforge_project = "ransack"
-
-  s.add_dependency 'actionpack', '>= 5.0'
-  s.add_dependency 'activerecord', '>= 5.0'
-  s.add_dependency 'activesupport', '>= 5.0'
+  s.add_dependency 'activerecord', '>= 5.2.4'
+  s.add_dependency 'activesupport', '>= 5.2.4'
   s.add_dependency 'i18n'
-  s.add_development_dependency 'rspec', '~> 3'
-  s.add_development_dependency 'machinist', '~> 1.0.6'
-  s.add_development_dependency 'faker', '~> 0.9.5'
-  s.add_development_dependency 'sqlite3', '~> 1.3.3'
-  s.add_development_dependency 'pg', '~> 0.21'
-  s.add_development_dependency 'mysql2', '0.3.20'
-  s.add_development_dependency 'pry', '0.10'
 
   s.files         = `git ls-files`.split("\n")
-
-  s.test_files    = `git ls-files -- {test,spec,features}/*`
-                    .split("\n")
-
-  s.executables   = `git ls-files -- bin/*`
-                    .split("\n")
-                    .map { |f| File.basename(f) }
-
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 end

data/spec/blueprints/articles.rb

@@ -2,4 +2,4 @@ Article.blueprint do
   person
   title
   body
-end
+end

data/spec/blueprints/comments.rb

@@ -2,4 +2,4 @@ Comment.blueprint do
   article
   person
   body
-end
+end

data/spec/blueprints/notes.rb

@@ -2,4 +2,4 @@ Note.blueprint do
   note
   notable_type { "Article" }
   notable_id
-end
+end

data/spec/blueprints/tags.rb

@@ -1,3 +1,3 @@
 Tag.blueprint do
   name    { Sham.tag_name }
-end
+end

data/spec/console.rb

@@ -14,11 +14,11 @@ Sham.define do
   title    { Faker::Lorem.sentence }
   body     { Faker::Lorem.paragraph }
   salary   { |index| 30000 + (index * 1000) }
-  tag_name { Faker::Lorem.words(3).join(' ') }
-  note     { Faker::Lorem.words(7).join(' ') }
-  only_admin  { Faker::Lorem.words(3).join(' ') }
-  only_search { Faker::Lorem.words(3).join(' ') }
-  only_sort   { Faker::Lorem.words(3).join(' ') }
+  tag_name { Faker::Lorem.words(number: 3).join(' ') }
+  note     { Faker::Lorem.words(number: 7).join(' ') }
+  only_admin  { Faker::Lorem.words(number: 3).join(' ') }
+  only_search { Faker::Lorem.words(number: 3).join(' ') }
+  only_sort   { Faker::Lorem.words(number: 3).join(' ') }
   notable_id  { |id| id }
 end
 

data/spec/helpers/polyamorous_helper.rb

@@ -3,18 +3,13 @@ module PolyamorousHelper
     Polyamorous::JoinAssociation.new reflection, children, klass
   end
 
-  if ActiveRecord::VERSION::STRING > "5.2.0"
+  if ActiveRecord.version >= ::Gem::Version.new("6.0.0.rc1")
     def new_join_dependency(klass, associations = {})
-      Polyamorous::JoinDependency.new klass, klass.arel_table, associations
-    end
-  elsif ActiveRecord::VERSION::STRING == "5.2.0"
-    def new_join_dependency(klass, associations = {})
-      alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(klass.connection, klass.table_name, [])
-      Polyamorous::JoinDependency.new klass, klass.arel_table, associations, alias_tracker
+      Polyamorous::JoinDependency.new klass, klass.arel_table, associations, Polyamorous::InnerJoin
     end
   else
     def new_join_dependency(klass, associations = {})
-      Polyamorous::JoinDependency.new klass, associations, []
+      Polyamorous::JoinDependency.new klass, klass.arel_table, associations
     end
   end
 

data/spec/helpers/ransack_helper.rb

@@ -6,4 +6,4 @@ module RansackHelper
   def quote_column_name(column)
     ActiveRecord::Base.connection.quote_column_name(column)
   end
-end
+end

data/spec/{ransack → polyamorous}/join_association_spec.rb

@@ -10,7 +10,14 @@ module Polyamorous
       new_join_association(reflection, parent.children, Article)
     }
 
-    it 'leaves the orginal reflection intact for thread safety' do
+    subject { new_join_association(reflection, parent.children, Person) }
+
+    it 'respects polymorphism on equality test' do
+      expect(subject).to eq new_join_association(reflection, parent.children, Person)
+      expect(subject).not_to eq new_join_association(reflection, parent.children, Article)
+    end
+
+    it 'leaves the original reflection intact for thread safety' do
       reflection.instance_variable_set(:@klass, Article)
       join_association
       .swapping_reflection_klass(reflection, Person) do |new_reflection|

data/spec/{ransack → polyamorous}/join_dependency_spec.rb

@@ -8,8 +8,8 @@ module Polyamorous
 
       specify { expect(subject.send(:join_root).drop(1).size)
         .to eq(2) }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
-        .to be_all { Polyamorous::InnerJoin } }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::InnerJoin] }
     end
 
     context 'with has_many :through association' do
@@ -38,8 +38,8 @@ module Polyamorous
         .to eq 2 }
       specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
         .to eq [Polyamorous::OuterJoin, Polyamorous::OuterJoin] }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
-        .to be_all { Polyamorous::OuterJoin } }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::OuterJoin] }
     end
 
     context 'with polymorphic belongs_to join' do
@@ -59,8 +59,19 @@ module Polyamorous
 
       specify { expect(subject.send(:join_root).drop(1).size)
         .to eq 2 }
-      specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
-        .to be_all { Polyamorous::InnerJoin } }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::InnerJoin] }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
+        .to eq 'comments' }
+    end
+
+    context 'with polymorphic belongs_to join and nested join' do
+      subject { new_join_dependency Note,
+        new_join(:notable, :outer, Person) => :comments }
+      specify { expect(subject.send(:join_root).drop(1).size).to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type)).to eq [Polyamorous::OuterJoin, Polyamorous::InnerJoin] }
       specify { expect(subject.send(:join_root).drop(1).first.table_name)
         .to eq 'people' }
       specify { expect(subject.send(:join_root).drop(1)[1].table_name)
@@ -68,7 +79,7 @@ module Polyamorous
     end
 
     context '#left_outer_join in Rails 5 overrides join type specified',
-            if: ActiveRecord::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MINOR < 2 do
+            if: ActiveRecord::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MAJOR < 6 && ActiveRecord::VERSION::MINOR < 2 do
 
       let(:join_type_class) do
         new_join_dependency(