ransack 1.7.0 → 2.4.1

data/lib/ransack/nodes/value.rb

@@ -23,87 +23,93 @@ module Ransack
       end
 
       def cast(type)
-         case type
-         when :date
-           cast_to_date(value)
-         when :datetime, :timestamp, :time
-           cast_to_time(value)
-         when :boolean
-           cast_to_boolean(value)
-         when :integer
-           cast_to_integer(value)
-         when :float
-           cast_to_float(value)
-         when :decimal
-           cast_to_decimal(value)
-         else
-           cast_to_string(value)
-         end
-       end
+        case type
+        when :date
+          cast_to_date(value)
+        when :datetime, :timestamp, :time
+          cast_to_time(value)
+        when :boolean
+          cast_to_boolean(value)
+        when :integer
+          cast_to_integer(value)
+        when :float
+          cast_to_float(value)
+        when :decimal
+          cast_to_decimal(value)
+        when :money
+          cast_to_money(value)
+        else
+          cast_to_string(value)
+        end
+      end
 
-       def cast_to_date(val)
-         if val.respond_to?(:to_date)
-           val.to_date rescue nil
-         else
-           y, m, d = *[val].flatten
-           m ||= 1
-           d ||= 1
-           Date.new(y,m,d) rescue nil
-         end
-       end
+      def cast_to_date(val)
+        if val.respond_to?(:to_date)
+          val.to_date rescue nil
+        else
+          y, m, d = *[val].flatten
+          m ||= 1
+          d ||= 1
+          Date.new(y,m,d) rescue nil
+        end
+      end
 
-       def cast_to_time(val)
-         if val.is_a?(Array)
-           Time.zone.local(*val) rescue nil
-         else
-           unless val.acts_like?(:time)
-             val = val.is_a?(String) ? Time.zone.parse(val) : val.to_time rescue val
-           end
-           val.in_time_zone rescue nil
-         end
-       end
+      def cast_to_time(val)
+        if val.is_a?(Array)
+          Time.zone.local(*val) rescue nil
+        else
+          unless val.acts_like?(:time)
+            val = val.is_a?(String) ? Time.zone.parse(val) : val.to_time rescue val
+          end
+          val.in_time_zone rescue nil
+        end
+      end
 
-       def cast_to_boolean(val)
-         if Constants::TRUE_VALUES.include?(val)
-           true
-         elsif Constants::FALSE_VALUES.include?(val)
-           false
-         else
-           nil
-         end
-       end
+      def cast_to_boolean(val)
+        if Constants::TRUE_VALUES.include?(val)
+          true
+        elsif Constants::FALSE_VALUES.include?(val)
+          false
+        else
+          nil
+        end
+      end
 
-       def cast_to_string(val)
-         val.respond_to?(:to_s) ? val.to_s : String.new(val)
-       end
+      def cast_to_string(val)
+        val.respond_to?(:to_s) ? val.to_s : String.new(val)
+      end
 
-       def cast_to_integer(val)
-         val.blank? ? nil : val.to_i
-       end
+      def cast_to_integer(val)
+        val.blank? ? nil : val.to_i
+      end
 
-       def cast_to_float(val)
-         val.blank? ? nil : val.to_f
-       end
+      def cast_to_float(val)
+        val.blank? ? nil : val.to_f
+      end
 
-       def cast_to_decimal(val)
-         if val.blank?
-           nil
-         elsif val.class == BigDecimal
-           val
-         elsif val.respond_to?(:to_d)
-           val.to_d
-         else
-           val.to_s.to_d
-         end
+      def cast_to_decimal(val)
+       if val.blank?
+         nil
+       elsif val.class == BigDecimal
+         val
+       elsif val.respond_to?(:to_d)
+         val.to_d
+       else
+         val.to_s.to_d
        end
+      end
+
+      def cast_to_money(val)
+        val.blank? ? nil : val.to_f.to_s
+      end
 
       def inspect
         "Value <#{value}>"
       end
 
-       def array_of_arrays?(val)
-         Array === val && Array === val.first
-       end
+      def array_of_arrays?(val)
+        Array === val && Array === val.first
+      end
     end
   end
 end

data/lib/ransack/nodes.rb

@@ -3,6 +3,6 @@ require 'ransack/nodes/node'
 require 'ransack/nodes/attribute'
 require 'ransack/nodes/value'
 require 'ransack/nodes/condition'
-Ransack::Adapters.require_nodes
+Ransack::Adapters.object_mapper.require_nodes
 require 'ransack/nodes/sort'
 require 'ransack/nodes/grouping'

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}$/, Constants::EMPTY
-          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)
@@ -74,5 +67,9 @@ module Ransack
       vals.any? { |v| validator.call(type ? v.cast(type) : v.value) }
     end
 
+    def negative?
+      @name.include?("not_".freeze)
+    end
+
   end
 end

data/lib/ransack/search.rb

@@ -1,6 +1,6 @@
 require 'ransack/nodes'
 require 'ransack/context'
-Ransack::Adapters.require_search
+Ransack::Adapters.object_mapper.require_search
 require 'ransack/naming'
 
 module Ransack
@@ -15,8 +15,10 @@ module Ransack
              :translate, :to => :base
 
     def initialize(object, params = {}, options = {})
+      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) ? v.strip : v }
         params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
       else
         params = {}
@@ -28,6 +30,7 @@ module Ransack
         )
       @scope_args = {}
       @sorts ||= []
+      @ignore_unknown_conditions = options[:ignore_unknown_conditions] == false ? false : true
       build(params.with_indifferent_access)
     end
 
@@ -37,13 +40,13 @@ module Ransack
 
     def build(params)
       collapse_multiparameter_attributes!(params).each do |key, value|
-        if Constants::S_SORTS.include?(key)
+        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 !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
           raise ArgumentError, "Invalid search term #{key}"
         end
       end
@@ -92,7 +95,7 @@ module Ransack
 
     def method_missing(method_id, *args)
       method_name = method_id.to_s
-      getter_name = method_name.sub(/=$/, Constants::EMPTY)
+      getter_name = method_name.sub(/=$/, ''.freeze)
       if base.attribute_method?(getter_name)
         base.send(method_id, *args)
       elsif @context.ransackable_scope?(getter_name, @context.object)
@@ -113,8 +116,8 @@ module Ransack
         [:base, base.inspect]
       ]
       .compact
-      .map { |d| d.join(Constants::COLON_SPACE) }
-      .join(Constants::COMMA_SPACE)
+      .map { |d| d.join(': '.freeze) }
+      .join(', '.freeze)
 
       "Ransack::Search<#{details}>"
     end
@@ -122,12 +125,18 @@ module Ransack
     private
 
     def add_scope(key, args)
+      sanitized_args = if Ransack.options[:sanitize_scope_args] && !@context.ransackable_scope_skip_sanitize_args?(key, @context.object)
+        sanitized_scope_args(args)
+      else
+        args
+      end
+
       if @context.scope_arity(key) == 1
         @scope_args[key] = args.is_a?(Array) ? args[0] : args
       else
-        @scope_args[key] = args.is_a?(Array) ? sanitized_scope_args(args) : args
+        @scope_args[key] = args.is_a?(Array) ? sanitized_args : args
       end
-      @context.chain_scope(key, sanitized_scope_args(args))
+      @context.chain_scope(key, sanitized_args)
     end
 
     def sanitized_scope_args(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}$/, Constants::EMPTY)
-      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
 
-      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
+
+        defaults << options.delete(:default) if options[:default]
+        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}_/, Constants::EMPTY)
-      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.7.0'
+  VERSION = '2.4.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,9 +1,9 @@
 require 'active_support/core_ext'
-
 require 'ransack/configuration'
-
 require 'ransack/adapters'
-Ransack::Adapters.require_constants
+require 'polyamorous/polyamorous.rb'
+
+Ransack::Adapters.object_mapper.require_constants
 
 module Ransack
   extend Configuration
@@ -15,17 +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.require_adapter
+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