dm-core 0.10.1 → 0.10.2

data/CONTRIBUTING

@@ -1,51 +0,0 @@
-# NOTE: This is a work in progress. As of July 24, it applies only to dm-core.
-
-# Contributing to Edge DataMapper
-
-We have now implemented Hoe throughout the DataMapper suite, so there will be a 
-handful of new procedures for contributing to our git repositories. I'll give 
-you a run through of how to set up your machine, and then provide a few 
-commands that should be run before committing or pushing changes.
-
-## Installing and configuring Hoe
-
-The first step is to install hoe. You'll need at least version 1.7.0.
-
-    (sudo) gem install hoe --include-dependencies
-    
-Now you'll need to configure hoe. You'll need to run this from inside of 
-dm-core, or one of the other DataMapper projects.
-
-    rake config_hoe
-    
-The only thing you should need to change is the exclude regular expression, 
-which needs to look like this:
-
-    exclude: !ruby/regexp /tmp$|CVS|\.svn|\.git|.+\.gemspec/
-    
-Now you have the correct setup for contributing.
-
-## Before committing changes
-
-Before you commit changes, you must verify that `Manifest.txt` (the file which 
-contains the names of every file to be included in a gem release) and 
-`[project-name].gemspec` are up to date. We have create a rake task to make 
-this easy:
-
-    rake gemspec
-    
-This will check `Manifest.txt` (using Hoe's `rake check_manifest`) to ensure 
-there are no differences between the files in the project, and those listed in 
-the manifest. If there is a difference, it will display a warning and a list of 
-the differences in `diff` format.
-
-If the changes in the diff are correct, then you can run the following command 
-to update the manifest.
-
-    rake check_manifest | patch
-    
-If there are files you do not want added to the manifest, then you should 
-remove the files from the project, and then run `rake gemspec` again.
-
-If `rake gemspec` says it was successful, then you can proceed with committing 
-and pushing your changes.

data/FAQ

@@ -1,93 +0,0 @@
-:include:QUICKLINKS
-
-= FAQ
-
-=== So where's my :id column?
-
-DataMapper will NOT create an auto-incrementing <tt>:id</tt> key for you 
-automatically, so you'll need to either explicitly create one with
-
-  property :id, Serial
-
-You can choose to use a natural key by doing
-
-  property :slug, String, :key => true
-
-Remember, DataMapper supports multiple keys ("composite keys"), so if your
-model has two or more keys, no big deal
-
-  property :store_id, 	Integer, :key => true
-  property :invoice_id, Integer, :key => true
-
-=== How do I make a model paranoid?
-
-Create a property and make it a ParanoidDateTime or ParanoidBoolean type.
-
-  property :deleted_at, ParanoidDateTime
-  property :deleted,    ParanoidBoolean
-
-All of your calls to <tt>##all()</tt>, <tt>##first()</tt> will be scoped 
-with <tt>:deleted_at => nil</tt> or <tt>:deleted => false</tt>. Plus, 
-you won't see deleted objects in your associations.
-
-=== Does DataMapper do Single Table Inheritance?
-
-This is what the Discriminator data-type is for:
-
-  class Person
-    include DataMapper::Resource
-
-    property :id,   Serial
-    property :type, Discriminator  ## other shared properties here
-  end
-
-  class Salesperson < Person; end
-
-You can claim a column to have the type <tt>Discriminator</tt> and DataMapper will
-automatically drop the class name of the inherited classes into that field of
-the data-store.
-
-=== How do I run my own commands?
-
-  repository.adapter.query("SELECT * FROM users WHERE clue > 0")
-  repository(:integration).adapter.query("SELECT * FROM users WHERE clue > 0")
-
-This does not return any Users (har har), but rather Struct's that will quack
-like Users. They'll be read-only as well.
-
-<tt>repository.adapter.query</tt> shouldn't be used if you aren't expecting a result set
-back.  If you want to just execute something against the database, use
-<tt>repository.adapter.execute</tt> instead.
-
-
-=== Can I get an query log of what DataMapper is issuing?
-
-An example of how to modify an existing logger:
-
-  DataMapper.logger.set_log(STDOUT, :debug)
-
-An example of how to create new logger:
-
-  DataMapper::Logger.new(STDOUT, :info)
-
-To send a message to the DataMapper logger:
-
-  DataMapper.logger.debug("something")
-  DataMapper.logger.info ("something")
-  DataMapper.logger.warn ("something")
-  DataMapper.logger.error("something")
-  DataMapper.logger.fatal("something")
-
-
-=== I want to run the specs, but I have a custom database setup
-
-For example, if you installed MySQL using MacPorts, your socket may be located
-at /opt/local/var/run/mysql5/mysqld.sock instead of /tmp/mysql.sock
-
-In that case, setup an environment variable in your shell before running the
-specs:
-  export MYSQL_SPEC_URI="mysql://localhost/dm_core_test?socket=/opt/local/var/run/mysql5/mysqld.sock"
-  rake spec
-
-Using another kind of database? Note that spec_helper.rb will also look for
-SQLITE3_SPEC_URI AND POSTGRES_SPEC_URI.

data/History.txt

@@ -1,27 +0,0 @@
-=== 0.10.1 / 2009-09-30
-
-* 4 minor enhancements:
-
-  * On Ruby 1.8.7+ allow #pop and #shift in Collection to work with
-    multiple entries.
-  * Added NullOperation condition
-  * Added Resource#destroyed?
-  * Updated ManyToMany::Collection#intermediaries to be public
-
-* 6 bug fixes:
-
-  * Fixed Query::Path to work with .like
-  * Replaced usage of base64 lib with pack/unpack
-  * Ensure the correct ordering of links for more complex joins
-  * Simplified SELECT query generation
-  * Simplified Relationship inheritance by subclasses
-  * Ensure Property.new options allow an Array of Symbols for :unique,
-    and :unique_index
-
-=== 0.10.0 / 2009-09-15
-
-* Countless enhancements:
-
-  * Total rewrite of most of dm-core, including YARD docs for more
-    than half the methods and ~90% coverage of code.  More to be done
-    but this is a great start.

data/MIT-LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2007, 2008, 2009 Sam Smoot, Dan Kubb
-
-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/Manifest.txt

@@ -1,121 +0,0 @@
-.autotest
-.gitignore
-CONTRIBUTING
-FAQ
-History.txt
-MIT-LICENSE
-Manifest.txt
-QUICKLINKS
-README.txt
-Rakefile
-SPECS
-TODO
-deps.rip
-dm-core.gemspec
-lib/dm-core.rb
-lib/dm-core/adapters.rb
-lib/dm-core/adapters/abstract_adapter.rb
-lib/dm-core/adapters/data_objects_adapter.rb
-lib/dm-core/adapters/in_memory_adapter.rb
-lib/dm-core/adapters/mysql_adapter.rb
-lib/dm-core/adapters/oracle_adapter.rb
-lib/dm-core/adapters/postgres_adapter.rb
-lib/dm-core/adapters/sqlite3_adapter.rb
-lib/dm-core/adapters/yaml_adapter.rb
-lib/dm-core/associations/many_to_many.rb
-lib/dm-core/associations/many_to_one.rb
-lib/dm-core/associations/one_to_many.rb
-lib/dm-core/associations/one_to_one.rb
-lib/dm-core/associations/relationship.rb
-lib/dm-core/collection.rb
-lib/dm-core/core_ext/kernel.rb
-lib/dm-core/core_ext/symbol.rb
-lib/dm-core/identity_map.rb
-lib/dm-core/migrations.rb
-lib/dm-core/model.rb
-lib/dm-core/model/descendant_set.rb
-lib/dm-core/model/hook.rb
-lib/dm-core/model/is.rb
-lib/dm-core/model/property.rb
-lib/dm-core/model/relationship.rb
-lib/dm-core/model/scope.rb
-lib/dm-core/property.rb
-lib/dm-core/property_set.rb
-lib/dm-core/query.rb
-lib/dm-core/query/conditions/comparison.rb
-lib/dm-core/query/conditions/operation.rb
-lib/dm-core/query/direction.rb
-lib/dm-core/query/operator.rb
-lib/dm-core/query/path.rb
-lib/dm-core/query/sort.rb
-lib/dm-core/repository.rb
-lib/dm-core/resource.rb
-lib/dm-core/spec/adapter_shared_spec.rb
-lib/dm-core/spec/data_objects_adapter_shared_spec.rb
-lib/dm-core/support/chainable.rb
-lib/dm-core/support/deprecate.rb
-lib/dm-core/support/equalizer.rb
-lib/dm-core/support/logger.rb
-lib/dm-core/support/naming_conventions.rb
-lib/dm-core/transaction.rb
-lib/dm-core/type.rb
-lib/dm-core/types/boolean.rb
-lib/dm-core/types/discriminator.rb
-lib/dm-core/types/object.rb
-lib/dm-core/types/paranoid_boolean.rb
-lib/dm-core/types/paranoid_datetime.rb
-lib/dm-core/types/serial.rb
-lib/dm-core/types/text.rb
-lib/dm-core/version.rb
-script/performance.rb
-script/profile.rb
-spec/lib/adapter_helpers.rb
-spec/lib/collection_helpers.rb
-spec/lib/counter_adapter.rb
-spec/lib/pending_helpers.rb
-spec/lib/rspec_immediate_feedback_formatter.rb
-spec/public/associations/many_to_many_spec.rb
-spec/public/associations/many_to_one_spec.rb
-spec/public/associations/one_to_many_spec.rb
-spec/public/associations/one_to_one_spec.rb
-spec/public/collection_spec.rb
-spec/public/migrations_spec.rb
-spec/public/model/relationship_spec.rb
-spec/public/model_spec.rb
-spec/public/property_spec.rb
-spec/public/resource_spec.rb
-spec/public/sel_spec.rb
-spec/public/setup_spec.rb
-spec/public/shared/association_collection_shared_spec.rb
-spec/public/shared/collection_shared_spec.rb
-spec/public/shared/finder_shared_spec.rb
-spec/public/shared/resource_shared_spec.rb
-spec/public/shared/sel_shared_spec.rb
-spec/public/transaction_spec.rb
-spec/public/types/discriminator_spec.rb
-spec/semipublic/adapters/abstract_adapter_spec.rb
-spec/semipublic/adapters/in_memory_adapter_spec.rb
-spec/semipublic/adapters/mysql_adapter_spec.rb
-spec/semipublic/adapters/oracle_adapter_spec.rb
-spec/semipublic/adapters/postgres_adapter_spec.rb
-spec/semipublic/adapters/sqlite3_adapter_spec.rb
-spec/semipublic/adapters/yaml_adapter_spec.rb
-spec/semipublic/associations/many_to_one_spec.rb
-spec/semipublic/associations/relationship_spec.rb
-spec/semipublic/associations_spec.rb
-spec/semipublic/collection_spec.rb
-spec/semipublic/property_spec.rb
-spec/semipublic/query/conditions_spec.rb
-spec/semipublic/query/path_spec.rb
-spec/semipublic/query_spec.rb
-spec/semipublic/resource_spec.rb
-spec/semipublic/shared/condition_shared_spec.rb
-spec/semipublic/shared/resource_shared_spec.rb
-spec/spec.opts
-spec/spec_helper.rb
-tasks/ci.rb
-tasks/dm.rb
-tasks/doc.rb
-tasks/gemspec.rb
-tasks/hoe.rb
-tasks/install.rb

data/QUICKLINKS

@@ -1,11 +0,0 @@
-= Quick Links
-
-* Setup and Configuration - DataMapper
-* Finders and CRUD -
-* Properties - DataMapper::Property
-* FAQ[link:/files/FAQ.html]
-* Contact Us
-  * Website - http://www.datamapper.org
-  * Bug Reports - http://datamapper.lighthouseapp.com
-  * IRC Channel - <tt>##datamapper</tt> on irc.freenode.net
-  * Mailing List - http://groups.google.com/group/datamapper/

data/SPECS

@@ -1,35 +0,0 @@
-Reading Specs
-=============
-
-  Blah blah blah...
-
-Writing Specs
-=============
-
-  Here are some general dos and don'ts
-
-  = DO:
-
-  * Write more specs for error conditions than clean conditions.
-  * Write specs with readability in mind. Somebody new to DataMapper should be
-    able to read specs to learn how something works.
-  * Use existing models that are part of a metaphor.
-  * Nest describe blocks (2 or 3 levels deep is probably fine).
-  * Limit a describe block to 10 - 15 examples.
-  * Group specs by method being tested. (See the 'Ordering Specs' section)
-  * Use custom matchers.
-
-  = DON'T:
-
-  * Spec more than one unit of functionality in an example. An example should be
-    as short as possible (while still remaining readable).
-  * Spec implementation. Refactoring code should not break specs.
-  * Declare models in the spec file.
-
-  And a final do: Do go against the guidelines if your best judgement tells you
-  to. These are just guidelines and are obviously not fast rules.
-
-Mocks and Stubs
-===============
-
-  Do not use mocks or stubs for any specs in DataMapper.

data/TODO

@@ -1 +0,0 @@
-See: http://wiki.github.com/datamapper/dm-core

data/spec/semipublic/query/conditions_spec.rb

@@ -1,528 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-include DataMapper::Query::Conditions
-
-module ComparisonSpecHelpers
-
-  def match(record)
-    ComparisonMatcher.new(record)
-  end
-
-  class ComparisonMatcher
-
-    def initialize(record)
-      @record = record
-    end
-
-    def matches?(comparison)
-      @comparison = comparison
-      comparison.matches?(@record)
-    end
-
-    def failure_message
-      "Expected #{@comparison.inspect} to match #{@record.inspect}"
-    end
-
-    def negative_failure_message
-      "Expected #{@comparison.inspect} to NOT match #{@record.inspect}"
-    end
-
-  end
-
-end
-
-describe DataMapper::Query::Conditions do
-
-  include ComparisonSpecHelpers
-
-  before :all do
-    class ::Mass < DataMapper::Type
-      primitive Integer
-
-      def self.load(value, property)
-        { 1 => 'Small', 2 => 'Large', 3 => 'XLarge' }[value]
-      end
-
-      def self.dump(value, property)
-        { 'Small' => 1, 'Large' => 2, 'XLarge' => 3 }[value]
-      end
-    end
-
-    class ::Heffalump
-      include DataMapper::Resource
-
-      property :id,        Serial
-      property :color,     String
-      property :num_spots, Integer
-      property :striped,   Boolean
-      property :mass,      Mass,    :default => 'Large', :nullable => false
-
-      belongs_to :parent, Heffalump
-
-      # Heffalumps are surprisingly picky when it comes to choosing friends --
-      # they greatly prefer the company of similarly sized beasts. :)
-      has n, :mass_mates, Heffalump, :child_key => [:mass], :parent_key => [:mass]
-    end
-
-    @heff1 = Heffalump.new(:id => 1, :num_spots => 1, :color => 'green', :striped => true,  :mass => 'Small')
-    @heff2 = Heffalump.new(:id => 2, :num_spots => 2, :color => 'green', :striped => false, :mass => 'Large',  :parent => @heff1)
-    @heff3 = Heffalump.new(:id => 3, :num_spots => 3, :color => 'blue',  :striped => false, :mass => 'XLarge', :parent => @heff2)
-  end
-
-  describe 'Operations' do
-    before do
-      @comp1 = Comparison.new(:eql, Heffalump.num_spots, 1)
-      @comp2 = Comparison.new(:eql, Heffalump.color, 'green')
-    end
-
-    it 'should initialize an AbstractOperation object' do
-      op = Operation.new(:and)
-      op.should be_kind_of(AbstractOperation)
-    end
-
-    {
-      :and => AndOperation,
-      :or  => OrOperation,
-      :not => NotOperation
-    }.each do |operand, klass|
-      it "should initialize as #{klass} for the #{operand} operator" do
-        op = Operation.new(operand)
-        op.should be_kind_of(klass)
-      end
-    end
-
-    it 'should set the remaining args in @operands' do
-      op = Operation.new(:and, @comp1, @comp2)
-      op.operands.should == [@comp1, @comp2]
-    end
-
-    it 'should have operands be empty of no operands are provided' do
-      op = Operation.new(:and)
-      op.operands.should == []
-    end
-
-    describe 'NotOperation' do
-      before do
-        @op = Operation.new(:not, @comp1)
-      end
-
-      it 'should not allow more than one operand' do
-        lambda {
-          Operation.new(:not, @comp1, @comp2)
-        }.should raise_error(InvalidOperation)
-      end
-
-      it 'should negate the comparison' do
-        @comp1.should match(@heff1)
-        @op.should_not match(@heff1)
-      end
-    end
-
-    describe 'AndOperation' do
-      before do
-        @op = Operation.new(:and, @comp1, @comp2)
-      end
-
-      it 'should match if all comparisons match' do
-        @comp1.should match(@heff1)
-        @comp2.should match(@heff1)
-
-        @op.should match(@heff1)
-      end
-
-      it 'should not match of any of the comparisons does not match' do
-        @comp1.should_not match(@heff2)
-
-        @op.should_not match(@heff2)
-      end
-    end
-
-    describe 'OrOperation' do
-      before do
-        @op = Operation.new(:or, @comp1, @comp2)
-      end
-
-      it 'should match if any of the comparisons match' do
-        @comp1.should_not match(@heff2)
-        @comp2.should match(@heff2)
-
-        @op.should match(@heff2)
-      end
-
-      it 'should not match if none of the comparisons match' do
-        @comp1.should_not match(@heff3)
-        @comp2.should_not match(@heff3)
-
-        @op.should_not match(@heff3)
-      end
-    end
-  end
-
-  describe 'Comparisons' do
-    it 'should initialize an AbstractComparison object' do
-      comp = Comparison.new(:eql, Heffalump.num_spots, 1)
-      comp.should be_kind_of(AbstractComparison)
-    end
-
-    {
-      :eql    => EqualToComparison,
-      :gt     => GreaterThanComparison,
-      :gte    => GreaterThanOrEqualToComparison,
-      :lt     => LessThanComparison,
-      :lte    => LessThanOrEqualToComparison,
-      :regexp => RegexpComparison
-    }.each do |slug, klass|
-      it "should initialize as #{klass} for the #{slug} comparator" do
-        comp = Comparison.new(slug, Heffalump.num_spots, 2)
-        comp.should be_kind_of(klass)
-      end
-    end
-
-    it 'should initialize as InclusionComparison for the :in comparator' do
-      comp = Comparison.new(:in, Heffalump.num_spots, [ 2 ])
-      comp.should be_kind_of(InclusionComparison)
-    end
-
-    describe 'EqualToComparison' do
-      describe 'with a value matching the property primitive' do
-        before :all do
-          @comp = Comparison.new(:eql, Heffalump.striped, false)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff2)
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff1)
-        end
-      end
-
-      describe 'with a value coerced into the property primitive' do
-        before :all do
-          @comp = Comparison.new(:eql, Heffalump.striped, 'false')
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff2)
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff1)
-        end
-      end
-
-      describe 'with a value from a custom type' do
-        before :all do
-          @comp = Comparison.new(:eql, Heffalump.mass, 'Large')
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff1)
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a relationship subject' do
-        before :all do
-          @comp = Comparison.new(:eql, Heffalump.relationships[:parent], @heff1)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff1)
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a relationship subject using a custom type key' do
-        before :all do
-          @comp = Comparison.new(:eql, Heffalump.relationships[:mass_mates], @heff1)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(Heffalump.new(:id => 4, :mass => 'Small'))
-          @comp.should match(@heff1)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff2)
-          @comp.should_not match(@heff3)
-        end
-      end
-    end
-
-    describe 'InclusionComparison' do
-      describe 'with a value matching the property primitive' do
-        before :all do
-          @comp = Comparison.new(:in, Heffalump.num_spots, 1..2)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff1)
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a value coerced into the property primitive' do
-        before :all do
-          @comp = Comparison.new(:in, Heffalump.num_spots, '1'..'2')
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff1)
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a value from a custom type' do
-        before :all do
-          @comp = Comparison.new(:in, Heffalump.mass, ['Small', 'Large'])
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff1)
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a relationship subject' do
-        before :all do
-          @comp = Comparison.new(:in, Heffalump.relationships[:parent], [@heff1, @heff2])
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(@heff2)
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff1)
-        end
-      end
-
-      describe 'with a relationship subject using a custom type key' do
-        before :all do
-          @comp = Comparison.new(:in, Heffalump.relationships[:mass_mates], [@heff1, @heff2])
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that equal the given value' do
-          @comp.should match(Heffalump.new(:mass => 'Small'))
-          @comp.should match(Heffalump.new(:mass => 'Large'))
-          @comp.should match(@heff1)
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that do not equal the given value' do
-          @comp.should_not match(@heff3)
-        end
-      end
-    end
-
-    describe 'GreaterThanComparison' do
-      describe 'with a value matching the property primitive' do
-        before :all do
-          @comp = Comparison.new(:gt, Heffalump.num_spots, 2)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are greater than the given value' do
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that are not greater than the given value' do
-          @comp.should_not match(@heff1)
-          @comp.should_not match(@heff2)
-        end
-      end
-
-      describe 'with a value coerced into the property primitive' do
-        before :all do
-          @comp = Comparison.new(:gt, Heffalump.num_spots, '2')
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are greater than the given value' do
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that are not greater than the given value' do
-          @comp.should_not match(@heff1)
-          @comp.should_not match(@heff2)
-        end
-      end
-    end
-
-    describe 'GreaterThanOrEqualToComparison' do
-      describe 'with a value matching the property primitive' do
-        before :all do
-          @comp = Comparison.new(:gte, Heffalump.num_spots, 2)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are greater than or equal to the given value' do
-          @comp.should match(@heff2)
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that are not greater than or equal to the given value' do
-          @comp.should_not match(@heff1)
-        end
-      end
-
-      describe 'with a value coerced into the property primitive' do
-        before :all do
-          @comp = Comparison.new(:gte, Heffalump.num_spots, 2.0)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are greater than or equal to the given value' do
-          @comp.should match(@heff2)
-          @comp.should match(@heff3)
-        end
-
-        it 'should not match records that are not greater than or equal to the given value' do
-          @comp.should_not match(@heff1)
-        end
-      end
-    end
-
-    describe 'LessThanComparison' do
-      describe 'with a value matching the property primitive' do
-        before :all do
-          @comp = Comparison.new(:lt, Heffalump.num_spots, 2)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are less than the given value' do
-          @comp.should match(@heff1)
-        end
-
-        it 'should not match records that are not less than the given value' do
-          @comp.should_not match(@heff2)
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a value coerced into the property primitive' do
-        before :all do
-          @comp = Comparison.new(:lt, Heffalump.num_spots, BigDecimal('2.0'))
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are less than the given value' do
-          @comp.should match(@heff1)
-        end
-
-        it 'should not match records that are not less than the given value' do
-          @comp.should_not match(@heff2)
-          @comp.should_not match(@heff3)
-        end
-      end
-    end
-
-    describe 'LessThanOrEqualToComparison' do
-      describe 'with a value matching the property primitive' do
-        before :all do
-          @comp = Comparison.new(:lte, Heffalump.num_spots, 2)
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are less than or equal to the given value' do
-          @comp.should match(@heff1)
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that are not less than or equal to the given value' do
-          @comp.should_not match(@heff3)
-        end
-      end
-
-      describe 'with a value coerced into the property primitive' do
-        before :all do
-          @comp = Comparison.new(:lte, Heffalump.num_spots, '2')
-        end
-
-        it_should_behave_like 'A valid query condition'
-
-        it 'should match records that are less than or equal to the given value' do
-          @comp.should match(@heff1)
-          @comp.should match(@heff2)
-        end
-
-        it 'should not match records that are not less than or equal to the given value' do
-          @comp.should_not match(@heff3)
-        end
-      end
-    end
-
-    describe 'RegexpComparison' do
-      before :all do
-        @comp = Comparison.new(:regexp, Heffalump.color, /green/)
-        @heff2.color = 'forest green'
-      end
-
-      it_should_behave_like 'A valid query condition'
-
-      it 'should match records that match the regexp' do
-        @comp.should match(@heff1)
-        @comp.should match(@heff2)
-      end
-
-      it "should not match records that don't match the regexp" do
-        @comp.should_not match(@heff3)
-      end
-
-    end
-
-  end
-
-end