ransack 1.3.0 → 1.4.0

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

@@ -174,6 +174,7 @@ module Ransack
               :build, Polyamorous::Join.new(name, @join_type, klass), parent
               )
             found_association = @join_dependency.join_associations.last
+            apply_default_conditions(found_association)
             # Leverage the stashed association functionality in AR
             @object = @object.joins(found_association)
           end
@@ -181,6 +182,15 @@ module Ransack
           found_association
         end
 
+        def apply_default_conditions(join_association)
+          reflection = join_association.reflection
+          default_scope = join_association.active_record.scoped
+          default_conditions = default_scope.arel.where_clauses
+          if default_conditions.any?
+            reflection.options[:conditions] = default_conditions
+          end
+        end
+
       end
     end
   end

data/lib/ransack/adapters/active_record/3.1/context.rb

@@ -189,6 +189,7 @@ module Ransack
               :build, Polyamorous::Join.new(name, @join_type, klass), parent
               )
             found_association = @join_dependency.join_associations.last
+            apply_default_conditions(found_association)
             # Leverage the stashed association functionality in AR
             @object = @object.joins(found_association)
           end
@@ -196,6 +197,15 @@ module Ransack
           found_association
         end
 
+        def apply_default_conditions(join_association)
+          reflection = join_association.reflection
+          default_scope = join_association.active_record.scoped
+          default_conditions = default_scope.arel.where_clauses
+          if default_conditions.any?
+            reflection.options[:conditions] = default_conditions
+          end
+        end
+
       end
     end
   end

data/lib/ransack/adapters/active_record/base.rb

@@ -12,9 +12,7 @@ module Ransack
         end
 
         def ransack(params = {}, options = {})
-          params = params.presence || {}
-          Search.new(self, params ? params.delete_if {
-            |k, v| v.blank? && v != false } : params, options)
+          Search.new(self, params, options)
         end
 
         def ransacker(name, opts = {}, &block)
@@ -22,21 +20,34 @@ module Ransack
             .new(self, name, opts, &block)
         end
 
+        # Ransackable_attributes, by default, returns all column names
+        # and any defined ransackers as an array of strings.
+        # For overriding with a whitelist array of strings.
+        #
         def ransackable_attributes(auth_object = nil)
           column_names + _ransackers.keys
         end
 
-        def ransortable_attributes(auth_object = nil)
-          # Here so users can overwrite the attributes
-          # that show up in the sort_select
-          ransackable_attributes(auth_object)
-        end
-
+        # Ransackable_associations, by default, returns the names
+        # of all associations as an array of strings.
+        # For overriding with a whitelist array of strings.
+        #
         def ransackable_associations(auth_object = nil)
           reflect_on_all_associations.map { |a| a.name.to_s }
         end
 
-        # For overriding with a whitelist of symbols
+        # Ransortable_attributes, by default, returns the names
+        # of all attributes available for sorting as an array of strings.
+        # For overriding with a whitelist array of strings.
+        #
+        def ransortable_attributes(auth_object = nil)
+          ransackable_attributes(auth_object)
+        end
+
+        # Ransackable_scopes, by default, returns an empty array
+        # i.e. no class methods/scopes are authorized.
+        # For overriding with a whitelist array of *symbols*.
+        #
         def ransackable_scopes(auth_object = nil)
           []
         end

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

@@ -11,4 +11,4 @@ module Arel
     end
 
   end
-end
+end

data/lib/ransack/constants.rb

@@ -12,11 +12,21 @@ module Ransack
         :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
+      ['i_cont', {
+        :arel_predicate => 'i_matches',
+        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
+      }
+      ],
       ['not_cont', {
         :arel_predicate => 'does_not_match',
         :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
+      ['i_not_cont', {
+        :arel_predicate => 'i_does_not_match',
+        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
+      }
+      ],
       ['start', {
         :arel_predicate => 'matches',
         :formatter => proc { |v| "#{escape_wildcards(v)}%" }
@@ -38,18 +48,35 @@ module Ransack
         }
       ],
       ['true', {
-        :arel_predicate => 'eq',
+        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| true }
+        }
+      ],
+      ['not_true', {
+        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
         :compounds => false,
         :type => :boolean,
-        :validator => proc { |v| TRUE_VALUES.include?(v) }
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| true }
         }
       ],
       ['false', {
-        :arel_predicate => 'eq',
+        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
+        :compounds => false,
+        :type => :boolean,
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| false }
+        }
+      ],
+      ['not_false', {
+        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
         :compounds => false,
         :type => :boolean,
-        :validator => proc { |v| TRUE_VALUES.include?(v) },
-        :formatter => proc { |v| !v }
+        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
+        :formatter => proc { |v| false }
         }
       ],
       ['present', {

data/lib/ransack/context.rb

@@ -34,7 +34,7 @@ module Ransack
       @object = relation_for(object)
       @klass = @object.klass
       @join_dependency = join_dependency(@object)
-      @join_type = options[:join_type] || Arel::OuterJoin
+      @join_type = options[:join_type] || Polyamorous::OuterJoin
       @search_key = options[:search_key] || Ransack.options[:search_key]
 
       if ::ActiveRecord::VERSION::STRING >= "4.1"

data/lib/ransack/locale/ro.yml

@@ -0,0 +1,70 @@
+ro:
+  ransack:
+    search: "caută"
+    predicate: "predicat"
+    and: "și"
+    or: "sau"
+    any: "oricare"
+    all: "toate"
+    combinator: "combinator"
+    attribute: "atribut"
+    value: "valoare"
+    condition: "condiție"
+    sort: "sortează"
+    asc: "crescător"
+    desc: "descrescător"
+    predicates:
+      eq: "egal cu"
+      eq_any: "egal cu unul din"
+      eq_all: "egal cu toate"
+      not_eq: "diferit de"
+      not_eq_any: "diferit de toate"
+      not_eq_all: "nu este egal cu toate"
+      matches: "corespunde"
+      matches_any: "corespunde cu unul din"
+      matches_all: "corespunde cu toate"
+      does_not_match: "nu corespunde"
+      does_not_match_any: "nu corespunde cu nici un"
+      does_not_match_all: "nu corespunde cu toate"
+      lt: "mai mic de"
+      lt_any: "mai mic decât cel puțin unul din"
+      lt_all: "mai mic decât toate"
+      lteq: "mai mic sau egal decât"
+      lteq_any: "mai mic sau egal decât cel puțin unul din"
+      lteq_all: "mai mic sau egal decât toate"
+      gt: "mai mare de"
+      gt_any: "mai mare decât cel puțin unul din"
+      gt_all: "mai mare decât toate"
+      gteq: "mai mare sau egal decât"
+      gteq_any: "mai mare sau egal decât cel puțin unul din"
+      gteq_all: "mai mare sau egal decât toate"
+      in: "inclus în"
+      in_any: "inclus într-unul din"
+      in_all: "inclus în toate"
+      not_in: "nu este inclus în"
+      not_in_any: "nu este inclus într-unul din"
+      not_in_all: "nu este inclus în toate"
+      cont: "conține"
+      cont_any: "conține unul din"
+      cont_all: "conține toate"
+      not_cont: "nu conține"
+      not_cont_any: "nu conține unul din"
+      not_cont_all: "nu conține toate"
+      start: "începe cu"
+      start_any: "începe cu unul din"
+      start_all: "începe cu toate"
+      not_start: "nu începe"
+      not_start_any: "nu începe cu unul din"
+      not_start_all: "nu începe cu toate"
+      end: "se termină cu"
+      end_any: "se termină cu unul din"
+      end_all: "se termină cu toate"
+      not_end: "nu se termină cu"
+      not_end_any: "nu se termină cu unul din"
+      not_end_all: "nu se termină cu toate"
+      'true': "este adevărat"
+      'false': "este fals"
+      present: "este prezent"
+      blank: "este gol"
+      'null': "este nul"
+      not_null: "nu este nul"

data/lib/ransack/search.rb

@@ -14,9 +14,12 @@ module Ransack
              :translate, :to => :base
 
     def initialize(object, params = {}, options = {})
-      params = {} unless params.is_a?(Hash)
-      (params ||= {})
-      .delete_if { |k, v| [*v].all? { |i| i.blank? && i != false } }
+      if params.is_a? Hash
+        params = params.dup
+        params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
+      else
+        params = {}
+      end
       @context = options[:context] || Context.for(object, options)
       @context.auth_object = options[:auth_object]
       @base = Nodes::Grouping.new(@context, options[:grouping] || 'and')

data/lib/ransack/translate.rb

@@ -27,23 +27,22 @@ module Ransack
       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}"
+        "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
       end
 
-      translated_names = attribute_names.map do |attr|
-        attribute_name(context, attr, options[:include_associations])
+      translated_names = attribute_names.map do |name|
+        attribute_name(context, name, options[:include_associations])
       end
 
-      interpolations = {}
-      interpolations[:attributes] = translated_names.join(
-        " #{Translate.word(combinator)} "
-        )
+      interpolations = {
+        :attributes => translated_names.join(" #{Translate.word(combinator)} ")
+      }
 
       if predicate
-        defaults << "%{attributes} %{predicate}"
+        defaults << "%{attributes} %{predicate}".freeze
         interpolations[:predicate] = Translate.predicate(predicate)
       else
-        defaults << "%{attributes}"
+        defaults << "%{attributes}".freeze
       end
 
       defaults << options.delete(:default) if options[:default]
@@ -56,52 +55,97 @@ module Ransack
         raise ArgumentError, "A context is required to translate associations"
       end
 
-      defaults = key.blank? ?
-        [:"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"] :
-        [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+      defaults =
+        if key.blank?
+          [:"#{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
 
-    private
+  private
 
     def self.attribute_name(context, name, include_associations = nil)
-      assoc_path = context.association_path(name)
-      associated_class = context.traverse(assoc_path) if assoc_path.present?
-      attr_name = name.sub(/^#{assoc_path}_/, '')
-      interpolations = {}
-      interpolations[:attr_fallback_name] = I18n.translate(
-        :"ransack.attributes.#{
-          i18n_key(associated_class || context.klass)
-          }.#{attr_name}",
-        :default => [
-          (
-            if associated_class
-              :"#{associated_class.i18n_scope}.attributes.#{
-                i18n_key(associated_class)}.#{attr_name}"
-            else
-              :"#{context.klass.i18n_scope}.attributes.#{
-                i18n_key(context.klass)}.#{attr_name}"
-            end
-          ),
-          :".attributes.#{attr_name}",
-          attr_name.humanize
-        ]
-      )
-      defaults = [:"ransack.attributes.#{i18n_key(context.klass)}.#{name}"]
-      if include_associations && associated_class
-        defaults << '%{association_name} %{attr_fallback_name}'
-        interpolations[:association_name] = association(
-          assoc_path, :context => context
-          )
-      else
-        defaults << '%{attr_fallback_name}'
-      end
+      @context, @name = context, name
+      @assoc_path = context.association_path(name)
+      @attr_name = @name.sub(/^#{@assoc_path}_/, '')
+      associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
+      @include_associated = include_associations && associated_class
+
+      defaults = default_attribute_name << fallback_args
       options = { :count => 1, :default => defaults }
+      interpolations = build_interpolations(associated_class)
+
       I18n.translate(defaults.shift, options.merge(interpolations))
     end
 
+    def self.default_attribute_name
+      ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
+    end
+
+    def self.fallback_args
+      if @include_associated
+        '%{association_name} %{attr_fallback_name}'.freeze
+      else
+        '%{attr_fallback_name}'.freeze
+      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 self.attr_fallback_name(associated_class)
+      I18n.t(
+        :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
+        :default => default_interpolation(associated_class)
+        )
+    end
+
+    def self.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 self.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
+      end
+    end
+
+    def self.translated_attribute(associated_class)
+      key = "#{associated_class.i18n_scope}.attributes.#{
+        i18n_key(associated_class)}.#{@attr_name}"
+      ["#{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 self.i18n_key(klass)
       if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
         klass.model_name.i18n_key.to_s.tr('.', '/')

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/spec/ransack/adapters/active_record/base_spec.rb

@@ -50,6 +50,14 @@ module Ransack
             end
           end
 
+          it 'does not raise exception for string :params argument' do
+            lambda { Person.search('') }.should_not raise_error
+          end
+
+          it 'does not modify the parameters' do
+            params = { :name_eq => '' }
+            expect { Person.search(params) }.not_to change { params }
+          end
         end
 
         describe '#ransacker' do