sexy_scopes 0.2.0 → 0.5.0

data/.gitignore

@@ -1,3 +1,4 @@
+Gemfile.lock
 coverage
-rdoc
 pkg
+doc

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -1,34 +1,113 @@
-sexy_scopes
-===========
-
-sexy_scope is a small wrapper around `Arel::Attribute` that adds a little syntactic
-sugar when creating scopes in ActiveRecord.
-It adds an `attribute` class method which takes an attribute name and returns an 
-`Arel::Attribute` wrapper, which responds to common operators to return predicates
-objects that can be used as arguments to `ActiveRecord::Base.where`.
-
-Examples
---------
-
-    class Product < ActiveRecord::Base
-      scope :untitled, where(attribute(:name) == nil)
-      
-      def self.cheaper_than(price)
-        where attribute(:price) < price
-      end
-      
-      def self.search(term)
-        where attribute(:name) =~ "%#{term}%"
-      end
-    end
-
-Classic `Arel::Attribute` methods (`lt`, `in`, `matches`, `not`, etc.) are still available
-and predicates can be chained using `and` and `or`:
-
-    (Product.attribute(:name) == nil).and(Product.attribute(:category).in(["foo", "bar"])).to_sql
-    # => ("products"."name" IS NULL AND "products"."category" IN ('foo', 'bar'))
+SexyScopes
+==========
+
+**Write beautiful and expressive ActiveRecord scopes without SQL**
+
+* [Source Code](https://github.com/samleb/sexy_scopes)
+* [Rubygem](http://rubygems.org/gems/sexy_scopes)
+
+SexyScopes is a gem that adds syntactic sugar for creating scopes in Rails 3.
+
+Usage & Examples
+----------------
+
+```ruby
+class Product < ActiveRecord::Base
+  # `self.price` represents the `price` column
+  def self.cheaper_than(price)
+    where self.price < price
+  end
+  
+  scope :visible, (category != nil) & (draft == false)
+  
+  # can't use `name` directly here as `Product.name` method already exists (== "Product")
+  def self.search(term)
+    where attribute(:name) =~ "%#{term}%"
+  end
+end
+```
+
+Classic `Arel::Attribute` methods (`lt`, `in`, `matches`, `not`, etc.) are still 
+available and predicates can be chained using special operators `&` (`and`),
+`|` (`or`), and `~` (`not`):
+
+```ruby
+class User < ActiveRecord::Base
+  scope :recently_signed_in, lambda {
+    where last_sign_in_at > 10.days.ago
+  }
+  
+  (score + 20 == 40).to_sql
+  # => ("users"."score" + 20) = 40
+  
+  ((username == "Bob") | (username != "Alice")).to_sql
+  # => ("users"."username" = 'Bob' OR "users"."username" != 'Alice')
+end
+
+class Product < ActiveRecord::Base
+  predicate = (attribute(:name) == nil) & ~category.in(%w( shoes shirts ))
+  predicate.to_sql
+  # => "products"."name" IS NULL AND NOT ("products"."category" IN ('shoes', 'shirts'))
+  
+  # These predicates can be used as arguments to `where`
+  where(predicate).all
+  # => SELECT "products".* FROM "products" WHERE "products"."name" IS NULL AND 
+  #    NOT ("products"."category" IN ('shoes', 'shirts'))
+end
+```
+
+Here is a complete list of Arel method aliases:
+
+* For predicates:
+  - `==`: `eq`
+  - `=~`: `matches`
+  - `!~`: `does_not_match`
+  - `>=`: `gteq`
+  - `>` : `gt`
+  - `<` : `lt`
+  - `<=`: `lteq`
+  - `!=`: `not_eq`
+
+
+* For combination
+  - `&`: `and`
+  - `|`: `or`
+  - `~`: `not` (unfortunately, unary prefix `!` doesn't work with ActiveRecord)
+
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'sexy_scopes'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sexy_scopes
+
+Then require it in your application code:
+
+    require 'sexy_scopes'
+
+
+Contributing
+------------
+
+Report bugs or suggest features using [GitHub issues](https://github.com/samleb/sexy_scopes).
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
 
 Copyright
 ---------
 
-Copyright (c) 2010 Samuel Lebeau. See LICENSE for details.
+Copyright (c) 2010-2012 Samuel Lebeau. See LICENSE for details.

data/Rakefile

@@ -1,36 +1,19 @@
-require 'rubygems'
-require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "sexy_scopes"
-    gem.summary = %Q{Small DSL to create ActiveRecord attribute predicates without writing SQL.}
-    gem.description = %Q{Small DSL to create ActiveRecord attribute predicates without writing SQL.}
-    gem.email = "samuel.lebeau@gmail.com"
-    gem.homepage = "http://github.com/samleb/sexy_scopes"
-    gem.authors = ["Samuel Lebeau"]
-    gem.add_dependency "activerecord", ">= 3.0.0.beta"
-    gem.add_development_dependency "rspec", ">= 1.2.9"
-    gem.add_development_dependency "yard", ">= 0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
+desc "Run specifications"
+RSpec::Core::RakeTask.new(:spec)
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
+desc "Measure test coverage"
+if RUBY_VERSION >= '1.9'
+  task :cov do
+    ENV['COVERAGE'] = '1'
+    Rake::Task['spec'].invoke
+  end
+else
+  RSpec::Core::RakeTask.new(:cov) do |spec|
+    spec.rcov = true
+  end
 end
 
-task :spec => :check_dependencies
-
 task :default => :spec

data/lib/sexy_scopes.rb

@@ -1,22 +1,11 @@
-require 'delegate'
-require 'active_record'
-require 'arel'
-
 module SexyScopes
-  module ClassMethods
-    def attribute(name)
-      Attribute.new(arel_table[name])
-    end
-  end
-  
-  class Attribute < DelegateClass(Arel::Attribute)
-    alias_method :<,  :lt
-    alias_method :<=, :lteq
-    alias_method :==, :eq
-    alias_method :>=, :gteq
-    alias_method :>,  :gt
-    alias_method :=~, :matches
+  %w( Version VERSION ).each do |constant|
+    autoload constant, 'sexy_scopes/version'
   end
-  
-  ActiveRecord::Base.extend ClassMethods
+end
+
+if defined? Rails::Railtie
+  require 'sexy_scopes/railtie'
+else
+  require 'sexy_scopes/active_record'
 end

data/lib/sexy_scopes/active_record.rb

@@ -0,0 +1,92 @@
+require 'delegate'
+require 'active_record'
+require 'sexy_scopes/wrappers'
+require 'sexy_scopes/arel'
+
+module SexyScopes
+  module ActiveRecord
+    include Wrappers
+
+    # Creates and extends an Arel <tt>Attribute</tt> representing the table's column with
+    # the given <tt>name</tt>.
+    #
+    # @param [String, Symbol] name The attribute name
+    #
+    # @note Please note that no exception is raised if no such column actually exists.
+    #
+    # @example
+    #   User.where(User.attribute(:score) > 1000)
+    #   # => SELECT "users".* FROM "users" WHERE ("users"."score" > 1000)
+    #
+    def attribute(name)
+      attribute = arel_table[name]
+      extend_expression(attribute)
+    end
+
+    # Creates and extends an Arel <tt>SqlLiteral</tt> instance for the given <tt>expression</tt>,
+    # first converted to a string using <tt>to_s</tt>.
+    #
+    # @param [String, #to_s] expression Any SQL expression.
+    #
+    # @example
+    #   def Circle.with_perimeter_smaller_than(perimeter)
+    #     where sql(2 * Math::PI) * radius < perimeter
+    #   end
+    #   
+    #   Circle.with_perimeter_smaller_than(20)
+    #   # => SELECT "circles".* FROM "circles" WHERE (6.283185307179586 * "circles"."radius" < 20)
+    #
+    def sql_literal(expression)
+      ::Arel.sql(expression.to_s).tap do |literal|
+        extend_expression(literal)
+        extend_predicate(literal)
+      end
+    end
+    alias_method :sql, :sql_literal
+    
+    # @!visibility private
+    def respond_to?(method_name, include_private = false) # :nodoc:
+      super || column_names.include?(method_name.to_s)
+    end
+    
+    private
+      # Equivalent to calling {#attribute} with the missing method's <tt>name</tt> if the table
+      # has a column with that name.
+      #
+      # Delegates to superclass implementation otherwise, eventually raising <tt>NoMethodError</tt>.
+      # 
+      # @see #attribute
+      #
+      # @note Due to the way this works, be careful not to use this syntactic sugar with existing
+      #       <tt>ActiveRecord::Base</tt> methods (see last example).
+      #
+      # @raise [NoMethodError] if the table has no corresponding column
+      #
+      # @example
+      #   # Suppose the "users" table has an "email" column, then these are equivalent:
+      #   User.email
+      #   User.attribute(:email)
+      #   
+      # @example
+      #   # Here is the previous example (from `attribute`) rewritten:
+      #   User.where(User.score > 1000)
+      #   # => SELECT "users".* FROM "users" WHERE ("users"."score" > 1000)
+      #
+      # @example
+      #   # Don't use it with existing `ActiveRecord::Base` methods, i.e. `name`:
+      #   User.name # => "User"
+      #   # In these cases you'll have to use `attribute` explicitely
+      #   User.attribute(:name)
+      #
+      def method_missing(name, *args)
+        if column_names.include?(name.to_s)
+          attribute(name)
+        else
+          super
+        end
+      end
+  end
+  
+  # Add these methods to Active Record
+  ::ActiveRecord::Base.extend SexyScopes::ActiveRecord
+end

data/lib/sexy_scopes/arel.rb

@@ -0,0 +1,35 @@
+module SexyScopes
+  module Arel
+    extend ActiveSupport::Autoload
+
+    autoload :ExpressionWrappers
+    autoload :PredicateWrappers
+    autoload :ExpressionMethods
+    autoload :PredicateMethods
+  end
+end
+
+module Arel
+  module Nodes
+    # <tt>Grouping</tt> nodes didn't include <tt>Arel::Predications</tt> before
+    # {https://github.com/rails/arel/commit/c78227d9b219933f54cecefb99c72bb231fbb8f2 this commit}.
+    #
+    # Here they are included explicitely just in case they're missing.
+    class Grouping
+      include Arel::Predications
+    end
+    
+    # As <tt>SqlLiteral</tt> could be any arbitrary SQL expression, include <tt>Arel::Math</tt>
+    # to allow common mathematic operations.
+    #
+    # @see SexyScopes::ActiveRecord#sql_literal
+    class SqlLiteral
+      include Arel::Math
+    end
+  end
+  
+  # @!visibility private
+  class SqlLiteral # :nodoc:
+    include Arel::Math
+  end
+end

data/lib/sexy_scopes/arel/expression_methods.rb

@@ -0,0 +1,21 @@
+module SexyScopes
+  module Arel
+    module ExpressionMethods
+      def *(other)
+        extend_expression(super)
+      end
+      
+      def +(other)
+        extend_expression(super)
+      end
+      
+      def -(other)
+        extend_expression(super)
+      end
+      
+      def /(other)
+        extend_expression(super)
+      end
+    end
+  end
+end

data/lib/sexy_scopes/arel/expression_wrappers.rb

@@ -0,0 +1,9 @@
+module SexyScopes
+  module Arel
+    module ExpressionWrappers
+      include Wrappers
+      include PredicateMethods
+      include ExpressionMethods
+    end
+  end
+end

data/lib/sexy_scopes/arel/predicate_methods.rb

@@ -0,0 +1,50 @@
+module SexyScopes
+  module Arel
+    module PredicateMethods
+      def eq(other)
+        extend_predicate(super)
+      end
+      alias == eq
+      
+      def in(other)
+        extend_predicate(super)
+      end
+      
+      def matches(other)
+        extend_predicate(super)
+      end
+      alias =~ matches
+      
+      def does_not_match(other)
+        extend_predicate(super)
+      end
+      alias !~ does_not_match
+      
+      def gteq(other)
+        extend_predicate(super)
+      end
+      alias >= gteq
+      
+      def gt(other)
+        extend_predicate(super)
+      end
+      alias > gt
+      
+      def lt(other)
+        extend_predicate(super)
+      end
+      alias < lt
+      
+      def lteq(other)
+        extend_predicate(super)
+      end
+      alias <= lteq
+      
+      def not_eq(other)
+        extend_predicate(super)
+      end
+      alias != not_eq
+    end
+  end
+end
+

data/lib/sexy_scopes/arel/predicate_wrappers.rb

@@ -0,0 +1,22 @@
+module SexyScopes
+  module Arel
+    module PredicateWrappers
+      include Wrappers
+      
+      def not
+        extend_predicate(super)
+      end
+      alias ~ not
+      
+      def or(other)
+        extend_predicate(super)
+      end
+      alias | or
+      
+      def and(other)
+        extend_predicate(super)
+      end
+      alias & and
+    end
+  end
+end

data/lib/sexy_scopes/railtie.rb

@@ -0,0 +1,9 @@
+module SexyScopes
+  class Railtie < Rails::Railtie
+    initializer 'sexy_scopes' do |app|
+      ActiveSupport.on_load :active_record do
+        require 'sexy_scopes/active_record'
+      end
+    end
+  end
+end

data/lib/sexy_scopes/version.rb

@@ -0,0 +1,11 @@
+module SexyScopes
+  module Version
+    MAJOR = 0
+    MINOR = 5
+    TINY  = 0
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+  
+  VERSION = Version::STRING
+end

data/lib/sexy_scopes/wrappers.rb

@@ -0,0 +1,13 @@
+module SexyScopes
+  # @!visibility private
+  module Wrappers # :nodoc:
+    private
+      def extend_expression(expression)
+        expression.extend(Arel::ExpressionWrappers)
+      end
+      
+      def extend_predicate(predicate)
+        predicate.extend(Arel::PredicateWrappers)
+      end
+  end
+end

data/sexy_scopes.gemspec

@@ -1,61 +1,32 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sexy_scopes/version', __FILE__)
 
-Gem::Specification.new do |s|
-  s.name = %q{sexy_scopes}
-  s.version = "0.2.0"
+Gem::Specification.new do |gem|
+  gem.name          = 'sexy_scopes'
+  gem.version       = SexyScopes::VERSION
+  
+  gem.summary = %{Write beautiful and expressive ActiveRecord scopes without SQL.}
+  gem.description = %{Small DSL to create ActiveRecord (>= 3) attribute predicates without writing SQL.}
+  
+  gem.authors       = ['Samuel Lebeau']
+  gem.email         = 'samuel.lebeau@gmail.com'
+  gem.homepage      = 'https://github.com/samleb/sexy_scopes'
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Samuel Lebeau"]
-  s.date = %q{2010-05-28}
-  s.description = %q{Small DSL to create ActiveRecord attribute predicates without writing SQL.}
-  s.email = %q{samuel.lebeau@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md"
-  ]
-  s.files = [
-    ".gitignore",
-     "LICENSE",
-     "README.md",
-     "Rakefile",
-     "VERSION",
-     "lib/sexy_scopes.rb",
-     "rails/init.rb",
-     "sexy_scopes.gemspec",
-     "spec/sexy_scopes_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/samleb/sexy_scopes}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Small DSL to create ActiveRecord attribute predicates without writing SQL.}
-  s.test_files = [
-    "spec/sexy_scopes_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0.beta"])
-      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-    else
-      s.add_dependency(%q<activerecord>, [">= 3.0.0.beta"])
-      s.add_dependency(%q<rspec>, [">= 1.2.9"])
-      s.add_dependency(%q<yard>, [">= 0"])
-    end
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  
+  gem.licenses = ['MIT']
+  
+  gem.add_dependency 'activerecord', '~> 3.0'
+  
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rails', '~> 3.0'
+  gem.add_development_dependency 'rspec', '~> 2.0'
+  gem.add_development_dependency 'sqlite3'
+  if RUBY_VERSION >= '1.9'
+    gem.add_development_dependency 'simplecov'
   else
-    s.add_dependency(%q<activerecord>, [">= 3.0.0.beta"])
-    s.add_dependency(%q<rspec>, [">= 1.2.9"])
-    s.add_dependency(%q<yard>, [">= 0"])
+    gem.add_development_dependency 'rcov'
   end
 end
-

data/spec/expression_methods_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+shared_examples "an expression method" do
+  it "should return an Arel node" do
+    subject.class.name.should =~ /^Arel::/
+  end
+  
+  it { should be_extended_by SexyScopes::Arel::ExpressionWrappers }
+end
+
+describe SexyScopes::Arel::ExpressionMethods do
+  before do
+    @attribute = User.attribute(:score)
+  end
+  
+  describe "the method `*`" do
+    subject { @attribute * 42.0 }
+    
+    it_behaves_like "an expression method"
+    
+    it { should convert_to_sql %{"users"."score" * 42.0} }
+  end
+  
+  describe "the method `+`" do
+    subject { @attribute + 42.0 }
+    
+    it_behaves_like "an expression method"
+    
+    it { should convert_to_sql %{("users"."score" + 42.0)} }
+  end
+  
+  describe "the method `-`" do
+    subject { @attribute - 42.0 }
+    
+    it_behaves_like "an expression method"
+    
+    it { should convert_to_sql %{("users"."score" - 42.0)} }
+  end
+  
+  describe "the method `/`" do
+    subject { @attribute / 42.0 }
+    
+    it_behaves_like "an expression method"
+    
+    it { should convert_to_sql %{"users"."score" / 42.0} }
+  end
+end

data/spec/predicate_methods_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+shared_examples "a predicate method" do
+  it "should return an Arel node" do
+    subject.class.name.should =~ /^Arel::/
+  end
+  
+  it { should be_extended_by SexyScopes::Arel::PredicateWrappers }
+end
+
+describe SexyScopes::Arel::PredicateMethods do
+  before do
+    @attribute = User.attribute(:score)
+  end
+  
+  METHODS = {
+    # Arel method   => [ Ruby operator, SQL operator ]
+    :eq             => [ '==',  '= %s'        ],
+    :in             => [ nil,   'IN (%s)'     ],
+    :matches        => [ '=~',  'LIKE %s'     ],
+    :does_not_match => [ '!~',  'NOT LIKE %s' ],
+    :gteq           =>   '>=',
+    :gt             =>   '>',
+    :lt             =>   '<',
+    :lteq           =>   '<=',
+    :not_eq         =>   '!='
+  }
+  
+  METHODS.each do |method, (operator, sql_operator)|
+    sql_operator ||= "#{operator} %s"
+    
+    describe "the method `#{method}`" do
+      subject { @attribute.send(method, 42.0) }
+      
+      it_behaves_like "a predicate method"
+      
+      it { should convert_to_sql %{"users"."score" #{sql_operator % 42.0}} }
+      
+      it "is aliased as `#{operator}`" do
+        @attribute.method(operator).should == @attribute.method(method)
+      end if operator
+    end
+  end
+end

data/spec/sexy_scopes_spec.rb

@@ -1,46 +1,47 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe SexyScopes do
-  it "extends `ActiveRecord::Base` with `SexyScopes::ClassMethods`" do
-    ActiveRecord::Base.singleton_class.included_modules.should include(SexyScopes::ClassMethods)
+describe SexyScopes::ActiveRecord do
+  it "should extend ActiveRecord::Base" do
+    ActiveRecord::Base.should be_extended_by SexyScopes::ActiveRecord
   end
   
-  describe "the `attribute` class method" do
-    before do
-      @attribute = User.attribute(:username)
-    end
+  describe ".attribute(name)" do
+    subject { User.attribute(:username) }
     
-    it "returns a `SexyScopes::Attribute` instance for the given attribute" do
-      @attribute.should be_a(SexyScopes::Attribute)
-      @attribute.name.should == :username
+    it "should return an Arel attribute for the given name" do
+      subject.should eql User.arel_table[:username]
     end
+    
+    it { should be_extended_by SexyScopes::Arel::ExpressionWrappers }
   end
   
-  describe SexyScopes::Attribute do
-    before do
-      @attribute = User.attribute(:username)
-      @arel_attribute = User.arel_table[:username]
+  describe ".sql_literal(expression)" do
+    subject { User.sql_literal('NOW()') }
+    
+    it "should return an Arel literal for given expression" do
+      subject.should eql(::Arel.sql('NOW()'))
     end
     
-    AREL_ALIASES = {
-      :<  => :lt,
-      :<= => :lteq,
-      :== => :eq,
-      :>= => :gteq,
-      :>  => :gt,
-      :=~ => :matches
-    }
+    it "should be aliased as `sql`" do
+      SexyScopes::ActiveRecord.instance_method(:sql).should ==
+        SexyScopes::ActiveRecord.instance_method(:sql_literal)
+    end
     
-    AREL_ALIASES.each do |method, arel_method|
-      it "aliases `Arel::Attribute##{arel_method}` with operator `#{method}`" do
-        @attribute.send(method, :any_value).should == @arel_attribute.send(arel_method, :any_value)
-      end
+    it { should be_extended_by SexyScopes::Arel::ExpressionWrappers }
+    
+    it { should be_extended_by SexyScopes::Arel::PredicateWrappers }
+  end
+  
+  context "dynamic method handling (method_missing/respond_to?)" do
+    it "should delegate to `attribute` when the method name is the name of an existing column" do
+      User.should respond_to(:username)
+      User.should_receive(:attribute).with(:username).once.and_return(:ok)
+      User.username.should == :ok
     end
     
-    (AREL_ALIASES.values + ['in']).each do |arel_method|
-      it "behaves like an `Arel::Attribute` when sent `#{arel_method}`" do
-        @attribute.send(arel_method, :any_value).should == @arel_attribute.send(arel_method, :any_value)
-      end
+    it "should raise NoMethodError otherwise" do
+      User.should_not respond_to(:foobar)
+      lambda { User.foobar }.should raise_error NoMethodError
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,16 +1,40 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'rspec'
 require 'active_record'
 require 'sexy_scopes'
-require 'spec'
-require 'spec/autorun'
+
+RSpec::Matchers.define :be_extended_by do |expected|
+  match do |actual|
+    extended_modules = actual.singleton_class.included_modules
+    extended_modules.include?(expected)
+  end
+end
+
+RSpec::Matchers.define :convert_to_sql do |expected|
+  match do |actual|
+    actual.to_sql == expected
+  end
+  
+  description do
+    "convert to the following SQL: #{expected}"
+  end
+  
+  failure_message_for_should do |actual|
+    "expected generated SQL to be \n  #{expected}\ngot\n  #{actual.to_sql}"
+  end
+end
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
 ActiveRecord::Schema.verbose = false
-ActiveRecord::Schema.define(:version => 1) do
+ActiveRecord::Schema.define do
   create_table :users do |t|
-    t.string :username
+    t.string  :username
+    t.integer :score
   end
 end
 

metadata

@@ -1,125 +1,188 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sexy_scopes
-version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 0
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Samuel Lebeau
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-05-28 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 31098225
-        segments: 
-        - 3
-        - 0
-        - 0
-        - beta
-        version: 3.0.0.beta
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 2
-        - 9
-        version: 1.2.9
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yard
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-description: Small DSL to create ActiveRecord attribute predicates without writing SQL.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Small DSL to create ActiveRecord (>= 3) attribute predicates without
+  writing SQL.
 email: samuel.lebeau@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.md
-files: 
+extra_rdoc_files: []
+files:
 - .gitignore
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
 - lib/sexy_scopes.rb
-- rails/init.rb
+- lib/sexy_scopes/active_record.rb
+- lib/sexy_scopes/arel.rb
+- lib/sexy_scopes/arel/expression_methods.rb
+- lib/sexy_scopes/arel/expression_wrappers.rb
+- lib/sexy_scopes/arel/predicate_methods.rb
+- lib/sexy_scopes/arel/predicate_wrappers.rb
+- lib/sexy_scopes/railtie.rb
+- lib/sexy_scopes/version.rb
+- lib/sexy_scopes/wrappers.rb
 - sexy_scopes.gemspec
+- spec/expression_methods_spec.rb
+- spec/predicate_methods_spec.rb
 - spec/sexy_scopes_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
-has_rdoc: true
-homepage: http://github.com/samleb/sexy_scopes
-licenses: []
-
+homepage: https://github.com/samleb/sexy_scopes
+licenses:
+- MIT
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 953557397482339219
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: 953557397482339219
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Small DSL to create ActiveRecord attribute predicates without writing SQL.
-test_files: 
+summary: Write beautiful and expressive ActiveRecord scopes without SQL.
+test_files:
+- spec/expression_methods_spec.rb
+- spec/predicate_methods_spec.rb
 - spec/sexy_scopes_spec.rb
 - spec/spec_helper.rb

data/VERSION

@@ -1 +0,0 @@
-0.2.0

data/rails/init.rb

@@ -1 +0,0 @@
-require 'sexy_scopes'

data/spec/spec.opts

@@ -1 +0,0 @@
---color