ransack 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'arel', :git => 'git://github.com/rails/arel.git'
+gem 'rack', :git => 'git://github.com/rack/rack.git'
+
+git 'git://github.com/rails/rails.git' do
+  gem 'activesupport'
+  gem 'activerecord'
+  gem 'actionpack'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Ernie Miller
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,5 @@
+= Ransack
+
+Don't use me.
+
+Seriously, I'm not anywhere close to ready for public consumption, yet.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do |rspec|
+  rspec.rspec_opts = ['--backtrace']
+end
+
+task :default => :spec
+
+desc "Open an irb session with Ransack and the sample data used in specs"
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'console'
+  ARGV.clear
+  IRB.start
+end

data/lib/ransack.rb

@@ -0,0 +1,24 @@
+require 'ransack/configuration'
+
+module Ransack
+  extend Configuration
+end
+
+Ransack.configure do |config|
+  Ransack::Constants::AREL_PREDICATES.each do |name|
+    config.add_predicate name, :arel_predicate => name
+  end
+
+  Ransack::Constants::DERIVED_PREDICATES.each do |args|
+    config.add_predicate *args
+  end
+end
+
+require 'ransack/translate'
+require 'ransack/search'
+require 'ransack/adapters/active_record'
+require 'ransack/helpers'
+require 'action_controller'
+
+ActiveRecord::Base.extend Ransack::Adapters::ActiveRecord::Base
+ActionController::Base.helper Ransack::Helpers::FormHelper

data/lib/ransack/adapters/active_record.rb

@@ -0,0 +1,2 @@
+require 'ransack/adapters/active_record/base'
+require 'ransack/adapters/active_record/context'

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

@@ -0,0 +1,17 @@
+module Ransack
+  module Adapters
+    module ActiveRecord
+      module Base
+
+        def self.extended(base)
+          alias :search :ransack unless base.method_defined? :search
+        end
+
+        def ransack(params = {})
+          Search.new(self, params)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+require 'ransack/context'
+require 'active_record'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      class Context < ::Ransack::Context
+        # Because the AR::Associations namespace is insane
+        JoinDependency = ::ActiveRecord::Associations::JoinDependency
+        JoinPart = JoinDependency::JoinPart
+        JoinAssociation = JoinDependency::JoinAssociation
+
+        def evaluate(search, opts = {})
+          relation = @object.where(accept(search.base)).order(accept(search.sorts))
+          opts[:distinct] ? relation.group(@klass.arel_table[@klass.primary_key]) : relation
+        end
+
+        def attribute_method?(str, klass = @klass)
+          exists = false
+
+          if column = get_column(str, klass)
+            exists = true
+          elsif (segments = str.split(/_/)).size > 1
+            remainder = []
+            found_assoc = nil
+            while !found_assoc && remainder.unshift(segments.pop) && segments.size > 0 do
+              if found_assoc = get_association(segments.join('_'), klass)
+                exists = attribute_method?(remainder.join('_'), found_assoc.klass)
+              end
+            end
+          end
+
+          exists
+        end
+
+        def type_for(attr)
+          return nil unless attr
+          name    = attr.name.to_s
+          table   = attr.relation.table_name
+
+          unless @engine.connection_pool.table_exists?(table)
+            raise "No table named #{table} exists"
+          end
+
+          @engine.connection_pool.columns_hash[table][name].type
+        end
+
+        private
+
+        def klassify(obj)
+          if Class === obj && ::ActiveRecord::Base > obj
+            obj
+          elsif obj.respond_to? :klass
+            obj.klass
+          elsif obj.respond_to? :active_record
+            obj.active_record
+          else
+            raise ArgumentError, "Don't know how to klassify #{obj}"
+          end
+        end
+
+        def get_attribute(str, parent = @base)
+          attribute = nil
+
+          if column = get_column(str, parent)
+            attribute = parent.table[str]
+          elsif (segments = str.split(/_/)).size > 1
+            remainder = []
+            found_assoc = nil
+            while remainder.unshift(segments.pop) && segments.size > 0 && !found_assoc do
+              if found_assoc = get_association(segments.join('_'), parent)
+                join = build_or_find_association(found_assoc.name, parent)
+                attribute = get_attribute(remainder.join('_'), join)
+              end
+            end
+          end
+
+          attribute
+        end
+
+        def get_column(str, parent = @base)
+          klassify(parent).columns_hash[str]
+        end
+
+        def get_association(str, parent = @base)
+          klassify(parent).reflect_on_all_associations.detect {|a| a.name.to_s == str}
+        end
+
+        def join_dependency(relation)
+          if relation.respond_to?(:join_dependency) # MetaWhere will enable this
+            relation.join_dependency
+          else
+            build_join_dependency(relation)
+          end
+        end
+
+        def build_join_dependency(relation)
+          buckets = relation.joins_values.group_by do |join|
+            case join
+            when String
+              'string_join'
+            when Hash, Symbol, Array
+              'association_join'
+            when ActiveRecord::Associations::JoinDependency::JoinAssociation
+              'stashed_join'
+            when Arel::Nodes::Join
+              'join_node'
+            else
+              raise 'unknown class: %s' % join.class.name
+            end
+          end
+
+          association_joins         = buckets['association_join'] || []
+          stashed_association_joins = buckets['stashed_join'] || []
+          join_nodes                = buckets['join_node'] || []
+          string_joins              = (buckets['string_join'] || []).map { |x|
+            x.strip
+          }.uniq
+
+          join_list = relation.send :custom_join_ast, relation.table.from(relation.table), string_joins
+
+          join_dependency = JoinDependency.new(
+            relation.klass,
+            association_joins,
+            join_list
+          )
+
+          join_nodes.each do |join|
+            join_dependency.table_aliases[join.left.name.downcase] = 1
+          end
+
+          join_dependency.graft(*stashed_association_joins)
+        end
+
+        def build_or_find_association(name, parent = @base)
+          found_association = @join_dependency.join_associations.detect do |assoc|
+            assoc.reflection.name == name &&
+            assoc.parent == parent
+          end
+          unless found_association
+            @join_dependency.send(:build, name.to_sym, parent, Arel::Nodes::OuterJoin)
+            found_association = @join_dependency.join_associations.last
+            # Leverage the stashed association functionality in AR
+            @object = @object.joins(found_association)
+          end
+
+          found_association
+        end
+
+      end
+    end
+  end
+end

data/lib/ransack/configuration.rb

@@ -0,0 +1,39 @@
+require 'ransack/constants'
+require 'ransack/predicate'
+
+module Ransack
+  module Configuration
+
+    mattr_accessor :predicates
+    self.predicates = {}
+
+    def self.predicate_keys
+      predicates.keys.sort {|a,b| b.length <=> a.length}
+    end
+
+    def configure
+      yield self
+    end
+
+    def add_predicate(name, opts = {})
+      name = name.to_s
+      opts[:name] = name
+      compounds = opts.delete(:compounds)
+      compounds = true if compounds.nil?
+      opts[:arel_predicate] = opts[:arel_predicate].to_s
+
+      self.predicates[name] = Predicate.new(opts)
+
+      ['_any', '_all'].each do |suffix|
+        self.predicates[name + suffix] = Predicate.new(
+          opts.merge(
+            :name => name + suffix,
+            :arel_predicate => opts[:arel_predicate] + suffix,
+            :compound => true
+          )
+        )
+      end if compounds
+    end
+
+  end
+end

data/lib/ransack/constants.rb

@@ -0,0 +1,23 @@
+module Ransack
+  module Constants
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+    AREL_PREDICATES = %w(eq not_eq matches does_not_match lt lteq gt gteq in not_in)
+
+    DERIVED_PREDICATES = [
+      ['cont', {:arel_predicate => 'matches', :formatter => proc {|v| "%#{v}%"}}],
+      ['not_cont', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "%#{v}%"}}],
+      ['start', {:arel_predicate => 'matches', :formatter => proc {|v| "#{v}%"}}],
+      ['not_start', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "#{v}%"}}],
+      ['end', {:arel_predicate => 'matches', :formatter => proc {|v| "%#{v}"}}],
+      ['not_end', {:arel_predicate => 'does_not_match', :formatter => proc {|v| "%#{v}"}}],
+      ['true', {:arel_predicate => 'eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}}],
+      ['false', {:arel_predicate => 'eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| !v}}],
+      ['present', {:arel_predicate => 'not_eq_all', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| [nil, '']}}],
+      ['blank', {:arel_predicate => 'eq_any', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| [nil, '']}}],
+      ['null', {:arel_predicate => 'eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| nil}}],
+      ['not_null', {:arel_predicate => 'not_eq', :compounds => false, :type => :boolean, :validator => proc {|v| TRUE_VALUES.include?(v)}, :formatter => proc {|v| nil}}]
+    ]
+  end
+end

data/lib/ransack/context.rb

@@ -0,0 +1,152 @@
+module Ransack
+  class Context
+    attr_reader :search, :object, :klass, :base, :engine, :arel_visitor
+
+    class << self
+
+      def for(object)
+        context = Class === object ? for_class(object) : for_object(object)
+        context or raise ArgumentError, "Don't know what context to use for #{object}"
+      end
+
+      def for_class(klass)
+        if klass < ActiveRecord::Base
+          Adapters::ActiveRecord::Context.new(klass)
+        end
+      end
+
+      def for_object(object)
+        case object
+        when ActiveRecord::Relation
+          Adapters::ActiveRecord::Context.new(object.klass)
+        end
+      end
+
+      def can_accept?(object)
+        method_defined? DISPATCH[object.class]
+      end
+
+    end
+
+    def initialize(object)
+      @object = object.scoped
+      @klass = @object.klass
+      @join_dependency = join_dependency(@object)
+      @base = @join_dependency.join_base
+      @engine = @base.arel_engine
+      @arel_visitor = Arel::Visitors.visitor_for @engine
+      @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
+      @attributes = Hash.new do |hash, key|
+        if attribute = get_attribute(key.to_s)
+          hash[key] = attribute
+        end
+      end
+    end
+
+    # Convert a string representing a chain of associations and an attribute
+    # into the attribute itself
+    def contextualize(str)
+      @attributes[str]
+    end
+
+    def traverse(str, base = @base)
+      str ||= ''
+
+      if (segments = str.split(/_/)).size > 0
+        association_parts = []
+        found_assoc = nil
+        while !found_assoc && segments.size > 0 && association_parts << segments.shift do
+          if found_assoc = get_association(association_parts.join('_'), base)
+            base = traverse(segments.join('_'), found_assoc.klass)
+          end
+        end
+        raise ArgumentError, "No association matches #{str}" unless found_assoc
+      end
+
+      klassify(base)
+    end
+
+    def association_path(str, base = @base)
+      base = klassify(base)
+      str ||= ''
+      path = []
+      segments = str.split(/_/)
+      association_parts = []
+      if (segments = str.split(/_/)).size > 0
+        while segments.size > 0 && !base.columns_hash[segments.join('_')] && association_parts << segments.shift do
+          if found_assoc = get_association(association_parts.join('_'), base)
+            path += association_parts
+            association_parts = []
+            base = klassify(found_assoc)
+          end
+        end
+      end
+
+      path.join('_')
+    end
+
+    def searchable_columns(str = '')
+      traverse(str).column_names
+    end
+
+    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.apply_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