ransack 0.1.0 → 0.2.0

data/lib/ransack/nodes/sort.rb

@@ -1,7 +1,9 @@
 module Ransack
   module Nodes
     class Sort < Node
-      attr_reader :name, :attr, :dir
+      include Bindable
+
+      attr_reader :name, :dir
       i18n_word :asc, :desc
 
       class << self
@@ -22,12 +24,12 @@ module Ransack
       end
 
       def valid?
-        @attr
+        bound? && attr
       end
 
       def name=(name)
         @name = name
-        @attr = contextualize(name) unless name.blank?
+        context.bind(self, name) unless name.blank?
       end
 
       def dir=(dir)

data/lib/ransack/nodes/value.rb

@@ -1,22 +1,12 @@
 module Ransack
   module Nodes
     class Value < Node
-      attr_reader :value_before_cast, :type
-      delegate :blank?, :to => :value_before_cast
+      attr_accessor :value
+      delegate :blank?, :present?, :to => :value
 
-      def initialize(context, value = nil, type = nil)
+      def initialize(context, value = nil)
         super(context)
-        @value_before_cast = value
-        self.type = type if type
-      end
-
-      def value=(val)
-        @value_before_cast = value
-        @value = nil
-      end
-
-      def value
-        @value ||= cast_to_type(@value_before_cast, @type)
+        @value = value
       end
 
       def persisted?
@@ -25,96 +15,90 @@ module Ransack
 
       def eql?(other)
         self.class == other.class &&
-        self.value_before_cast == other.value_before_cast
+        self.value == other.value
       end
       alias :== :eql?
 
       def hash
-        value_before_cast.hash
-      end
-
-      def type=(type)
-        @value = nil
-        @type = type
-      end
-
-      def cast_to_type(val, type)
-        case type
-        when :date
-          cast_to_date(val)
-        when :datetime, :timestamp, :time
-          cast_to_time(val)
-        when :boolean
-          cast_to_boolean(val)
-        when :integer
-          cast_to_integer(val)
-        when :float
-          cast_to_float(val)
-        when :decimal
-          cast_to_decimal(val)
-        else
-          cast_to_string(val)
-        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
-
-      # FIXME: doesn't seem to be casting, even with Time.zone.local
-      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
-        end
-      end
-
-      def cast_to_boolean(val)
-        if val.is_a?(String) && val.blank?
-          nil
-        else
-          Constants::TRUE_VALUES.include?(val)
-        end
-      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_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
-      end
-
-      def array_of_arrays?(val)
-        Array === val && Array === val.first
-      end
+        value.hash
+      end
+
+      def cast_to_type(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
+
+       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_boolean(val)
+         if val.is_a?(String) && val.blank?
+           nil
+         else
+           Constants::TRUE_VALUES.include?(val)
+         end
+       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_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
+       end
+
+       def array_of_arrays?(val)
+         Array === val && Array === val.first
+       end
     end
   end
 end

data/lib/ransack/predicate.rb

@@ -25,16 +25,6 @@ module Ransack
       @compound = opts[:compound]
     end
 
-    def format(vals)
-      if formatter
-        vals.select {|v| validator ? validator.call(v.value_before_cast) : !v.blank?}.
-             map {|v| formatter.call(v.value)}
-      else
-        vals.select {|v| validator ? validator.call(v.value_before_cast) : !v.blank?}.
-             map {|v| v.value}
-      end
-    end
-
     def eql?(other)
       self.class == other.class &&
       self.name == other.name
@@ -47,7 +37,7 @@ module Ransack
 
     def validate(vals)
       if validator
-        vals.select {|v| validator.call(v.value_before_cast)}.any?
+        vals.select {|v| validator.call(v.value)}.any?
       else
         vals.select {|v| !v.blank?}.any?
       end

data/lib/ransack/ransacker.rb

@@ -0,0 +1,26 @@
+module Ransack
+  class Ransacker
+
+    attr_reader :name, :type, :formatter, :args
+
+    delegate :call, :to => :@callable
+
+    def initialize(klass, name, opts = {}, &block)
+      @klass, @name = klass, name
+
+      @type = opts[:type] || :string
+      @args = opts[:args] || [:parent]
+      @formatter = opts[:formatter]
+      @callable = opts[:callable] || block ||
+                  (@klass.method(name) if @klass.respond_to?(name)) ||
+                  proc {|parent| parent.table[name]}
+
+      @klass._ransackers[name.to_s] = self
+    end
+
+    def attr_from(bindable)
+      call(*args.map {|arg| bindable.send(arg)})
+    end
+
+  end
+end

data/lib/ransack/search.rb

@@ -13,15 +13,16 @@ module Ransack
              :build_and, :build_or, :build_condition,
              :translate, :to => :base
 
-    def initialize(object, params = {})
+    def initialize(object, params = {}, options = {})
       params ||= {}
       @context = Context.for(object)
+      @context.auth_object = options[:auth_object]
       @base = Nodes::And.new(@context)
       build(params.with_indifferent_access)
     end
 
     def result(opts = {})
-      @result ||= @context.evaluate(self, opts)
+      @context.evaluate(self, opts)
     end
 
     def build(params)

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ransack/visitor.rb

@@ -0,0 +1,64 @@
+module Ransack
+  class Visitor
+
+    def accept(object)
+      visit(object)
+    end
+
+    def can_accept?(object)
+      respond_to? DISPATCH[object.class]
+    end
+
+    def visit_Array(object)
+      object.map {|o| accept(o)}.compact
+    end
+
+    def visit_Ransack_Nodes_Condition(object)
+      object.arel_predicate if object.valid?
+    end
+
+    def visit_Ransack_Nodes_And(object)
+      nodes = object.values.map {|o| accept(o)}.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
+      else
+        nodes.first
+      end
+    end
+
+    def visit_Ransack_Nodes_Sort(object)
+      object.attr.send(object.dir) if object.valid?
+    end
+
+    def visit_Ransack_Nodes_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 quoted?(object)
+      case object
+      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+        false
+      else
+        true
+      end
+    end
+
+    def visit(object)
+      send(DISPATCH[object.class], object)
+    end
+
+    DISPATCH = Hash.new do |hash, klass|
+      hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+    end
+
+  end
+end

data/ransack.gemspec

@@ -14,9 +14,9 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "ransack"
 
-  s.add_dependency 'activerecord', '~> 3.1.0.alpha'
-  s.add_dependency 'activesupport', '~> 3.1.0.alpha'
-  s.add_dependency 'actionpack', '~> 3.1.0.alpha'
+  s.add_dependency 'activerecord', '~> 3.0'
+  s.add_dependency 'activesupport', '~> 3.0'
+  s.add_dependency 'actionpack', '~> 3.0'
   s.add_development_dependency 'rspec', '~> 2.5.0'
   s.add_development_dependency 'machinist', '~> 1.0.6'
   s.add_development_dependency 'faker', '~> 0.9.5'

data/spec/console.rb

@@ -2,6 +2,7 @@ Bundler.setup
 require 'machinist/active_record'
 require 'sham'
 require 'faker'
+require 'ransack'
 
 Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
   require f
@@ -18,5 +19,3 @@ end
 
 Schema.create
 
-require 'ransack'
-

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

@@ -24,6 +24,24 @@ module Ransack
           end
         end
 
+        describe '#ransacker' do
+          it 'creates ransack attributes' do
+            s = Person.search(:reversed_name_eq => 'htimS cirA')
+            s.result.should have(1).person
+            s.result.first.should eq Person.find_by_name('Aric Smith')
+          end
+
+          it 'allows access of attributes through associations' do
+            s = Person.search(:children_reversed_name_eq => 'htimS cirA')
+            s.result.to_sql.should match /"children_people"."name" = 'Aric Smith'/
+          end
+
+          it 'allows an "attribute" to be an InfixOperation' do
+            s = Person.search(:doubled_name_eq => 'Aric SmithAric Smith')
+            s.result.first.should eq Person.find_by_name('Aric Smith')
+          end if defined?(Arel::Nodes::InfixOperation)
+        end
+
       end
     end
   end

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

@@ -11,14 +11,14 @@ module Ransack
         it 'contextualizes strings to attributes' do
           attribute = @c.contextualize 'children_children_parent_name'
           attribute.should be_a Arel::Attributes::Attribute
-          attribute.name.should eq 'name'
+          attribute.name.to_s.should eq 'name'
           attribute.relation.table_alias.should eq 'parents_people'
         end
 
         it 'builds new associations if not yet built' do
           attribute = @c.contextualize 'children_articles_title'
           attribute.should be_a Arel::Attributes::Attribute
-          attribute.name.should eq 'title'
+          attribute.name.to_s.should eq 'title'
           attribute.relation.name.should eq 'articles'
           attribute.relation.table_alias.should be_nil
         end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -20,6 +20,10 @@ module Ransack
           include router.url_helpers
         end
 
+        @controller.view_context_class.class_eval do
+          include router.url_helpers
+        end
+
         @s = Person.search
         @controller.view_context.search_form_for @s do |f|
           @f = f