outoftime-record_filter 0.1.0

data/Rakefile

@@ -0,0 +1,24 @@
+ENV['RUBYOPT'] = '-W1'
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+FileList['tasks/**/*.rake'].each { |file| load file }
+
+task :default => :spec
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'record_filter'
+    gemspec.summary = 'Pure-ruby criteria API for building complex queries in ActiveRecord'
+    gemspec.email = 'mat@patch.com'
+    gemspec.homepage = 'http://github.com/outoftime/record_filter/tree/master'
+    gemspec.description = 'Pure-ruby criteria API for building complex queries in ActiveRecord'
+    gemspec.authors = ['Mat Brown', 'Aubrey Holland']
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/record_filter/active_record.rb

@@ -0,0 +1,24 @@
+module RecordFilter
+  module ActiveRecordExtension
+    module ClassMethods
+
+      def filter(&block)
+        Filter.new(self, nil, nil, &block)
+      end
+
+      def named_filter(name, &block)
+        DSL::DSL::subclass(self).module_eval do
+          define_method(name, &block)
+        end
+
+        (class << self; self; end).instance_eval do
+          define_method(name.to_s) do |*args|
+            Filter.new(self, name, nil, *args)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, RecordFilter::ActiveRecordExtension::ClassMethods)

data/lib/record_filter/conjunctions.rb

@@ -0,0 +1,96 @@
+module RecordFilter
+  module Conjunctions
+    class Base
+      attr_reader :table_name, :limit, :offset
+
+      def self.create_from(dsl_conjunction, table)
+        result = case dsl_conjunction.type
+          when :any_of: AnyOf.new(table)
+          when :all_of: AllOf.new(table)
+        end
+
+        dsl_conjunction.steps.each do |step|
+          case step
+          when DSL::Restriction 
+            result.add_restriction(step.column, step.operator, step.value, :negated => step.negated)
+          when DSL::Conjunction 
+            result.add_conjunction(create_from(step, table)) 
+          when DSL::Join
+            join = result.add_join_on_association(step.association)
+            result.add_conjunction(create_from(step.conjunction, join.right_table))
+          when DSL::Limit
+            result.add_limit_and_offset(step.limit, step.offset)
+          when DSL::Order
+            result.add_order(step.column, step.direction)
+          end
+        end
+        result
+      end
+
+      def initialize(table, restrictions = nil, joins = nil)
+        @table = table
+        @table_name = table.table_alias
+        @restrictions = restrictions || []
+        @joins = joins || []
+      end
+
+      def add_restriction(column_name, operator, value, options={})
+        restriction_class = "RecordFilter::Restrictions::#{operator.to_s.camelize}".constantize
+        restriction = restriction_class.new("#{@table_name}.#{column_name}", value, options)
+        self << restriction
+        restriction
+      end
+
+      def add_conjunction(conjunction)
+        self << conjunction
+        conjunction
+      end
+
+      def add_join_on_association(association_name)
+        @table.join_association(association_name)
+      end
+      
+      def add_order(column, direction)
+        @table.order_column(column, direction)
+      end
+
+      def add_limit_and_offset(limit, offset)
+        @limit, @offset = limit, offset
+      end
+
+      def <<(restriction)
+        @restrictions << restriction
+      end
+
+      def to_conditions
+        if @restrictions.empty?
+          nil
+        elsif @restrictions.length == 1
+          @restrictions.first.to_conditions
+        else
+          @restrictions.map do |restriction|
+            conditions = restriction.to_conditions
+            conditions[0] = "(#{conditions[0]})"
+            conditions
+          end.inject do |conditions, new_conditions|
+            conditions.first << " #{conjunctor} #{new_conditions.shift}"
+            conditions.concat(new_conditions)
+            conditions
+          end
+        end
+      end
+    end
+
+    class AnyOf < Base
+      def conjunctor
+        'OR'
+      end
+    end
+
+    class AllOf < Base
+      def conjunctor
+        'AND'
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/conjunction.rb

@@ -0,0 +1,47 @@
+module RecordFilter
+  module DSL
+    class Conjunction
+
+      attr_reader :type, :steps
+
+      DEFAULT_VALUE = Object.new
+
+      def initialize(type=:all_of)
+        @type, @steps = type, []
+      end
+
+      def add_restriction(column, value, negated)
+        @steps << (restriction = Restriction.new(column, negated))
+        if value == DEFAULT_VALUE
+          return restriction
+        elsif value.nil?
+          restriction.is_null
+        else
+          restriction.equal_to(value)
+        end
+        nil
+      end
+
+      def add_conjunction(type, &block)
+        dsl = ConjunctionDSL.new(Conjunction.new(type))
+        dsl.instance_eval(&block) if block
+        @steps << dsl.conjunction
+      end
+
+      def add_join(association, &block)
+        dsl = ConjunctionDSL.new
+        dsl.instance_eval(&block) if block
+        @steps << (join = Join.new(association, dsl.conjunction))
+        join
+      end
+
+      def add_limit(limit, offset)
+        @steps << Limit.new(limit, offset)
+      end
+
+      def add_order(column, direction)
+        @steps << Order.new(column, direction)
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -0,0 +1,40 @@
+module RecordFilter
+  module DSL
+    class ConjunctionDSL
+
+      attr_reader :conjunction
+
+      def initialize(conjunction=Conjunction.new(:all_of))
+        @conjunction = conjunction
+      end
+
+      # restriction
+      def with(column, value=Conjunction::DEFAULT_VALUE)
+        return @conjunction.add_restriction(column, value, false) # using return just to make it explicit
+      end
+
+      # restriction
+      def without(column, value=Conjunction::DEFAULT_VALUE)
+        return @conjunction.add_restriction(column, value, true) # using return just to make it explicit
+      end
+
+      # conjunction
+      def any_of(&block)
+        @conjunction.add_conjunction(:any_of, &block)
+        nil
+      end
+
+      # conjunction
+      def all_of(&block)
+        @conjunction.add_conjunction(:all_of, &block)
+        nil
+      end
+
+      # join
+      def having(association, &block)
+        join = @conjunction.add_join(association, &block)
+        ConjunctionDSL.new(join.conjunction)
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/dsl.rb

@@ -0,0 +1,42 @@
+module RecordFilter
+  module DSL
+    class DSL < ConjunctionDSL
+
+      SUBCLASSES = Hash.new do |h, k|
+        h[k] = Class.new(DSL)
+      end
+
+      class << self
+        def create(clazz)
+          subclass(clazz).new
+        end
+
+        def subclass(clazz)
+          SUBCLASSES[clazz.name.to_sym]
+        end
+      end
+
+      # This method can take two forms:
+      # limit(offset, limit), or
+      # limit(limit)
+      def limit(offset_or_limit, limit=nil)
+        if limit
+          @conjunction.add_limit(limit, offset_or_limit)
+        else
+          @conjunction.add_limit(offset_or_limit, nil)
+        end
+        nil
+      end
+
+      # This method can take two forms, as shown below.
+      # order :permalink
+      # order :permalink, :desc
+      # order :photo => :path, :desc
+      # order :photo => { :comment => :id }, :asc
+      def order(column, direction=:asc)
+        @conjunction.add_order(column, direction)
+        nil
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/join.rb

@@ -0,0 +1,12 @@
+module RecordFilter
+  module DSL
+    class Join
+
+      attr_reader :association, :conjunction
+
+      def initialize(association, conjunction)
+        @association, @conjunction = association, conjunction
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/limit.rb

@@ -0,0 +1,12 @@
+module RecordFilter
+  module DSL
+    class Limit
+
+      attr_reader :limit, :offset
+
+      def initialize(limit, offset)
+        @limit, @offset = limit, offset
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/order.rb

@@ -0,0 +1,12 @@
+module RecordFilter
+  module DSL
+    class Order
+
+      attr_reader :column, :direction
+
+      def initialize(column, direction)
+        @column, @direction = column, direction
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/restriction.rb

@@ -0,0 +1,20 @@
+module RecordFilter
+  module DSL
+    class Restriction
+
+      attr_reader :column, :negated, :operator, :value
+
+      def initialize(column, negated)
+        @column, @negated, @operator = column, negated, nil
+      end
+
+      [:equal_to, :is_null, :less_than, :greater_than, :in, :between].each do |operator|
+        define_method(operator) do |*args|
+          @value = args[0] 
+          @operator = operator
+          self
+        end
+      end
+    end
+  end
+end

data/lib/record_filter/dsl.rb

@@ -0,0 +1,6 @@
+%w(conjunction conjunction_dsl dsl join limit order restriction).each { |file| require File.join(File.dirname(__FILE__), 'dsl', file) }
+
+module RecordFilter
+  module DSL
+  end
+end

data/lib/record_filter/filter.rb

@@ -0,0 +1,46 @@
+module RecordFilter
+  class Filter
+
+    delegate :inspect, :to => :loaded_data
+
+    def initialize(clazz, named_filter, combine_conjunction, *args, &block)
+      @clazz = clazz
+
+      @dsl = dsl_for_named_filter(@clazz, named_filter)
+      @dsl.instance_eval(&block) if block
+      @dsl.send(named_filter, *args) if named_filter && @dsl.respond_to?(named_filter)
+      @dsl.conjunction.steps.unshift(combine_conjunction.steps).flatten! if combine_conjunction
+    end
+
+    def filter(&block)
+      Filter.new(@clazz, nil, @dsl.conjunction, &block)
+    end
+
+    def method_missing(method, *args, &block)
+      if @clazz.respond_to?(method) # UGLY, we need to only pass through things that are named filters.
+        Filter.new(@clazz, method, @dsl.conjunction, *args)
+      else
+        loaded_data.send(method, *args, &block)
+      end
+    end
+
+    protected
+
+    def loaded_data
+      @loaded_data ||= begin
+        query = Query.new(@clazz, @dsl.conjunction)
+        @clazz.scoped(query.to_find_params)
+      end
+    end
+
+    def dsl_for_named_filter(clazz, named_filter)
+      return DSL::DSL.create(clazz) if named_filter.blank?
+      while (clazz)
+        dsl = DSL::DSL::SUBCLASSES.has_key?(clazz.name.to_sym) ? DSL::DSL::SUBCLASSES[clazz.name.to_sym] : nil
+        return DSL::DSL.create(clazz) if dsl && dsl.instance_methods(false).include?(named_filter.to_s)
+        clazz = clazz.superclass
+      end
+      nil
+    end
+  end
+end

data/lib/record_filter/join.rb

@@ -0,0 +1,17 @@
+module RecordFilter
+  class Join
+    attr_reader :left_table, :right_table
+
+    def initialize(left_table, right_table, join_predicate)
+      @left_table, @right_table, @join_predicate =
+        left_table, right_table, join_predicate
+    end
+
+    def to_sql
+      predicate_sql = @join_predicate.map do |left_column, right_column|
+        "#{@left_table.table_alias}.#{left_column} = #{@right_table.table_alias}.#{right_column}"
+      end * ' AND '
+      "INNER JOIN #{@right_table.table_name} AS #{@right_table.table_alias} ON #{predicate_sql}"
+    end
+  end
+end

data/lib/record_filter/order.rb

@@ -0,0 +1,24 @@
+module RecordFilter
+  class Order
+    attr_reader :column, :direction, :table
+
+    def initialize(column, direction, table)
+      @column, @direction, @table = column, direction, table
+    end
+
+    def to_sql
+      dir = case @direction
+        when :asc then 'ASC'
+        when :desc then 'DESC'
+      end
+      
+      table, column = @table, @column
+      while column.is_a?(Hash)
+        table = table.join_association(column.keys[0]).right_table
+        column = column.values[0]
+      end
+
+      "#{table.table_name}.#{column} #{dir}"
+    end
+  end
+end

data/lib/record_filter/query.rb

@@ -0,0 +1,20 @@
+module RecordFilter
+  class Query
+
+    def initialize(clazz, dsl_conjunction)
+      @table = RecordFilter::Table.new(clazz)
+      @conjunction = RecordFilter::Conjunctions::Base.create_from(dsl_conjunction, @table)
+    end
+
+    def to_find_params
+      params = { :conditions => @conjunction.to_conditions }
+      joins = @table.all_joins
+      params[:joins] = joins.map { |join| join.to_sql } * ' ' unless joins.empty?
+      orders = @table.all_orders
+      params[:order] = orders.map { |order| order.to_sql } * ', ' unless orders.empty?
+      params[:limit] = @conjunction.limit if @conjunction.limit
+      params[:offset] = @conjunction.offset if @conjunction.offset
+      params
+    end
+  end
+end

data/lib/record_filter/restrictions.rb

@@ -0,0 +1,69 @@
+module RecordFilter
+  module Restrictions
+    class Base
+      def initialize(column_name, value, options={})
+        @column_name, @value, @negated = column_name, value, !!options.delete(:negated)
+      end
+
+      def to_conditions
+        @value.nil? ? [to_sql] : [to_sql, @value]
+      end
+
+      def to_sql
+        @negated ? to_negative_sql : to_positive_sql
+      end
+
+      def to_negative_sql
+        "!(#{to_positive_sql})"
+      end
+    end
+
+    class EqualTo < Base
+      def to_positive_sql
+        "#{@column_name} = ?"
+      end
+
+      def to_negative_sql
+        "#{@column_name} != ?"
+      end
+    end
+
+    class IsNull < Base
+      def to_positive_sql
+        "#{@column_name} IS NULL"
+      end
+
+      def to_negative_sql
+        "#{@column_name} IS NOT NULL"
+      end
+    end
+
+    class LessThan < Base
+      def to_positive_sql
+        "#{@column_name} < ?"
+      end
+    end
+
+    class GreaterThan < Base
+      def to_positive_sql
+        "#{@column_name} > ?"
+      end
+    end
+
+    class In < Base
+      def to_positive_sql
+        "#{@column_name} IN (?)"
+      end
+
+      def to_negative_sql
+        "#{@column_name} NOT IN (?)"
+      end
+    end
+
+    class Between < Base
+      def to_conditions
+        ["#{@column_name} #{'NOT ' if @negated}BETWEEN ? AND ?", @value.first, @value.last]
+      end
+    end
+  end
+end

data/lib/record_filter/table.rb

@@ -0,0 +1,93 @@
+module RecordFilter
+  class Table
+    attr_reader :table_alias
+
+    def initialize(model_class, table_alias = nil)
+      @model_class = model_class
+      @aliased = !table_alias.nil?
+      @table_alias = table_alias || model_class.quoted_table_name
+      @joins_cache = {}
+      @joins = []
+      @orders = []
+    end
+
+    def table_name
+      @model_class.quoted_table_name
+    end
+
+    def join_association(association_name)
+      @joins_cache[association_name] ||=
+        begin
+          association = @model_class.reflect_on_association(association_name)
+          case association.macro
+          when :belongs_to, :has_many, :has_one
+            simple_join(association)
+          when :has_and_belongs_to_many
+            compound_join(association)
+          end
+        end
+    end
+
+    def all_joins
+      @joins + @joins.inject([]) do |child_joins, join|
+        child_joins.concat(join.right_table.all_joins)
+        child_joins
+      end
+    end
+
+    def order_column(column, direction)
+      @orders << Order.new(column, direction, self)
+    end
+
+    def all_orders
+      @orders + @joins.inject([]) do |child_orders, join|
+        child_orders.concat(join.right_table.all_orders)
+        child_orders
+      end
+    end
+
+    private
+
+    def simple_join(association)
+      join_predicate =
+        case association.macro
+        when :belongs_to
+          { association.primary_key_name.to_sym => :id }
+        when :has_many, :has_one
+          { :id => association.primary_key_name.to_sym }
+        end
+      join_table = Table.new(association.klass, alias_for_association(association))
+      @joins << join = Join.new(self, join_table, join_predicate)
+      join
+    end
+
+    def compound_join(association)
+      pivot_join_predicate = { :id => association.primary_key_name.to_sym }
+      table_name = @model_class.connection.quote_table_name(association.options[:join_table])
+      pivot_table = PivotTable.new(table_name, "__#{alias_for_association(association)}")
+      pivot_join = Join.new(self, pivot_table, pivot_join_predicate)
+      join_predicate = { association.association_foreign_key => :id }
+      join_table = Table.new(association.klass, alias_for_association(association))
+      pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate)
+      @joins << pivot_join
+      join
+    end
+
+    protected
+
+    def alias_for_association(association)
+      "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name}"
+    end
+  end
+
+  class PivotTable < Table
+    attr_reader :table_name, :joins
+
+    def initialize(table_name, table_alias = table_name)
+      @table_name, @table_alias = table_name, table_alias
+      @joins_cache = {}
+      @joins = []
+      @orders = []
+    end
+  end
+end

data/lib/record_filter.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gem 'activerecord', '~> 2.2'
+require 'active_record'
+
+%w(active_record query table conjunctions restrictions filter join order dsl).each do |file|
+  require File.join(File.dirname(__FILE__), 'record_filter', file)
+end
+
+module RecordFilter
+end