sayso-meta_where 1.0.4.001

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/CHANGELOG

@@ -0,0 +1,90 @@
+Changes since 1.0.2 (2011-02-09):
+  * Fix eager loading with order values supplied
+
+Changes since 1.0.1 (2011-01-18):
+  * Fix *_all behavior to not result in ORs when collapse_wheres is called
+  * Add support for NOT operator (-) on hashes, conditions, and compound
+    conditions. Unary NOTs the condition, binary does an AND NOT between
+    on the second condition.
+
+Changes since 1.0.0 (2011-01-17):
+  * Update polymorphic join support to play nicely with MetaSearch
+
+Changes since 0.9.10 (2011-01-06):
+  * Doc updates only, and a version change to 1.0.0.
+
+Changes since 0.9.9 (2010-11-15):
+  * Multiple conditions on the same column with the same predicate will be "OR"ed
+    instead of dropping all but the last one. This tracks the same behavior in
+    Rails 3-0-stable.
+  * You can specify a polymorphic belongs_to join via something like:
+    Model.joins(:joinable.type(PolymorphicClass))
+  * You can specify ActiveRecord objects as values:
+    Developer.joins(:projects).where(:projects => Project.first) is the same as
+    Developer.joins(:projects).where(:projects => {:id => Project.first.id}), but
+    less hashy.
+
+Changes since 0.9.6 (2010-09-30):
+  * ARel 2.x and Rails 3.0.2 compatibility
+  * Allow MetaWhere::And and MetaWhere::Or on the value side of a condition hash
+    to trigger treatment of key as an association.
+    ex: :comments => (:created_at.lt % 1.day.ago | :body.matches % '%hey%')
+  * Support for selecting join type: :association.outer / :association.inner results
+    in an outer or inner join.
+  * Having clauses are now fully MetaWhere-enabled.
+  * SQL functions are now supported. :concat.func(val1, val2) will result in an
+    SQL concat() call, with two parameters. If you've enabled Symbol operators, then
+    you can also just do :concat[val1, val2].
+
+Changes since 0.9.5 (2010-09-27):
+  * Don't skip adding condition if an empty array is supplied
+
+Changes since 0.9.4 (2010-09-23):
+  * Fix those fun problems with cache_classes.
+
+Changes since 0.9.3 (2010-09-08):
+  * alias :& to :merge in singleton to work properly with Ruby 1.8.7.
+  * Fix merge to only use associations if not against the same base class. (STI)
+
+Changes since 0.9.2 (2010-08-26):
+  * Updated gemspec to require Rails 3.0.0 final.
+
+Changes since 0.9.1 (2010-08-25):
+  * Fix missing .any? on method chain in check for mw in association macros.
+
+Changes since 0.9.0 (2010-08-24):
+  * Check for use of MetaWhere in association macros. This won't work as expected
+    so it's better to raise a helpful error than create a potentially confusing
+    behavior.
+
+Changes since 0.5.2 (2010-07-09):
+  * Removed autojoin. Inner joins have side-effects. Newbies are the ones who aremost
+    likely to use autojoin, and they're also the ones least likely to understand why
+    certain rows stop being returned. Better to force a small learning curve. I've
+    decided against leaving it in with deprecation since Rails 3 isn't final yet.
+    Decided to get it out before it's "too late" to do so without impacting code running
+    on a stable version of Rails.
+  * Refactored build_arel to more closely mirror the refactoring that's been going on
+    to the method in Rails edge.
+  * Improved merge functonality. It shouldn't have ever required someone to do an
+    autojoin to begin with. Now it just works. If you're merging two relations, you
+    should expect to only get results that have a match on both sides.
+  * Attempt to gracefully degrade in the case where a MetaWhere::Column is expected
+    to be a normal symbol. Return the column name in #to_s.
+  * Fix order clauses when constructing a limited_ids_condition for postgresql.
+  * Fix problems with cache_classes == false on certain server configurations. Also
+    handle self-join with a merge of two identical classes and a second param.
+  * Drop ActiveSupport::Concern and only use alias_method_chain when needed.
+
+Changes since 0.5.1 (2010-06-22):
+  * Added debug_sql method to Relations. Lets you see the actual SQL that
+    will be run against the database without having to resort to the
+    development.log. Differs from to_sql because that doesn't (and can't,
+    by necessity) handle eager loading.
+
+Changes since 0.5.0 (2010-06-08):
+  * Track Emilio Tagua's performance enhancements in build_arel from edge.
+
+Changes since 0.3.3 (2010-04-30):
+  * Lots. See http://metautonomo.us/2010/06/08/metasearch-and-metawhere-0-5-0-released/
+    for a summary.

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'arel', :git => 'git://github.com/rails/arel.git', :tag => 'v2.0.8.beta.20110131120940'
+git 'git://github.com/rails/rails.git', :branch => '3-0-stable' do
+  gem 'activesupport'
+  gem 'activerecord'
+end

data/LICENSE

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

data/README.rdoc

@@ -0,0 +1,346 @@
+= MetaWhere
+
+(If you're using edge Rails and you'd like to help me test the successor to
+MetaWhere, please have a look at {Squeel}[http://github.com/ernie/squeel])
+
+MetaWhere puts the power of Arel predications (comparison methods) in your ActiveRecord
+condition hashes.
+
+== Why?
+
+<b>I hate SQL fragments in Rails code.</b> Resorting to <tt>where('name LIKE ?', '%something%')</tt> is an admission of defeat. It says, "I concede to allow your rigid, 1970's-era syntax into my elegant Ruby world of object oriented goodness." While sometimes such concessions are necessary, they should <em>always</em> be a last resort, because <b>once you move away from an abstract representation of your intended query, your query becomes more brittle.</b> You're now reduced to hacking about with regular expressions, string scans, and the occasional deferred variable interpolation trick (like '#{quoted_table_name}') in order to maintain some semblance of flexibility.
+
+It isn't that I hate SQL (much). I'm perfectly capable of constructing complex queries from scratch, and did more than my fair share before coming to the Rails world. It's that I hate the juxtaposition of SQL against Ruby. It's like seeing your arthritic grandfather hand in hand with some hot, flexible, yoga instructor. Good for him, but sooner or later something's going to get broken.  It's like a sentence which, tanpa alasan, perubahan ke bahasa lain, then back again ("for no reason, changes to another language" -- with thanks to Google Translate, and apologies to native speakers of Indonesian). It just feels <em>wrong</em>. It breaks the spell -- the "magic" that adds to programmer joy, and <em>for no good reason</em>.
+
+MetaWhere is a gem that sets out to right that wrong, and give tranquility to you, the Rails coder.
+
+== Getting started
+
+In your Gemfile:
+
+  gem "meta_where"  # Last officially released gem
+  # gem "meta_where", :git => "git://github.com/ernie/meta_where.git" # Track git repo
+
+or, to install as a plugin:
+
+  rails plugin install git://github.com/ernie/meta_where.git
+
+== Example usage
+
+=== Where
+You can use MetaWhere in your usual method chain:
+
+  Article.where(:title.matches => 'Hello%', :created_at.gt => 3.days.ago)
+  => SELECT "articles".* FROM "articles" WHERE ("articles"."title" LIKE 'Hello%')
+     AND ("articles"."created_at" > '2010-04-12 18:39:32.592087')
+
+=== Find condition hash
+You can also use similar syntax in a conditions hash supplied to ActiveRecord::Base#find:
+
+  Article.find(:all,
+    :conditions => {
+      :title.matches => 'Hello%',
+      :created_at.gt => 3.days.ago
+    }
+  )
+
+=== Scopes
+They also work in named scopes as you would expect.
+
+  class Article
+    scope :recent, lambda {|v| where(:created_at.gt => v.days.ago)}
+  end
+
+  Article.recent(14).to_sql
+  => SELECT "articles".* FROM "articles"
+     WHERE ("articles"."created_at" > '2010-04-01 18:54:37.030951')
+
+=== Operators (Optionally)
+Additionally, you can use certain operators as shorthand for certain Arel predication methods.
+
+These are disabled by default, but can be enabled by calling MetaWhere.operator_overload! during
+your app's initialization process.
+
+These are experimental at this point and subject to change. Keep in mind that if you don't want
+to enclose other conditions in {}, you should place operator conditions before any hash conditions.
+
+  Article.where(:created_at > 100.days.ago, :title =~ 'Hi%').to_sql
+  => SELECT "articles".* FROM "articles"
+     WHERE ("articles"."created_at" > '2010-01-05 20:11:44.997446')
+     AND ("articles"."title" LIKE 'Hi%')
+
+Operators are:
+
+* >> (equal)
+* ^ (not equal)
+* + (in array/range)
+* - (not in array/range)
+* =~ (matching -- not a regexp but a string for SQL LIKE) <b>NOTE:</b> This will override 1.9.x "symbol as string" =~ behavior.
+* !~ (not matching, only available under Ruby 1.9)
+* > (greater than)
+* >= (greater than or equal to)
+* < (less than)
+* <= (less than or equal to)
+* [] (SQL functions -- more on those below)
+
+=== Compounds
+You can use the & and | operators to perform ands and ors within your queries.
+
+<b>With operators:</b>
+  Article.where((:title =~ 'Hello%') | (:title =~ 'Goodbye%')).to_sql
+  => SELECT "articles".* FROM "articles" WHERE (("articles"."title" LIKE 'Hello%'
+     OR "articles"."title" LIKE 'Goodbye%'))
+
+That's kind of annoying, since operator precedence is such that you have to put
+parentheses around everything. So MetaWhere also supports a substitution-inspired
+(String#%) syntax.
+
+<b>With "substitutions":</b>
+  Article.where(:title.matches % 'Hello%' | :title.matches % 'Goodbye%').to_sql
+  => SELECT "articles".* FROM "articles" WHERE (("articles"."title" LIKE 'Hello%'
+     OR "articles"."title" LIKE 'Goodbye%'))
+
+<b>With hashes:</b>
+  Article.where(
+    {:created_at.lt => Time.now} & {:created_at.gt => 1.year.ago}
+  ).to_sql
+  => SELECT "articles".* FROM "articles" WHERE
+     ((("articles"."created_at" < '2010-04-16 00:26:30.629467')
+     AND ("articles"."created_at" > '2009-04-16 00:26:30.629526')))
+
+<b>With both hashes and substitutions:</b>
+  Article.where(
+    :title.matches % 'Hello%' &
+    {:created_at.lt => Time.now, :created_at.gt => 1.year.ago}
+  ).to_sql
+  => SELECT "articles".* FROM  "articles" WHERE (("articles"."title" LIKE 'Hello%' AND
+     ("articles"."created_at" < '2010-04-16 01:04:38.023615' AND
+      "articles"."created_at" > '2009-04-16 01:04:38.023720')))
+
+<b>With insanity... errr, complex combinations(*):</b>
+
+  Article.joins(:comments).where(
+    {:title => 'Greetings'} |
+    (
+      (
+        :created_at.gt % 21.days.ago &
+        :created_at.lt % 7.days.ago
+      ) &
+      :body.matches % '%from the past%'
+    ) &
+    {:comments => [:body =~ '%first post!%']}
+  ).to_sql
+  => SELECT "articles".*
+     FROM "articles"
+       INNER JOIN "comments"
+       ON "comments"."article_id" = "articles"."id"
+     WHERE
+     ((
+       "articles"."title" = 'Greetings'
+       OR
+       (
+         (
+           (
+             "articles"."created_at" > '2010-03-26 05:57:57.924258'
+             AND "articles"."created_at" < '2010-04-09 05:57:57.924984'
+           )
+           AND "articles"."body" LIKE '%from the past%'
+         )
+         AND "comments"."body" LIKE '%first post!%'
+       )
+     ))
+
+(*) Formatting added for clarity. I said you could do this, not that you should. :)
+
+== Join type specification
+You can choose whether to use an inner join (the default) or a left outer join by tacking
+<tt>.outer</tt> or <tt>.inner</tt> to the symbols specified in your joins() call:
+
+  Article.joins(:comments => :moderations.outer).to_sql
+  => SELECT "articles".* FROM "articles"
+     INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
+     LEFT OUTER JOIN "moderations" ON "moderations"."comment_id" = "comments"."id"
+
+== SQL Functions
+You can use SQL functions in your queries:
+
+  Manager.joins(:employees.outer).group('managers.id').
+          having(:employees => (:count.func(:id) < 3))
+  => SELECT "managers".* FROM "managers"
+     LEFT OUTER JOIN "employees" ON "employees"."manager_id" = "managers"."id"
+     GROUP BY managers.id HAVING count("employees"."id") < 3
+
+If you enable Symbol operators, you can just use <tt>:count[:id]</tt>, instead of calling
+<tt>func</tt> as shown above. SQL functions work in the SELECT, WHERE, and HAVING clauses,
+and can be aliased with <tt>as</tt>:
+
+  Manager.select('managers.*').
+          select(:find_in_set[:id, '3,2,1'].as('position'))
+  => SELECT managers.*, find_in_set("managers"."id",'3,2,1') AS position
+     FROM "managers"
+
+=== But wait, there's more!
+
+== Intelligent hash condition mapping
+This is one of those things I hope you find so intuitive that you forget it wasn't
+built in already.
+
+PredicateBuilder (the part of ActiveRecord responsible for turning your conditions
+hash into a valid SQL query) will allow you to nest conditions in order to specify a
+table that the conditions apply to:
+
+  Article.joins(:comments).where(:comments => {:body => 'hey'}).to_sql
+  => SELECT "articles".* FROM "articles" INNER JOIN "comments"
+     ON "comments"."article_id" = "articles"."id"
+     WHERE ("comments"."body" = 'hey')
+
+This feels pretty magical at first, but the magic quickly breaks down. Consider an
+association named <tt>:other_comments</tt> that is just a condition against comments:
+
+  Article.joins(:other_comments).where(:other_comments => {:body => 'hey'}).to_sql
+  => ActiveRecord::StatementInvalid: No attribute named `body` exists for table `other_comments`
+
+Ick. This is because the query is being created against tables, and not against associations.
+You'd need to do...
+
+  Article.joins(:other_comments).where(:comments => {:body => 'hey'})
+
+...instead.
+
+With MetaWhere:
+
+  Article.joins(:other_comments).where(:other_comments => {:body => 'hey'}).to_sql
+  => SELECT "articles".* FROM "articles" INNER JOIN "comments"
+     ON "comments"."article_id" = "articles"."id" WHERE (("comments"."body" = 'hey'))
+
+The general idea is that if an association with the name provided exists, MetaWhere
+will build the conditions against that association's table as it's been aliased, before falling
+back to assuming you're specifying a table by name. It also handles nested associations:
+
+  Article.where(
+    :comments => {
+      :body => 'yo',
+      :moderations => [:value < 0]
+    },
+    :other_comments => {:body => 'hey'}
+  ).joins(
+    {:comments => :moderations},
+    :other_comments
+  ).to_sql
+  => SELECT "articles".* FROM "articles"
+     INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
+     INNER JOIN "moderations" ON "moderations"."comment_id" = "comments"."id"
+     INNER JOIN "comments" "other_comments_articles"
+       ON "other_comments_articles"."article_id" = "articles"."id"
+    WHERE (("comments"."body" = 'yo' AND "moderations"."value" < 0
+      AND "other_comments_articles"."body" = 'hey'))
+
+Contrived example, I'll admit -- but I'll bet you can think of some uses for this.
+
+== Enhanced relation merges
+
+One of the changes MetaWhere makes to ActiveRecord is to delay "compiling" the
+where_values into actual Arel predicates until absolutely necessary. This allows
+for greater flexibility and last-second inference of associations/joins from any
+hashes supplied. A drawback of this method is that when merging relations, ActiveRecord
+just assumes that the values being merged are already firmed up against a specific table
+name and can just be thrown together. This isn't the case with MetaWhere, and would
+cause unexpected failures when merging. However, MetaWhere improves on the default
+ActiveRecord merge functionality in two ways. First, when called with 1 parameter,
+(as is always the case when using the & alias) MetaWhere will try to determine if
+an association exists between the two models involved in the merge. If it does, the
+association name will be used to construct criteria.
+
+Additionally, to cover times when detection is impossible, or the first detected
+association isn't the one you wanted, you can call merge with a second parameter,
+specifying the association to be used during the merge.
+
+This merge functionality allows you to do this...
+
+  (Comment.where(:id < 7) & Article.where(:title =~ '%blah%')).to_sql
+  => SELECT "comments".* FROM "comments" INNER JOIN "articles"
+     ON "articles"."id" = "comments"."article_id"
+     WHERE ("comments"."id" < 7) AND ("articles"."title" LIKE '%blah%')"
+
+...or this...
+
+  Article.where(:id < 2).merge(Comment.where(:id < 7), :lame_comments).to_sql
+  => "SELECT "articles".* FROM "articles"
+     INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
+        AND "comments"."body" = 'first post!'
+     WHERE ("articles"."id" < 2) AND ("comments"."id" < 7)"
+
+== Enhanced order clauses
+
+If you are used to doing stuff like <tt>Article.order('title asc')</tt>, that will still
+work as you expect. However, if you pass symbols or arrays in to the <tt>order</tt> method,
+you can take advantage of intelligent association detection (as with "Intelligent hash condition
+mapping," above) and also some convenience methods for ascending and descending sorts.
+
+  Article.order(
+    :title.desc,
+    :comments => [:created_at.asc, :updated_at]
+  ).joins(:comments).to_sql
+  => SELECT "articles".* FROM "articles"
+     INNER JOIN "comments" ON "comments"."article_id" = "articles"."id"
+     ORDER BY  "articles"."title" DESC,
+       "comments"."created_at" ASC, "comments"."updated_at"
+
+== Polymorphic belongs_to joins
+
+Polymorphic associations provide great flexibility, but they can sometimes be a bit of a hassle
+when it comes to querying through a belongs_to association. First, you have to know what type
+you're looking for to do a proper join, and then, you're forced into using a string join in order
+to make it happen (which would prevent the use of MetaWhere intelligent condition mapping).
+
+MetaWhere allows you to join polymorphic belongs_to associations like this:
+
+  Note.joins(:notable.type(Developer)).
+       where(:notable.type(Developer) => {:name.matches => 'Ernie%'})
+  => SELECT "notes".* FROM "notes"
+     INNER JOIN "developers" ON "developers"."id" = "notes"."notable_id"
+       AND "notes"."notable_type" = 'Developer'
+     WHERE "developers"."name" LIKE 'Ernie%'
+
+== Using ActiveRecord objects as condition values
+
+Wouldn't it be nice if you could do something like this?
+
+  # Developer belongs_to Company
+  company = Company.find(123)
+  Developer.where(:company => company)
+
+  # Developer HABTM Projects
+  projects = [Project.first, Project.last]
+  Developer.joins(:projects).where(:projects => projects)
+
+  # Note belongs_to :notable, :polymorphic => true
+  dev1 = Developer.first
+  dev2 = Developer.last
+  project = Project.first
+  company = Company.first
+  Note.where(:notable => [dev1, dev2, project, company]).to_sql
+  => SELECT "notes".* FROM "notes" WHERE (((("notes"."notable_id" IN (1, 8)
+     AND "notes"."notable_type" = 'Developer') OR ("notes"."notable_id" = 1
+     AND "notes"."notable_type" = 'Project')) OR ("notes"."notable_id" = 1
+     AND "notes"."notable_type" = 'Company')))
+
+With MetaWhere, you can.
+
+== Thanks
+A huge thank you goes to Pratik Naik (lifo) for a dicussion on #rails-contrib about a patch
+I'd submitted, and his take on a DSL for query conditions, which was the inspiration for this
+gem.
+
+== Contributions
+
+There are several ways you can help MetaWhere continue to improve.
+
+* Use MetaWhere in your real-world projects and {submit bug reports or feature suggestions}[http://metautonomous.lighthouseapp.com/projects/53011-metawhere/].
+* Better yet, if you’re so inclined, fix the issue yourself and submit a patch! Or you can {fork the project on GitHub}[http://github.com/ernie/meta_where] and send me a pull request (please include tests!)
+* If you like MetaWhere, spread the word. More users == more eyes on code == more bugs getting found == more bugs getting fixed (hopefully!)
+* Lastly, if MetaWhere has saved you hours of development time on your latest Rails gig, and you’re feeling magnanimous, please consider {making a donation}[http://pledgie.com/campaigns/10096] to the project. I have spent hours of my personal time coding and supporting MetaWhere, and your donation would go a great way toward justifying that time spent to my loving wife. :)
+
+== Copyright
+
+Copyright (c) 2010 {Ernie Miller}[http://metautonomo.us]. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+end
+
+task :default => :test

data/lib/core_ext/hash.rb

@@ -0,0 +1,5 @@
+require 'meta_where/condition_operators'
+
+class Hash
+  include MetaWhere::ConditionOperators
+end

data/lib/core_ext/symbol.rb

@@ -0,0 +1,39 @@
+class Symbol
+  MetaWhere::PREDICATES.each do |predication|
+    define_method(predication) do
+      MetaWhere::Column.new(self, predication)
+    end
+  end
+
+  MetaWhere::METHOD_ALIASES.each_pair do |aliased, predication|
+    define_method(aliased) do
+      MetaWhere::Column.new(self, predication)
+    end
+  end
+
+  def mw_func(*args)
+    MetaWhere::Function.new(self, *args)
+  end
+
+  alias_method :func, :mw_func unless method_defined?(:func)
+
+  def inner
+    MetaWhere::JoinType.new(self, Arel::Nodes::InnerJoin)
+  end
+
+  def outer
+    MetaWhere::JoinType.new(self, Arel::Nodes::OuterJoin)
+  end
+
+  def type(klass)
+    MetaWhere::JoinType.new(self, Arel::Nodes::InnerJoin, klass)
+  end
+
+  def asc
+    MetaWhere::Column.new(self, :asc)
+  end
+
+  def desc
+    MetaWhere::Column.new(self, :desc)
+  end
+end

data/lib/core_ext/symbol_operators.rb

@@ -0,0 +1,48 @@
+class Symbol
+  def [](*values)
+    MetaWhere::Function.new(self, *values)
+  end
+
+  def >>(value)
+    MetaWhere::Condition.new(self, value, :eq)
+  end
+
+  def ^(value)
+    MetaWhere::Condition.new(self, value, :not_eq)
+  end
+
+  def +(value)
+    MetaWhere::Condition.new(self, value, :in)
+  end
+
+  def -(value)
+    MetaWhere::Condition.new(self, value, :not_in)
+  end
+
+  def =~(value)
+    MetaWhere::Condition.new(self, value, :matches)
+  end
+
+  # Won't work on Ruby 1.8.x so need to do this conditionally
+  if respond_to?('!~')
+    define_method('!~') do |value|
+      MetaWhere::Condition.new(self, value, :does_not_match)
+    end
+  end
+
+  def >(value)
+    MetaWhere::Condition.new(self, value, :gt)
+  end
+
+  def >=(value)
+    MetaWhere::Condition.new(self, value, :gteq)
+  end
+
+  def <(value)
+    MetaWhere::Condition.new(self, value, :lt)
+  end
+
+  def <=(value)
+    MetaWhere::Condition.new(self, value, :lteq)
+  end
+end

data/lib/meta_where/association_reflection.rb

@@ -0,0 +1,51 @@
+module MetaWhere
+  class MetaWhereInAssociationError < StandardError; end
+
+  module AssociationReflection
+
+    def initialize(macro, name, options, active_record)
+      super
+
+      if options.has_key?(:conditions)
+        ensure_no_metawhere_in_conditions(options[:conditions])
+      end
+    end
+
+    private
+
+    def ensure_no_metawhere_in_conditions(obj)
+      case obj
+      when Hash
+        if obj.keys.grep(MetaWhere::Column).any?
+          raise MetaWhereInAssociationError, <<END
+The :#{name} association has a MetaWhere::Column in its :conditions. \
+If you actually needed to access conditions other than equality, then you most \
+likely meant to set up a scope or method, instead. Associations only work with \
+standard equality conditions, since they can be used to create records as well.
+END
+        end
+
+        obj.values.each do |v|
+          case v
+          when MetaWhere::Condition, Array, Hash
+            ensure_no_metawhere_in_conditions(v)
+          end
+        end
+      when Array
+        obj.each do |v|
+          case v
+          when MetaWhere::Condition, Array, Hash
+            ensure_no_metawhere_in_conditions(v)
+          end
+        end
+      when MetaWhere::Condition
+        raise MetaWhereInAssociationError, <<END
+The :#{name} association has a MetaWhere::Condition in its :conditions. \
+If you actually needed to access conditions other than equality, then you most \
+likely meant to set up a scope or method, instead. Associations only work with \
+standard equality conditions, since they can be used to create records as well.
+END
+      end
+    end
+  end
+end