aub-record_filter 0.9.3 → 0.9.4

data/README.rdoc

@@ -19,6 +19,10 @@ intended to be a getting started guide that should cover the most common uses.
 
   gem install aub-record_filter --source=http://gems.github.com
 
+In Rails, you'll need to add this to your config/environment.rb file:
+
+  config.gem 'aub-record_filter', :lib => 'record_filter', :source => 'http://gems.github.com'
+
 == Using Filters
 
 Given a Blog model having a has_many relationship with a Post model, a simple 
@@ -31,24 +35,27 @@ filter with conditions and joins might look like this.
 
 This could be expressed in ActiveRecord as:
 
-  Blog.find(
-    :all, 
+  Blog.all(
     :joins => :posts, 
-    :conditions => ['posts.permalink IS NULL AND blogs.created_at > ?', 'blog-post', 1.day.ago)
+    :conditions => {
+      :posts => {:permalink => nil},
+      :created_at => 1.day.ago..Time.now
+    }
+  )
 
 and it returns the same result, a list of Blog objects that are the result of the query. This
 type of filter is designed to be created on the fly, but if you have a filter that you would like
 to use in more than one place, it can be added to a class as a named filter. The following example
 creates the same filter as above and executes it:
 
-  class Post < ActiveRecord::Base
-    named_filter(:new_with_nil_permalink) do
+  class Blog < ActiveRecord::Base
+    named_filter(:new_with_unlinked_posts) do
       with(:created_at).greater_than(1.day.ago)
       having(:posts).with(:permalink, nil)
     end
   end
 
-  Post.new_with_nil_permalink
+  Blog.new_with_unlinked_posts
 
 This returns the same result as the example above but with the advantages that it is
 easily reusable and that it can be combined with other named filters to produce a more
@@ -85,13 +92,15 @@ model even if called from a join.
   end
 
   class Post < ActiveRecord::Base
-    named_filter(:recursive_test) do
+    named_filter(:using_other_filter) do
       having(:comments) do
         offensive
       end
     end
   end
 
+  Post.using_other_filter
+
 == Specifying Filters
 
 record_filter supports all of the SQL query abstractions provided by ActiveRecord, specifically:
@@ -125,13 +134,13 @@ the name of the column to restrict. If a second argument is given, it will autom
 be used as the value in an equality condition. The 'with' function will return a Restriction
 object that has methods to specify a number of different conditions and to negate them:
 
-  with(:permalink, 'aardvarks')            # :conditions => ['permalink = ?', 'aardvarks']
-  with(:permalink).equal_to('sheep')       # :conditions => ['permalink = ?', 'sheep']
-  with(:permalink).not.equal_to('cats')    # :conditions => ['permailnk <> ?', 'cats']
+  with(:permalink, 'aardvarks')            # ['permalink = ?', 'aardvarks']
+  with(:permalink).equal_to('sheep')       # ['permalink = ?', 'sheep']
+  with(:permalink).not.equal_to('cats')    # ['permailnk <> ?', 'cats']
 
-  with(:permalink, nil)                    # :conditions => ['permalink IS NULL']
-  with(:permalink).is_null                 # :conditions => ['permalink IS NULL']
-  with(:permalink, nil).not                # :conditions => ['permalink IS NOT NULL']
+  with(:permalink, nil)                    # ['permalink IS NULL']
+  with(:permalink).is_null                 # ['permalink IS NULL']
+  with(:permalink, nil).not                # ['permalink IS NOT NULL']
 
 The following condition types are supported through the Restriction API:
 
@@ -141,8 +150,23 @@ The following condition types are supported through the Restriction API:
 * In
 * Is null
 * Like
+* Negation of all of the above
+
+And here are some examples. See the RDoc page for 
+{DSL::Restriction}[http://aub.github.com/record_filter/rdoc/classes/RecordFilter/DSL/Restriction.html] 
+for more details on how to use them.
+
+  with(:featured_at).greater_than(Time.now)  # ['featured_at > ?', Time.now]
+
+  with(:price).lte(1000)                     # ['price <= ?', 1000]
+
+  with(:created_at).between(time_a..time_b)  # ['created_at BETWEEN ? AND ?', time_a, time_b]
 
-See the RDoc page for {DSL::Restriction}[http://aub.github.com/record_filter/rdoc/classes/RecordFilter/DSL/Restriction.html] for specifics on how to use these.
+  with(:id).in([1, 2, 3])                    # ['id in (?)', [1, 2, 3]]
+
+  with(:content).like('%easy%')              # ['content LIKE ?', '%easy%']
+
+  with(:content).not.like('%hard%')          # ['content NOT LIKE ?', '%hard%']
 
 === Boolean Operations
 
@@ -156,25 +180,34 @@ joins or other boolean operations. The default operator is all_of.
     with(:permalink, 'ack')
   end
 
-  :conditions => ['id = ? AND permalink = ?', 4, 'ack']
+  # ['id = ? AND permalink = ?', 4, 'ack']
 
   Post.filter do
-    any_of
+    any_of do
       with(:id, 3)
       with(:permalink, 'booya')
     end
   end
 
-  :conditions => ['id = ? OR permalink = ?', 3, 'booya']
+  # ['id = ? OR permalink = ?', 3, 'booya']
 
   Post.filter do
-    none_of
+    none_of do
       with(:id, 2)
       with(:permalink, 'ouch')
     end
   end
 
-  :conditions => ['NOT (id = ? OR permalink = ?', 2, 'ouch']
+  # ['NOT (id = ? OR permalink = ?)', 2, 'ouch']
+
+  Post.filter do
+    not_all_of do
+      with(:id, 1)
+      with(:permalink, 'bonobo')
+    end
+  end
+
+  # ['NOT (id = ? AND permalink = ?)', 1, 'bonobo']
 
 === Joins
 
@@ -257,7 +290,7 @@ order in which they were given.
 
 (The MIT License)
 
-Copyright (c) 2008 Aubrey Holland, Mat Brown
+Copyright (c) 2008-2009 Aubrey Holland, Mat Brown
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,12 +1,10 @@
-# ENV['RUBYOPT'] = '-W1'
-
 require 'rubygems'
 require 'rake'
 require 'rake/testtask'
 
 FileList['tasks/**/*.rake'].each { |file| load file }
 
-task :default => :spec
+task :default => ["db:spec:prepare", :spec]
 
 begin
   require 'jeweler'
@@ -41,6 +39,7 @@ Rake::RDocTask.new do |rdoc|
   rdoc.title = "record_filter #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--webcvs=http://github.com/aub/record_filter/tree/master/'
 end
 
 begin
@@ -56,3 +55,32 @@ rescue LoadError
   puts 'Ruby-prof not available. Profiling tests are disabled.'
 end
 
+begin
+  require 'metric_fu'
+  MetricFu::Configuration.run do |config|
+    #define which metrics you want to use
+    config.metrics  = [:churn, :flog, :flay, :reek, :roodi, :rcov] # :saikuro, :stats
+    config.flay     = { :dirs_to_flay => ['lib']  } 
+    config.flog     = { :dirs_to_flog => ['lib']  }
+    config.reek     = { :dirs_to_reek => ['lib']  }
+    config.roodi    = { :dirs_to_roodi => ['lib'] }
+    config.saikuro  = { :output_directory => 'scratch_directory/saikuro', 
+                        :input_directory => ['lib'],
+                        :cyclo => "",
+                        :filter_cyclo => "0",
+                        :warn_cyclo => "5",
+                        :error_cyclo => "7",
+                        :formater => "text"} #this needs to be set to "text"
+    config.churn    = { :start_date => "1 year ago", :minimum_churn_count => 10}
+    config.rcov     = { :test_files => ['spec/**/*_spec.rb'],
+                        :rcov_opts => ["--sort coverage", 
+                                       "--no-html", 
+                                       "--text-coverage",
+                                       "--no-color",
+                                       "--profile",
+                                       "--exclude spec"]}
+  end
+rescue LoadError
+  puts 'Install metric_fu for code quality metric tests.'
+end
+

data/VERSION.yml

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

data/lib/record_filter/active_record.rb

@@ -59,16 +59,17 @@ module RecordFilter
       #
       # @public
       def named_filter(name, &block)
-        if named_filters.include?(name.to_sym)
+        name = name.to_sym
+        if named_filters.include?(name)
           raise InvalidFilterNameException.new("A named filter with the name #{name} already exists on the class #{self.name}.")
         end
-        local_named_filters << name.to_sym 
+        local_named_filters << name
         DSL::DSLFactory::get_subclass(self).module_eval do
           define_method(name, &block)
         end
 
         (class << self; self; end).instance_eval do
-          define_method(name.to_s) do |*args|
+          define_method(name) do |*args|
             Filter.new(self, name, *args)
           end
         end

data/lib/record_filter/column_parser.rb

@@ -0,0 +1,14 @@
+module RecordFilter
+  module ColumnParser # :nodoc: all
+
+    protected
+
+    def parse_column_in_table(column, table)
+      while column.is_a?(Hash)
+        table = table.join_association(column.keys[0]).right_table
+        column = column.values[0]
+      end
+      [column, table]
+    end
+  end
+end

data/lib/record_filter/conjunctions.rb

@@ -9,6 +9,7 @@ module RecordFilter
           when :all_of then AllOf.new(table)
           when :none_of then NoneOf.new(table)
           when :not_all_of then NotAllOf.new(table)
+          else raise InvalidFilterException.new("An invalid conjunction type of #{dsl_conjunction.type} was used.")
         end
 
         dsl_conjunction.steps.each do |step|
@@ -32,6 +33,7 @@ module RecordFilter
             result.add_group_by(step.column)
           when DSL::NamedFilter
             result.add_named_filter(step.name, step.args)
+          else raise InvalidFilterException.new('And invalid filter step was provided.')
           end
         end
         result
@@ -46,8 +48,7 @@ module RecordFilter
 
       def add_restriction(column_name, operator, value, options={})
         check_column_exists!(column_name)
-        restriction_class = RecordFilter::Restrictions::Base.class_from_operator(operator)
-        restriction = restriction_class.new("#{@table_name}.#{column_name}", value, options)
+        restriction = RestrictionFactory.build(operator, "#{@table_name}.#{column_name}", value, options)
         self << restriction
         restriction
       end
@@ -60,8 +61,7 @@ module RecordFilter
       def add_join_on_association(association_name, join_type)
         table = @table
         while association_name.is_a?(Hash)
-          result = table.join_association(association_name.keys[0], join_type)
-          table = result.right_table
+          table = table.join_association(association_name.keys[0], join_type).right_table
           association_name = association_name.values[0]
         end
         table.join_association(association_name, join_type)

data/lib/record_filter/dsl/dsl.rb

@@ -30,6 +30,24 @@ module RecordFilter
         nil
       end
 
+      # Define an offset for the results returned from the current
+      # filter. This method can only be called from the outermost scope of a filter
+      # (i.e. not inside of a having block, etc.). If it is called multiple times, the
+      # last one will override any others.
+      #
+      # ==== Parameters
+      # offset<Integer>::
+      #   The offset of the query.
+      #
+      # ==== Returns
+      # nil
+      #
+      # @public
+      def offset(offset)
+        @conjunction.add_limit(nil, offset)
+        nil
+      end
+
       # Define an order clause for the current query, with options for specifying
       # both the column to use as well as the direction. This method can only be called
       # in the outermost scope of a filter (i.e. not inside of a having block, etc.).
@@ -51,9 +69,11 @@ module RecordFilter
       # column<Symbol, Hash>::
       #   Specify the column for the ordering. If a symbol is given, it is assumed to represent
       #   a column in the class that is being filtered. With a hash argument, it is possible
-      #   to specify a path to a column in one of the joined tables, as seen above.
+      #   to specify a path to a column in one of the joined tables, as seen above. If a string
+      #   is given and it doesn't match up with a column name, it is used as a literal string
+      #   for ordering.
       # direction<Symbol>::
-      #   Specifies the direction of the join. Should be either :asc or :desc and defaults to :asc.
+      #   Specifies the direction of the order. Should be either :asc or :desc and defaults to :asc.
       #
       # ==== Returns
       # nil
@@ -63,7 +83,7 @@ module RecordFilter
       #   If the direction is neither :asc nor :desc.
       #
       # ==== Alternatives
-      # As described above, it is possible to pass either a symbol or a hash as the first
+      # As described above, it is possible to pass a symbol, a hash or a string as the first
       # argument.
       #
       # @public

data/lib/record_filter/dsl/restriction.rb

@@ -190,7 +190,7 @@ module RecordFilter
       #
       # ==== Parameters
       # value::
-      #   Either a single item or an array of values to form the values to be tested for inclusion.
+      #   Either a single item, an array of values, or a range to form the values to be tested for inclusion.
       #
       # ==== Returns
       # Restriction:: self

data/lib/record_filter/group_by.rb

@@ -1,5 +1,7 @@
 module RecordFilter
   class GroupBy # :nodoc: all
+    include ColumnParser
+
     attr_reader :column, :table
 
     def initialize(column, table)
@@ -7,11 +9,7 @@ module RecordFilter
     end
 
     def to_sql
-      table, column = @table, @column
-      while column.is_a?(Hash)
-        table = table.join_association(column.keys[0]).right_table
-        column = column.values[0]
-      end
+      column, table = parse_column_in_table(@column, @table)
 
       if (table.has_column(column))
         "#{table.table_alias}.#{column}"

data/lib/record_filter/join.rb

@@ -46,9 +46,11 @@ module RecordFilter
       unless @right_table.has_column(dsl_restriction.column)
         raise ColumnNotFoundException.new("The column #{dsl_restriction.column} was not found in the table #{@right_table.table_name}")
       end
-      restriction_class = RecordFilter::Restrictions::Base.class_from_operator(dsl_restriction.operator)
-      restriction = restriction_class.new(
-        "#{@right_table.table_alias}.#{dsl_restriction.column}", dsl_restriction.value, :negated => dsl_restriction.negated)
+      restriction = RestrictionFactory.build(
+        dsl_restriction.operator,
+        "#{@right_table.table_alias}.#{dsl_restriction.column}",
+        dsl_restriction.value,
+        :negated => dsl_restriction.negated)
       @right_table.model_class.merge_conditions(restriction.to_conditions)
     end
 

data/lib/record_filter/order.rb

@@ -1,5 +1,7 @@
 module RecordFilter
   class Order # :nodoc: all
+    include ColumnParser
+
     attr_reader :column, :direction, :table
 
     def initialize(column, direction, table)
@@ -10,19 +12,16 @@ module RecordFilter
       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]
+        else raise InvalidFilterException.new("An invalid order of #{@direction} was specified.") 
       end
 
-      if (!table.has_column(column))
-        raise ColumnNotFoundException.new("The column #{column} was not found in #{table.table_name}.")
-      end
+      column, table = parse_column_in_table(@column, @table)
 
-      "#{table.table_alias}.#{column} #{dir}"
+      if (table.has_column(column))
+        "#{table.table_alias}.#{column} #{dir}"
+      else
+        "#{column} #{dir}"
+      end
     end
   end
 end

data/lib/record_filter/query.rb

@@ -20,15 +20,7 @@ module RecordFilter
         params = {}
         conditions = @conjunction.to_conditions
         params = { :conditions => conditions } if conditions
-        joins = @table.all_joins
-        params[:joins] = joins.map { |join| join.to_sql } unless joins.empty?
-        if (joins.any? { |j| j.requires_distinct_select? })
-          if count_query
-            params[:select] = "DISTINCT #{@table.model_class.quoted_table_name}.#{@table.model_class.primary_key}"
-          else
-            params[:select] = "DISTINCT #{@table.model_class.quoted_table_name}.*"
-          end
-        end
+        add_joins(params, count_query)
         orders = @table.orders
         params[:order] = orders.map { |order| order.to_sql } * ', ' unless orders.empty?
         group_bys = @table.group_bys
@@ -41,6 +33,18 @@ module RecordFilter
 
     protected
 
+    def add_joins(params, count_query)
+      joins = @table.all_joins
+      params[:joins] = joins.map { |join| join.to_sql } unless joins.empty?
+      if (joins.any? { |j| j.requires_distinct_select? })
+        if count_query
+          params[:select] = "DISTINCT #{@table.table_name}.#{@table.model_class.primary_key}"
+        else
+          params[:select] = "DISTINCT #{@table.table_name}.*"
+        end
+      end
+    end
+
     def dsl_for_named_filter(clazz, named_filter)
       return DSL::DSLFactory.create(clazz) if named_filter.blank?
       while (clazz)

data/lib/record_filter/restriction_factory.rb

@@ -0,0 +1,21 @@
+module RecordFilter
+  class RestrictionFactory # :nodoc: all
+
+    OPERATOR_HASH = {
+      :equal_to => Restrictions::EqualTo,
+      :is_null => Restrictions::IsNull,
+      :less_than => Restrictions::LessThan,
+      :less_than_or_equal_to => Restrictions::LessThanOrEqualTo,
+      :greater_than => Restrictions::GreaterThan,
+      :greater_than_or_equal_to => Restrictions::GreaterThanOrEqualTo,
+      :in => Restrictions::In,
+      :between => Restrictions::Between,
+      :like => Restrictions::Like
+    }
+
+    def self.build(operator, column_name, value, options)
+      OPERATOR_HASH[operator].new(column_name, value, options)
+    end
+  end
+end
+

data/lib/record_filter/restrictions.rb

@@ -17,10 +17,6 @@ module RecordFilter
       def to_negative_sql
         "NOT (#{to_positive_sql})"
       end
-
-      def self.class_from_operator(operator)
-        "RecordFilter::Restrictions::#{operator.to_s.camelize}".constantize
-      end
     end
 
     class EqualTo < Base

data/lib/record_filter/table.rb

@@ -5,7 +5,7 @@ module RecordFilter
     def initialize(model_class, table_alias = nil)
       @model_class = model_class
       @aliased = !table_alias.nil?
-      @table_alias = table_alias || model_class.quoted_table_name
+      @table_alias = table_alias || table_name
       @joins_cache = {}
       @joins = []
       @orders = []
@@ -13,7 +13,7 @@ module RecordFilter
     end
 
     def table_name
-      @model_class.quoted_table_name
+      @table_name ||= @model_class.quoted_table_name
     end
 
     def join_association(association_name, join_type=nil, options={})
@@ -41,6 +41,7 @@ module RecordFilter
               simple_join(association, join_type, options)
             when :has_and_belongs_to_many
               compound_join(association, join_type)
+            else raise InvalidJoinException.new("I don't know how to join on an association of type #{association.macro}.")
             end
           end
         end
@@ -77,13 +78,7 @@ module RecordFilter
     private
 
     def simple_join(association, join_type, options)
-      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 }]
-        end
+      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)
@@ -101,6 +96,17 @@ module RecordFilter
       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)
       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])
@@ -116,7 +122,9 @@ module RecordFilter
     protected
 
     def alias_for_association(association)
-      "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name.to_s.downcase}"
+      @alias_cache ||= {} 
+      @alias_cache[association.name] ||= 
+        "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name.to_s.downcase}"
     end
 
     alias_method :alias_for_class, :alias_for_association

data/lib/record_filter.rb

@@ -1,8 +1,8 @@
 require 'rubygems'
-gem 'activerecord', '~> 2.2'
+gem 'activerecord', '~> 2.3'
 require 'active_record'
 
-%w(active_record query table conjunctions restrictions filter join order group_by dsl).each do |file|
+%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
 

data/spec/exception_spec.rb

@@ -34,12 +34,12 @@ describe 'raising exceptions' do
       }.should raise_error(RecordFilter::ColumnNotFoundException)
     end
 
-    it 'should get ColumnNotFoundException for order' do
+    it 'should not get ColumnNotFoundException for order' do
       lambda {
         Post.filter do
-          order(:this_is_not_there, :asc)
+          order('this_is_not_there', :asc)
         end.inspect
-      }.should raise_error(RecordFilter::ColumnNotFoundException)
+      }.should_not raise_error(RecordFilter::ColumnNotFoundException)
     end
 
     it 'should not get ColumnNotFoundException for group_by' do

data/spec/limits_and_ordering_spec.rb

@@ -63,6 +63,50 @@ describe 'filter qualifiers' do
     end
   end
 
+  describe 'offsets' do
+    describe 'simple offset setting' do
+      before do
+        Post.filter do
+          with :published, true
+          offset 10
+        end.inspect
+      end
+
+      it 'should add the offset to the parameters' do
+        Post.last_find[:offset].should == 10
+      end
+    end
+
+    describe 'with multiple calls to offset' do
+      before do
+       Post.filter do
+          offset 5
+          with :published, true
+          offset 6
+        end.inspect
+      end
+
+      it 'should add the offset to the parameters' do
+        Post.last_find[:offset].should == 6 
+      end
+    end
+
+    describe 'offsetting named scopes' do
+      before do
+        @post = Class.new(Post)
+        @post.named_filter(:published_ones) do
+          offset(2)
+          with(:published, false)
+        end
+      end
+
+      it 'should offset the query' do
+        @post.published_ones.inspect
+        @post.last_find[:offset].should == 2
+      end
+    end
+  end
+
   describe 'ordering' do
     describe 'with a simple order supplied' do
       before do
@@ -115,10 +159,24 @@ describe 'filter qualifiers' do
         end.inspect
       end
 
-      it 'should add the limit to the parameters' do
+      it 'should add the order to the parameters' do
         Post.last_find[:order].should == %q(posts__photo.path DESC, "posts".permalink ASC)
       end
     end
+
+    describe 'with the order supplied as a string' do
+      before do
+        Post.filter do
+          with :published, true
+          group_by(:published)
+          order('SUM(id)', :desc)
+        end.inspect
+      end
+
+      it 'should add the order to the query' do
+        Post.last_find[:order].should == %q(SUM(id) DESC)
+      end
+    end
   end
 
   describe 'group_by' do

data/spec/restrictions_spec.rb

@@ -89,6 +89,13 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), nil] }
   end
 
+  it 'should do the right thing for IN filters with a range' do
+    Post.filter do
+      with(:blog_id).in(1..5)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), 1..5] }
+  end
+
   it 'should negate is_not_null conditions correctly' do
     Post.filter do
       with(:blog_id).is_not_null.not

data/test/performance_test.rb

@@ -19,6 +19,7 @@ ActiveRecord::Base.establish_connection(
 @blog.named_filter :somethings do
   having(:ads) do
     with(:content, nil)
+    with(:id).greater_than(25)
   end
   join(Post, :left) do
     on(:id => :blog_id)
@@ -28,6 +29,8 @@ ActiveRecord::Base.establish_connection(
     end
   end
   group_by(:id)
+  limit(10, 100)
+  order(:ads => :id)
 end
 
 10000.times do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors: 
 - Aubrey Holland
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-07 00:00:00 -07:00
+date: 2009-05-09 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,7 @@ files:
 - VERSION.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
@@ -48,6 +49,7 @@ files:
 - 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
 - spec/active_record_spec.rb
@@ -64,7 +66,7 @@ files:
 - spec/test.db
 - test/performance_test.rb
 - test/test.db
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/aub/record_filter/tree/master
 post_install_message: 
 rdoc_options: