ransack 1.8.4 → 3.2.1

data/lib/ransack/nodes/value.rb

@@ -26,7 +26,7 @@ module Ransack
         case type
         when :date
           cast_to_date(value)
-        when :datetime, :timestamp, :time
+        when :datetime, :timestamp, :time, :timestamptz
           cast_to_time(value)
         when :boolean
           cast_to_boolean(value)
@@ -50,7 +50,7 @@ module Ransack
           y, m, d = *[val].flatten
           m ||= 1
           d ||= 1
-          Date.new(y,m,d) rescue nil
+          Date.new(y, m, d) rescue nil
         end
       end
 
@@ -98,7 +98,7 @@ module Ransack
          val.to_s.to_d
        end
       end
-      
+
       def cast_to_money(val)
         val.blank? ? nil : val.to_f.to_s
       end

data/lib/ransack/predicate.rb

@@ -1,7 +1,7 @@
 module Ransack
   class Predicate
     attr_reader :name, :arel_predicate, :type, :formatter, :validator,
-                :compound, :wants_array
+                :compound, :wants_array, :case_insensitive
 
     class << self
 
@@ -9,34 +9,26 @@ module Ransack
         Ransack.predicates.keys
       end
 
-      def names_by_decreasing_length
-        names.sort { |a, b| b.length <=> a.length }
-      end
-
       def named(name)
         Ransack.predicates[name.to_s]
       end
 
       def detect_and_strip_from_string!(str)
-        if p = detect_from_string(str)
-          str.sub! /_#{p}$/, ''.freeze
-          p
-        end
+        detect_from_string str, chomp: true
       end
 
-      def detect_from_string(str)
-        names_by_decreasing_length.detect { |p| str.end_with?("_#{p}") }
-      end
+      def detect_from_string(str, chomp: false)
+        return unless str
 
-#      def name_from_attribute_name(attribute_name)
-#        names_by_decreasing_length.detect {
-#          |p| attribute_name.to_s.match(/_#{p}$/)
-#        }
-#      end
+        Ransack.predicates.sorted_names_with_underscores.each do |predicate, underscored|
+          if str.end_with? underscored
+            str.chomp! underscored if chomp
+            return predicate
+          end
+        end
 
-#      def for_attribute_name(attribute_name)
-#        self.named(detect_from_string(attribute_name.to_s))
-#      end
+        nil
+      end
 
     end
 
@@ -50,6 +42,7 @@ module Ransack
       @compound = opts[:compound]
       @wants_array = opts.fetch(:wants_array,
         @compound || Constants::IN_NOT_IN.include?(@arel_predicate))
+      @case_insensitive = opts[:case_insensitive]
     end
 
     def eql?(other)

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
 
@@ -40,11 +43,11 @@ module Ransack
       collapse_multiparameter_attributes!(params).each do |key, value|
         if ['s'.freeze, 'sorts'.freeze].freeze.include?(key)
           send("#{key}=", value)
-        elsif base.attribute_method?(key)
-          base.send("#{key}=", value)
         elsif @context.ransackable_scope?(key, @context.object)
           add_scope(key, value)
-        elsif !Ransack.options[:ignore_unknown_conditions]
+        elsif base.attribute_method?(key)
+          base.send("#{key}=", value)
+        elsif !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
           raise ArgumentError, "Invalid search term #{key}"
         end
       end
@@ -123,7 +126,7 @@ module Ransack
     private
 
     def add_scope(key, args)
-      sanitized_args = if Ransack.options[:sanitize_scope_args]
+      sanitized_args = if Ransack.options[:sanitize_scope_args] && !@context.ransackable_scope_skip_sanitize_args?(key, @context.object)
         sanitized_scope_args(args)
       else
         args

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)
-      }
-      predicate = Predicate.detect_from_string(original_name)
-      attributes_str = original_name.sub(/_#{predicate}$/, ''.freeze)
-      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 = '1.8.4'
+  VERSION = '3.2.1'
 end

data/lib/ransack/visitor.rb

@@ -31,17 +31,7 @@ module Ransack
 
     def visit_or(object)
       nodes = object.values.map { |o| accept(o) }.compact
-      return nil unless nodes.size > 0
-
-      if nodes.size > 1
-        nodes.inject(&:or)
-      else
-        nodes.first
-      end
-    end
-
-    def visit_Ransack_Nodes_Sort(object)
-      object.attr.send(object.dir) if object.valid?
+      nodes.inject(&:or)
     end
 
     def quoted?(object)
@@ -57,6 +47,5 @@ module Ransack
         klass.name.gsub(Constants::TWO_COLONS, Constants::UNDERSCORE)
         }"
     end
-
   end
 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|
@@ -14,16 +15,17 @@ Ransack.configure do |config|
     config.add_predicate name, :arel_predicate => name
   end
   Ransack::Constants::DERIVED_PREDICATES.each do |args|
-    config.add_predicate *args
+    config.add_predicate(*args)
   end
 end
 
 require 'ransack/search'
 require 'ransack/ransacker'
-require 'ransack/helpers'
-require 'action_controller'
 require 'ransack/translate'
 
 Ransack::Adapters.object_mapper.require_adapter
 
-ActionController::Base.helper Ransack::Helpers::FormHelper
+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,37 +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"]
-  s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com", "jonnyatack@gmail.com"]
+  s.authors     = ["Ernie Miller", "Ryan Bigg", "Jon Atack", "Sean Carroll", "David Rodríguez"]
+  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.summary     = %q{Object-based searching for Active Record.}
   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.7'
   s.license     = 'MIT'
 
-  s.rubyforge_project = "ransack"
-
-  s.add_dependency 'actionpack', '>= 3.0'
-  s.add_dependency 'activerecord', '>= 3.0'
-  s.add_dependency 'activesupport', '>= 3.0'
+  s.add_dependency 'activerecord', '>= 6.1.5'
+  s.add_dependency 'activesupport', '>= 6.1.5'
   s.add_dependency 'i18n'
-  s.add_dependency 'polyamorous', '~> 1.3'
-  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'
-  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

@@ -0,0 +1,13 @@
+module PolyamorousHelper
+  def new_join_association(reflection, children, klass)
+    Polyamorous::JoinAssociation.new reflection, children, klass
+  end
+
+  def new_join_dependency(klass, associations = {})
+    Polyamorous::JoinDependency.new klass, klass.arel_table, associations, Polyamorous::InnerJoin
+  end
+
+  def new_join(name, type = Polyamorous::InnerJoin, klass = nil)
+    Polyamorous::Join.new name, type, klass
+  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/polyamorous/activerecord_compatibility_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe "ActiveRecord Compatibility" do
+    it 'works with self joins and includes' do
+      trade_account = Account.create!
+      Account.create!(trade_account: trade_account)
+
+      accounts = Account.joins(:trade_account).includes(:trade_account, :agent_account)
+      account = accounts.first
+
+      expect(account.agent_account).to be_nil
+    end
+  end
+end

data/spec/polyamorous/join_association_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe JoinAssociation do
+
+    let(:join_dependency) { new_join_dependency Note, {} }
+    let(:reflection) { Note.reflect_on_association(:notable) }
+    let(:parent) { join_dependency.send(:join_root) }
+    let(:join_association) {
+      new_join_association(reflection, parent.children, Article)
+    }
+
+    subject { new_join_association(reflection, parent.children, Person) }
+
+    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|
+        expect(new_reflection.options).not_to equal reflection.options
+        expect(new_reflection.options).not_to have_key(:polymorphic)
+        expect(new_reflection.klass).to eq(Person)
+        expect(reflection.klass).to eq(Article)
+      end
+    end
+
+    it 'sets the polymorphic option to true after initializing' do
+      expect(join_association.reflection.options[:polymorphic]).to be true
+    end
+  end
+end