record_filter 0.9.12

data/lib/record_filter/restrictions.rb

@@ -0,0 +1,97 @@
+module RecordFilter
+  module Restrictions # :nodoc: all
+    class Base
+      def initialize(column_name, value, options={})
+        @column_name, @value, @negated = column_name, value, !!options.delete(:negated)
+        @value = @value.id if @value.kind_of?(ActiveRecord::Base)
+      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
+        "NOT (#{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} < #{@value.nil? ? 'NULL' : '?'}"
+      end
+    end
+
+    class LessThanOrEqualTo < Base
+      def to_positive_sql
+        "#{@column_name} <= #{@value.nil? ? 'NULL' : '?'}"
+      end
+    end
+
+    class GreaterThan < Base
+      def to_positive_sql
+        "#{@column_name} > #{@value.nil? ? 'NULL' : '?'}"
+      end
+    end
+
+    class GreaterThanOrEqualTo < Base
+      def to_positive_sql
+        "#{@column_name} >= #{@value.nil? ? 'NULL' : '?'}"
+      end
+    end
+
+    class In < Base
+      def to_positive_sql
+        "#{@column_name} IN (?)"
+      end
+
+      def to_negative_sql
+        "#{@column_name} NOT IN (?)"
+      end
+
+      def to_conditions
+        # Need to put in the value even if it's null in this case.
+        [to_sql, @value]
+      end
+    end
+
+    class Between < Base
+      def to_conditions
+        ["#{@column_name} #{'NOT ' if @negated}BETWEEN ? AND ?", @value.first, @value.last]
+      end
+    end
+
+    class Like < Base
+      def to_positive_sql
+        "#{@column_name} LIKE ?"
+      end
+
+      def to_negative_sql
+        "#{@column_name} NOT LIKE ?"
+      end
+    end
+  end
+end

data/lib/record_filter/table.rb

@@ -0,0 +1,172 @@
+module RecordFilter
+  class Table # :nodoc: all
+    attr_reader :table_alias, :orders, :group_bys, :model_class
+
+    def initialize(model_class, table_alias = nil)
+      @model_class = model_class
+      @aliased = !table_alias.nil?
+      @table_alias = table_alias || table_name
+      @joins_cache = {}
+      @joins = []
+      @orders = []
+      @group_bys = []
+    end
+
+    def table_name
+      @table_name ||= @model_class.quoted_table_name
+    end
+
+    def join_association(association_name, options={})
+      association_name = association_name.to_sym
+      join_type = options[:join_type] || :inner
+      cache_key = options[:alias] || association_name
+      @joins_cache[cache_key] ||= begin
+        association = @model_class.reflect_on_association(association_name)
+        if association.nil?
+          raise AssociationNotFoundException.new("The association #{association_name} was not found on #{@model_class.name}.")
+        end
+        if (association.options[:through])
+          through_association = @model_class.reflect_on_association(association.options[:through])
+
+          through_join = join_association(
+            association.options[:through], 
+            :join_type => join_type, 
+            :type_restriction => association.options[:source_type], 
+            :source => association.options[:source])
+
+          through_join.right_table.join_association(
+            association.options[:source] || association_name, 
+            :join_type => join_type,
+            :alias => options[:alias],
+            :join_class => association.options[:source_type])
+        else
+          case association.macro
+          when :belongs_to, :has_many, :has_one
+            simple_join(association, join_type, options)
+          when :has_and_belongs_to_many
+            compound_join(association, join_type, options)
+          else raise InvalidJoinException.new("I don't know how to join on an association of type #{association.macro}.")
+          end
+        end
+      end
+    end
+
+    def join_class(clazz, join_type, table_alias, conditions)
+      use_alias = table_alias || alias_for_class(clazz)
+      @joins_cache[use_alias] ||= 
+        begin
+          join_table = Table.new(clazz, use_alias)
+          @joins << (join = Join.new(self, join_table, conditions, join_type))
+          join
+        end
+    end
+
+    def join_key_for(key)
+      case key
+      when Class then alias_for_class(key)
+      when String, Symbol then key
+      end
+    end
+
+    def find_join(key)
+      @joins_cache[join_key_for(key)]
+    end
+
+    def find_join!(key)
+      join = find_join(key)
+      raise InvalidJoinException.new("The join #{key} was not found.") unless join
+      join
+    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 group_by_column(column)
+      @group_bys << GroupBy.new(column, self)
+    end
+
+    def has_column(column_name)
+      @model_class.column_names.include?(column_name.to_s)
+    end
+
+    private
+
+    def simple_join(association, join_type, options)
+      join_predicate = simple_join_predicate(association)
+
+      if association.options[:as]
+        join_predicate << DSL::Restriction.new(association.options[:as].to_s + '_type').equal_to(association.active_record.base_class.name)
+      end
+
+      if options[:type_restriction] && options[:source]
+        foreign_type = association.klass.reflect_on_association(options[:source]).options[:foreign_type]
+        join_predicate << DSL::Restriction.new(foreign_type).equal_to(options[:type_restriction])
+      end
+
+      clazz = options[:join_class].nil? ? association.klass : options[:join_class].constantize
+
+      join_table = Table.new(clazz, options[:alias] || alias_for_association(association))
+      @joins << join = Join.new(self, join_table, join_predicate, join_type)
+      join
+    end
+
+    def simple_join_predicate(association)
+      join_predicate =
+        case association.macro
+        when :belongs_to
+          [{ association.options[:foreign_key] || association.primary_key_name.to_sym => @model_class.primary_key }]
+        when :has_many, :has_one
+          [{ association.options[:primary_key] || @model_class.primary_key => association.primary_key_name.to_sym }]
+        else raise InvalidJoinException.new("I don't know how to do a simple join on an association of type #{association.macro}.")
+        end
+    end
+
+    def compound_join(association, join_type, options)
+      pivot_join_predicate = [{ @model_class.primary_key => association.primary_key_name.to_sym }]
+      table_name = @model_class.connection.quote_table_name(association.options[:join_table])
+      pivot_table = PivotTable.new(table_name, association, "__#{options[:alias] || alias_for_association(association)}")
+      pivot_join = Join.new(self, pivot_table, pivot_join_predicate, join_type)
+      join_predicate = [{ association.association_foreign_key.to_sym => @model_class.primary_key }]
+      join_table = Table.new(association.klass, options[:alias] || alias_for_association(association))
+      pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate, join_type)
+      @joins << pivot_join
+      join
+    end
+
+    protected
+
+    def alias_for_association(association)
+      @alias_cache ||= {} 
+      @alias_cache[association.name] ||= 
+        "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name.to_s.underscore}"
+    end
+
+    alias_method :alias_for_class, :alias_for_association
+  end
+
+  class PivotTable < Table # :nodoc: all
+    attr_reader :table_name, :joins
+
+    def initialize(table_name, association, table_alias = table_name)
+      @table_name, @table_alias = table_name, table_alias
+      @joins_cache = {}
+      @joins = []
+      @orders = []
+      @group_bys = []
+      @primary_key = association.primary_key_name.to_sym
+      @foreign_key = association.association_foreign_key.to_sym
+    end
+
+    def has_column(column_name)
+      [@primary_key, @foreign_key].include?(column_name.to_sym)
+    end
+  end
+end

data/lib/record_filter.rb

@@ -0,0 +1,35 @@
+require 'active_record'
+
+%w(active_record column_parser query table conjunctions restrictions restriction_factory filter join order group_by dsl).each do |file|
+  require File.join(File.dirname(__FILE__), 'record_filter', file)
+end
+
+# The base-level namespace for the record_filter code. See RecordFilter::ActiveRecordExtension::ClassMethods
+# for a description of the public API.
+module RecordFilter
+
+  # An exception that is raised when an implicit join is attempted on an association 
+  # that does not exist.
+  class AssociationNotFoundException < StandardError; end
+  
+  # An exception that is raised when attempting to place restrictions or specify an
+  # explicit join on a column that doesn't exist.
+  class ColumnNotFoundException < StandardError; end
+
+  # An exception that is raised when operations such as limit, order, group_by, or
+  # on are called out of context.
+  class InvalidFilterException < StandardError; end
+
+  # An exception that is raised when attempting to create a named filter with a name that
+  # already exists in the class it is created on or one of its superclasses.
+  class InvalidFilterNameException < StandardError; end
+
+  # An exception that is raised when no columns are privided to specify an explicit join
+  # or when the join names are incorrect.
+  class InvalidJoinException < StandardError; end
+
+  # An exception raised in the case where a named filter is called from within a filter
+  # and the named filter does not exist.
+  class NamedFilterNotFoundException < StandardError; end
+end
+

data/record_filter.gemspec

@@ -0,0 +1,108 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{record_filter}
+  s.version = "0.9.12"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aubrey Holland", "Mat Brown"]
+  s.date = %q{2009-09-13}
+  s.description = %q{RecordFilter is a Pure-ruby criteria API for building complex queries in ActiveRecord. It supports queries that are built on the fly as well as named filters that can be added to objects and chained to create complex queries. It also gets rid of the nasty hard-coded SQL that shows up in most ActiveRecord code with a clean API that makes queries simple and intuitive to build.}
+  s.email = %q{aubreyholland@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "README.rdoc",
+     "Rakefile",
+     "TODO",
+     "VERSION.yml",
+     "config/roodi.yml",
+     "lib/record_filter.rb",
+     "lib/record_filter/active_record.rb",
+     "lib/record_filter/column_parser.rb",
+     "lib/record_filter/conjunctions.rb",
+     "lib/record_filter/dsl.rb",
+     "lib/record_filter/dsl/class_join.rb",
+     "lib/record_filter/dsl/conjunction.rb",
+     "lib/record_filter/dsl/conjunction_dsl.rb",
+     "lib/record_filter/dsl/dsl.rb",
+     "lib/record_filter/dsl/dsl_factory.rb",
+     "lib/record_filter/dsl/group_by.rb",
+     "lib/record_filter/dsl/join.rb",
+     "lib/record_filter/dsl/join_condition.rb",
+     "lib/record_filter/dsl/join_dsl.rb",
+     "lib/record_filter/dsl/limit.rb",
+     "lib/record_filter/dsl/named_filter.rb",
+     "lib/record_filter/dsl/order.rb",
+     "lib/record_filter/dsl/restriction.rb",
+     "lib/record_filter/filter.rb",
+     "lib/record_filter/group_by.rb",
+     "lib/record_filter/join.rb",
+     "lib/record_filter/order.rb",
+     "lib/record_filter/query.rb",
+     "lib/record_filter/restriction_factory.rb",
+     "lib/record_filter/restrictions.rb",
+     "lib/record_filter/table.rb",
+     "record_filter.gemspec",
+     "script/console",
+     "spec/active_record_spec.rb",
+     "spec/exception_spec.rb",
+     "spec/explicit_join_spec.rb",
+     "spec/implicit_join_spec.rb",
+     "spec/limits_and_ordering_spec.rb",
+     "spec/models.rb",
+     "spec/named_filter_spec.rb",
+     "spec/proxying_spec.rb",
+     "spec/restrictions_spec.rb",
+     "spec/select_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/test.db",
+     "tasks/db.rake",
+     "tasks/rcov.rake",
+     "tasks/spec.rake",
+     "test/performance_test.rb",
+     "test/test.db"
+  ]
+  s.homepage = %q{http://github.com/aub/record_filter}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{record-filter}
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{An ActiveRecord query API for replacing SQL with awesome}
+  s.test_files = [
+    "spec/active_record_spec.rb",
+     "spec/exception_spec.rb",
+     "spec/explicit_join_spec.rb",
+     "spec/implicit_join_spec.rb",
+     "spec/limits_and_ordering_spec.rb",
+     "spec/models.rb",
+     "spec/named_filter_spec.rb",
+     "spec/proxying_spec.rb",
+     "spec/restrictions_spec.rb",
+     "spec/select_spec.rb",
+     "spec/spec_helper.rb",
+     "test/performance_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/script/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'spec', 'spec_helper')
+
+require 'logger'
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+IRB.start

data/spec/active_record_spec.rb

@@ -0,0 +1,211 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'active record options' do
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end
+
+  describe 'for has_many' do
+    describe 'using class_name' do
+      before do
+        Blog.filter do
+          having(:stories).with(:permalink, 'ack')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Blog.last_find[:conditions].should == [%q(blogs__stories.permalink = ?), 'ack']
+      end
+
+      it 'should create the correct join' do
+        Blog.last_find[:joins].should == [%q(INNER JOIN "news_stories" AS blogs__stories ON "blogs".id = blogs__stories.blog_id)]
+      end
+    end
+
+    describe 'using foreign_key' do
+      before do
+        Blog.filter do
+          having(:special_posts).with(:permalink, 'eek')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Blog.last_find[:conditions].should == [%q(blogs__special_posts.permalink = ?), 'eek']
+      end
+
+      it 'should create the correct join' do
+        Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__special_posts ON "blogs".id = blogs__special_posts.special_blog_id)]
+      end
+    end
+
+    describe 'using primary_key' do
+      before do
+        Blog.filter do
+          having(:special_public_posts).with(:permalink, 'oooh')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Blog.last_find[:conditions].should == [%q(blogs__special_public_posts.permalink = ?), 'oooh']
+      end
+
+      it 'should create the correct join' do
+        Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__special_public_posts ON "blogs".special_id = blogs__special_public_posts.blog_id)]
+      end
+    end
+
+    describe 'using source' do
+      before do
+        Blog.filter do
+          having(:nasty_comments).with(:contents, 'blammo')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Blog.last_find[:conditions].should == [%q(blogs__posts__bad_comments.contents = ?), 'blammo']
+      end
+
+      it 'should create the correct join' do
+        Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "comments" AS blogs__posts__bad_comments ON blogs__posts.id = blogs__posts__bad_comments.post_id)]
+      end
+    end
+
+    describe 'using source_type' do
+      before do
+        Blog.filter do
+          having(:featured_posts).with(:permalink, 'slam dunk')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Blog.last_find[:conditions].should == [%q(blogs__features__featurable.permalink = ?), 'slam dunk']
+      end
+
+      it 'should create the correct join' do
+        Blog.last_find[:joins].should == [%q(INNER JOIN "features" AS blogs__features ON "blogs".id = blogs__features.blog_id AND (blogs__features.featurable_type = 'Post')), %q(INNER JOIN "posts" AS blogs__features__featurable ON blogs__features.featurable_id = blogs__features__featurable.id)]
+      end
+    end
+  end
+
+  describe 'for belongs_to' do
+
+    describe 'using class_name' do
+      before do
+        Post.filter do
+          having(:publication).with(:name, 'NYT')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Post.last_find[:conditions].should == [%q(posts__publication.name = ?), 'NYT'] 
+      end
+
+      it 'should create the correct join' do
+        Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__publication ON "posts".blog_id = posts__publication.id)]
+      end
+    end
+
+    describe 'using class_name when the association has a different name than the class name' do
+      before do
+        AssetAttachment.filter { having(:from).with(:id).gt(1) }.inspect
+      end
+
+      it 'should create the correct condition' do
+        AssetAttachment.last_find[:conditions].should == [%q(asset_attachments__from.id > ?), 1] 
+      end
+
+      it 'should create the correct join' do
+        AssetAttachment.last_find[:joins].should == [%q(INNER JOIN "assets" AS asset_attachments__from ON "asset_attachments".from_id = asset_attachments__from.id)]
+      end
+    end
+
+    describe 'using foreign_key' do
+      before do
+        Post.filter do
+          having(:special_blog).with(:name, 'Larry')
+        end.inspect
+      end
+
+      it 'should create the correct condition' do
+        Post.last_find[:conditions].should == [%q(posts__special_blog.name = ?), 'Larry'] 
+      end
+
+      it 'should create the correct join' do
+        Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__special_blog ON "posts".special_blog_id = posts__special_blog.id)]
+      end
+    end
+  end
+
+  describe 'working with named scopes' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_scope :with_high_id, { :conditions => ['id > 100'] }
+      @blog.named_filter(:published) { with(:published, true) }
+    end
+    
+    it 'should concatenate the filter with the scope correctly' do
+      @blog.with_high_id.published.inspect
+      @blog.last_find[:conditions].should == %q(("blogs".published = 't') AND (id > 100))
+    end
+
+    it 'should concatenate correctly when called in the other order' do
+      @blog.published.with_high_id.inspect
+      @blog.last_find[:conditions].should == %q((id > 100) AND ("blogs".published = 't'))
+    end
+  end
+
+  describe 'working with named scopes when there are a number of joins' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_scope :ads_with_sale, { :joins => :ads, :conditions => ["'ads'.content LIKE ?", '%sale%'] }
+      @blog.named_filter(:with_permalinked_posts) { having(:posts).with(:permalink).is_not_null }
+      @blog.named_filter(:with_offensive_comments) { having(:comments).with(:offensive, true) }
+      @blog.with_permalinked_posts.ads_with_sale.with_offensive_comments.inspect
+    end
+
+    it 'should concatenate the conditions correctly' do
+      @blog.last_find[:conditions].should == %q((blogs__posts__comments.offensive = 't') AND (('ads'.content LIKE '%sale%') AND (blogs__posts.permalink IS NOT NULL)))
+    end
+
+    it 'should concatenate the joins correctly and not throw away my joins like AR usually does' do
+      @blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id), %q(INNER JOIN "ads" ON ads.blog_id = blogs.id)]
+    end
+  end
+
+  describe 'working with named scopes that join to the same table' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_scope :with_crazy_post_permalinks, { :joins => :posts, :conditions => ["'posts'.permalink = ?", 'crazy'] }
+      @blog.named_filter(:with_empty_permalinks) { having(:posts).with(:permalink, nil) } 
+    end
+
+    it 'should concatenate the conditions correctly' do
+      @blog.with_crazy_post_permalinks.with_empty_permalinks.inspect 
+      @blog.last_find[:conditions].should == %q((blogs__posts.permalink IS NULL) AND ('posts'.permalink = 'crazy'))
+    end
+
+    it 'should concatenate the joins correctly' do
+      @blog.with_crazy_post_permalinks.with_empty_permalinks.inspect
+      @blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "posts" ON posts.blog_id = blogs.id)]
+    end
+  end
+
+  describe 'working with default scopes' do
+    describe 'with a simple filter' do
+      before do
+        Article.filter do
+          with(:contents, 'something')
+        end.inspect
+      end
+
+      it 'should use the correct order' do
+        Article.last_find[:order].should == %q(created_at DESC)
+      end
+
+      it 'should use the correct conditions' do
+        pending 'currently the IS NULL condition is added twice.'
+        Article.last_find[:conditions].should == %q((("articles"."created_at" IS NULL) AND ("articles".contents = 'something')))
+      end
+    end
+  end
+end