ar_oo_select 0.5.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+.svn

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Elliot Winkler
+
+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.md

@@ -0,0 +1,57 @@
+# ar_oo_select
+
+## Summary
+
+A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`.
+
+## Rationale
+
+Let's face it, ActiveRecord is slow. Sometimes you need a way to bypass ActiveRecord but still enjoy the typecasting and object-oriented goodness it provides. `ar_oo_select` allows you to do just that.
+
+As you may or may not know, ActiveRecord gives you four methods to perform a low-level SQL query through the connection object itself:
+
+* `connection.select_all`
+* `connection.select_rows`
+* `connection.select_one`
+* `connection.select_value`
+
+Likewise, `ar_oo_select` gives you four methods that are simply a wrapper for their builtin counterparts:
+
+* `oo_select_all` (aliased to `oo_select` since this is most common)
+* `oo_select_rows`
+* `oo_select_one`
+* `oo_select_value`
+
+The difference is that 1) your query goes through AR's `sanitize_sql` method before reaching the connection methods and 2) the values in the result set are typecasted depending on what they look like (date, time, integer, float, or boolean). In the case of `oo_select_all`, the hashes that come from the result set are converted to special hashes whose values you can access using an object-oriented syntax (or openhashes for short), so it still feels like ActiveRecord. This is done using one of four libraries you may have installed, in this order:
+
+* [Mash](http://github.com/mbleigh/mash/)
+* [OpenObject](http://facets.rubyforge.org/doc/api/more/classes/OpenObject.html), provided by Ruby Facets
+* [OpenHash](http://github.com/mcmire/openhash), a library I've written
+* [OpenStruct](http://apidock.com/ruby/OpenStruct), included in the Ruby standard library
+
+## Usage
+
+All four methods receive the same arguments as `find_by_sql`: either a statement, or statement + bind variables. In addition, you can pass a second argument to specify whether the generated SQL should be sanitized. Taking `oo_select_all` as an example:
+
+    oo_select_all(query)
+    oo_select_all([query, vars])
+    oo_select_all(query, false) # don't sanitize sql
+    oo_select_all([query, vars], false) # don't sanitize sql
+
+## Installation
+
+1. Run `gem install ar_oo_select` (probably as root)
+2. Add `config.gem 'ar_oo_select'` to environment.rb
+3. Optionally run `rake gems:unpack`
+  
+## Support
+
+If you find any bugs with this plugin, feel free to:
+
+* file a bug report in the [Issues area on Github](http://github.com/mcmire/ar_oo_select/issues)
+* fork the [project on Github](http://github.com/mcmire/ar_oo_select) and send me a pull request
+* email me (_firstname_ dot _lastname_ at gmail dot com)
+
+## Author/License
+
+(c) 2009-2010 Elliot Winkler. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+require File.dirname(__FILE__) + "/lib/mcmire/ar_oo_select/version"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = Mcmire::ArOoSelect::VERSION
+    gem.name = "ar_oo_select"
+    gem.summary = %Q{A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`}
+    gem.description = %Q{A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`}
+    gem.email = "elliot.winkler@gmail.com"
+    gem.homepage = "http://github.com/mcmire/ar_oo_select"
+    gem.authors = ["Elliot Winkler"]
+    gem.add_dependency "activerecord", "< 3.0"
+    gem.add_development_dependency "mcmire-protest", "~> 0.2.4"
+    gem.add_development_dependency "mcmire-matchy", "~> 0.4.1"
+    gem.add_development_dependency "mcmire-mocha", "~> 0.9.8"
+    gem.add_development_dependency "mocha-protest-integration"
+    gem.add_development_dependency "mash"
+    gem.add_development_dependency "mcmire-openhash"
+    gem.add_development_dependency "facets"
+    #gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/ar_oo_select.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ar_oo_select}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Elliot Winkler"]
+  s.date = %q{2010-01-14}
+  s.description = %q{A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`}
+  s.email = %q{elliot.winkler@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "ar_oo_select.gemspec",
+     "lib/mcmire/ar_oo_select.rb",
+     "lib/mcmire/ar_oo_select/ar_ext.rb",
+     "lib/mcmire/ar_oo_select/version.rb",
+     "lib/mcmire/ar_oo_select/will_paginate_ext.rb",
+     "rails/init.rb",
+     "test/ar_oo_select_test.rb",
+     "test/helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mcmire/ar_oo_select}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`}
+  s.test_files = [
+    "test/ar_oo_select_test.rb",
+     "test/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::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["< 3.0"])
+      s.add_development_dependency(%q<mcmire-protest>, ["~> 0.2.4"])
+      s.add_development_dependency(%q<mcmire-matchy>, ["~> 0.4.1"])
+      s.add_development_dependency(%q<mcmire-mocha>, ["~> 0.9.8"])
+      s.add_development_dependency(%q<mocha-protest-integration>, [">= 0"])
+      s.add_development_dependency(%q<mash>, [">= 0"])
+      s.add_development_dependency(%q<mcmire-openhash>, [">= 0"])
+      s.add_development_dependency(%q<facets>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, ["< 3.0"])
+      s.add_dependency(%q<mcmire-protest>, ["~> 0.2.4"])
+      s.add_dependency(%q<mcmire-matchy>, ["~> 0.4.1"])
+      s.add_dependency(%q<mcmire-mocha>, ["~> 0.9.8"])
+      s.add_dependency(%q<mocha-protest-integration>, [">= 0"])
+      s.add_dependency(%q<mash>, [">= 0"])
+      s.add_dependency(%q<mcmire-openhash>, [">= 0"])
+      s.add_dependency(%q<facets>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["< 3.0"])
+    s.add_dependency(%q<mcmire-protest>, ["~> 0.2.4"])
+    s.add_dependency(%q<mcmire-matchy>, ["~> 0.4.1"])
+    s.add_dependency(%q<mcmire-mocha>, ["~> 0.9.8"])
+    s.add_dependency(%q<mocha-protest-integration>, [">= 0"])
+    s.add_dependency(%q<mash>, [">= 0"])
+    s.add_dependency(%q<mcmire-openhash>, [">= 0"])
+    s.add_dependency(%q<facets>, [">= 0"])
+  end
+end
+

data/lib/mcmire/ar_oo_select.rb

@@ -0,0 +1,26 @@
+module Mcmire
+  module ArOoSelect
+    def self.open_hash
+      @open_hash ||= try_loading(
+        ['mash', :Mash],
+        ['facets/openobject', :OpenObject],
+        ['openhash', :OpenHash],
+        ['ostruct' => :OpenStruct]
+      )
+    end
+    def self.try_loading(*libs)
+      klass = nil
+      libs.each do |path, sym|
+        begin
+          require path
+          klass = Object.const_get(sym)
+          break
+        rescue LoadError
+        end
+      end
+      klass
+    end
+  end
+end
+
+require 'mcmire/ar_oo_select/ar_ext'

data/lib/mcmire/ar_oo_select/ar_ext.rb

@@ -0,0 +1,73 @@
+module Mcmire
+  module ArOoSelect
+    module ArExt
+      def self.included(base)
+        base.class_eval do
+          alias_method :oo_select, :oo_select_all
+        end
+      end
+    
+      # Executes the query and returns an array of openhashes.
+      def oo_select_all(query, options={})
+        options.reverse_merge!(:sanitize => true, :type_cast => true)
+        query = sanitize_sql(query) if options[:sanitize]
+        rows = connection.select_all(query)
+        if options[:type_cast]
+          rows.map! do |row|
+            oh = ArOoSelect.open_hash.new
+            row.each {|k, v| oh.send("#{k}=", oo_select_type_cast(v)) }
+            oh
+          end
+        end
+        rows
+      end
+    
+      # Executes the query and returns the first row as an openhash.
+      def oo_select_one(query, options={})
+        oo_select_all(query, options).first
+      end
+    
+      # Executes the query and returns the value of the first column in the first row.
+      def oo_select_value(query, options={})
+        options.reverse_merge!(:sanitize => true, :type_cast => true)
+        query = sanitize_sql(query) if options[:sanitize]
+        value = connection.select_value(query)
+        value = oo_select_type_cast(value) if options[:type_cast]
+        value
+      end
+    
+      # Executes the query and returns an array of rows.
+      def oo_select_rows(query, options={})
+        options.reverse_merge!(:sanitize => true, :type_cast => true)
+        query = sanitize_sql(query) if options[:sanitize]
+        rows = connection.select_rows(query)
+        if options[:type_cast]
+          rows.map! do |row|
+            row.map {|v| oo_select_type_cast(v) }
+          end
+        end
+        rows
+      end
+    
+    private
+      def oo_select_type_cast(v)
+        return unless v
+        if md = v.match(/^(\d{4})-(\d{2})-(\d{2})$/)
+          Date.new(*md.captures.map(&:to_i)) rescue v
+        elsif md = v.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/)
+          Time.local(*md.captures.map(&:to_i)) rescue v
+        elsif v =~ /^(?:-|\+)?\d+$/
+          v.to_i
+        elsif v =~ /^(?:-|\+)?\d+(?:\.\d+)+$/
+          v.to_f
+        elsif v == "true"
+          true
+        elsif v == "false"
+          false
+        else
+          v
+        end
+      end
+    end
+  end
+end

data/lib/mcmire/ar_oo_select/version.rb

@@ -0,0 +1,5 @@
+module Mcmire
+  module ArOoSelect
+    VERSION = "0.5.0"
+  end
+end

data/lib/mcmire/ar_oo_select/will_paginate_ext.rb

@@ -0,0 +1,26 @@
+module ArOoSelect
+  module WillPaginateExt
+    # Patch to use our oo_select_all instead of connection.select_all
+    def oo_select_paginate(sql, options)
+      WillPaginate::Collection.create(*wp_parse_options(options)) do |pager|
+        query = sanitize_sql(sql)
+        original_query = query.dup
+        # add limit, offset
+        add_limit! query, :offset => pager.offset, :limit => pager.per_page
+        # perform the find
+        pager.replace oo_select_all(query)
+
+        unless pager.total_entries
+          count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s]+$/mi, ''
+          count_query = "SELECT COUNT(*) FROM (#{count_query})"
+
+          unless ['oracle', 'oci'].include?(self.connection.adapter_name.downcase)
+            count_query << ' AS count_table'
+          end
+          # perform the count query
+          pager.total_entries = count_by_sql(count_query)
+        end
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+require 'mcmire/ar_oo_select'
+ActiveRecord::Base.extend(Mcmire::ArOoSelect::ArExt)
+
+# I'm not sure if this should be here?
+#if defined?(WillPaginate)
+#  require 'mcmire/ar_oo_select/will_paginate_ext'
+#  ActiveRecord::Base.extend(ArOoSelect::WillPaginateExt)
+#end

data/test/ar_oo_select_test.rb

@@ -0,0 +1,190 @@
+require 'helper'
+
+$shared_tests = lambda do
+  context "oo_select_all" do
+    before do
+      ActiveRecord::Base.stubs(:sanitize_sql).returns("sanitized query")
+      ActiveRecord::Base.connection.stubs(:select_all).returns([ {"foo" => "1"} ])
+    end
+    test "sanitized and type casted" do
+      results = ActiveRecord::Base.oo_select_all(["query", "some", "args"])
+      p :results => results
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_all).with("sanitized query")
+      results[0].foo.should == 1
+    end
+    test "not sanitized, just type casted" do
+      results = ActiveRecord::Base.oo_select_all("query", :sanitize => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).never
+      ActiveRecord::Base.connection.should have_received(:select_all).with("query")
+      results[0].foo.should == 1
+    end
+    test "not type casted, just sanitized" do
+      results = ActiveRecord::Base.oo_select_all(["query", "some", "args"], :type_cast => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_all).with("sanitized query")
+      results[0]["foo"].should == "1"
+    end
+  end
+  context "oo_select_one" do
+    before do
+      ActiveRecord::Base.stubs(:sanitize_sql).returns("sanitized query")
+      ActiveRecord::Base.connection.stubs(:select_all).returns([ {"foo" => "1"} ])
+    end
+    test "sanitized and type casted" do
+      result = ActiveRecord::Base.oo_select_one(["query", "some", "args"])
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_all).with("sanitized query")
+      result.foo.should == 1
+    end
+    test "not sanitized, just type casted" do
+      result = ActiveRecord::Base.oo_select_one("query", :sanitize => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).never
+      ActiveRecord::Base.connection.should have_received(:select_all).with("query")
+      result.foo.should == 1
+    end
+    test "not type casted, just sanitized" do
+      result = ActiveRecord::Base.oo_select_one(["query", "some", "args"], :type_cast => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_all).with("sanitized query")
+      result["foo"].should == "1"
+    end
+  end
+  context "oo_select_value" do
+    before do
+      ActiveRecord::Base.stubs(:sanitize_sql).returns("sanitized query")
+      ActiveRecord::Base.connection.stubs(:select_value).returns("1")
+    end
+    test "sanitized and type casted" do
+      result = ActiveRecord::Base.oo_select_value(["query", "some", "args"])
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_value).with("sanitized query")
+      result.should == 1
+    end
+    test "not sanitized, just type casted" do
+      result = ActiveRecord::Base.oo_select_value("query", :sanitize => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).never
+      ActiveRecord::Base.connection.should have_received(:select_value).with("query")
+      result.should == 1
+    end
+    test "not type casted, just sanitized" do
+      result = ActiveRecord::Base.oo_select_value(["query", "some", "args"], :type_cast => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_value).with("sanitized query")
+      result.should == "1"
+    end
+  end
+  context "oo_select_rows" do
+    before do
+      ActiveRecord::Base.stubs(:sanitize_sql).returns("sanitized query")
+      ActiveRecord::Base.connection.stubs(:select_rows).returns([ ["foo", "1"] ])
+    end
+    test "sanitized and type casted" do
+      results = ActiveRecord::Base.oo_select_rows(["query", "some", "args"])
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_rows).with("sanitized query")
+      results[0].should == ["foo", 1]
+    end
+    test "not sanitized, just type casted" do
+      results = ActiveRecord::Base.oo_select_rows("query", :sanitize => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).never
+      ActiveRecord::Base.connection.should have_received(:select_rows).with("query")
+      results[0].should == ["foo", 1]
+    end
+    test "not type casted, just sanitized" do
+      results = ActiveRecord::Base.oo_select_rows(["query", "some", "args"], :type_cast => false)
+      ActiveRecord::Base.should have_received(:sanitize_sql).with(["query", "some", "args"])
+      ActiveRecord::Base.connection.should have_received(:select_rows).with("sanitized query")
+      results[0].should == ["foo", "1"]
+    end
+  end
+end
+
+def stub_query(sym)
+  ActiveRecord::Base.connection.stubs(sym).returns([
+    {
+      "created_at" => "2009-01-02 11:22:33",
+      "created_on" => "2009-01-02",
+      "loss" => "-3",
+      "gain" => "11",
+      "money_loss" => "-3.34",
+      "money_gain" => "9.24",
+      "zaxbied" => "true",
+      "yazzled" => "false",
+      "text" => "yellow"
+    }
+  ])
+end
+
+Protest.context "ar_oo_select" do
+  context "using mash" do
+    global_setup do
+      require 'mash'
+    end
+    #global_teardown do
+    #  Object.remove_class(Mash)
+    #  Object.const_defined?(:Mash) and raise "Tried to remove Mash, but it's still defined!"
+    #end
+    setup do
+      Mcmire::ArOoSelect.stubs(:open_hash).returns(Mash)
+    end
+    instance_eval(&$shared_tests)
+  end
+
+  context "using my openhash" do
+    global_setup do
+      require 'openhash'
+    end
+    #global_teardown do
+    #  Object.remove_class(OpenHash)
+    #  Object.const_defined?(:OpenHash) and raise "Tried to remove OpenHash, but it's still defined!"
+    #end
+    setup do
+      Mcmire::ArOoSelect.stubs(:open_hash).returns(OpenHash)
+    end
+    instance_eval(&$shared_tests)
+  end
+
+  # XXX: I can't get this to work for some reason?!
+  #context "using facets' openhash" do
+  #  global_setup do
+  #    require 'facets/openhash'
+  #  end
+  #  global_teardown do
+  #    Object.remove_class(OpenHash)
+  #    Object.const_defined?(:OpenHash) and raise "Tried to remove OpenHash, but it's still defined!"
+  #  end
+  #  setup do
+  #    Mcmire::ArOoSelect.stubs(:open_hash).returns(OpenHash)
+  #  end
+  #  instance_eval(&$shared_tests)
+  #end
+
+  context "using facets' openobject" do
+    global_setup do
+      require 'facets/openobject'
+    end
+    #global_teardown do
+    #  Object.remove_class(OpenObject)
+    #  Object.const_defined?(:OpenObject) and raise "Tried to remove OpenObject, but it's still defined!"
+    #end
+    setup do
+      Mcmire::ArOoSelect.stubs(:open_hash).returns(OpenObject)
+    end
+    instance_eval(&$shared_tests)
+  end
+  
+  context "using ruby built-in ostruct" do
+    global_setup do
+      require 'ostruct'
+    end
+    #global_teardown do
+    #  Object.remove_class(OpenStruct)
+    #  Object.const_defined?(:OpenStruct) and raise "Tried to remove OpenStruct, but it's still defined!"
+    #end
+    setup do
+      Mcmire::ArOoSelect.stubs(:open_hash).returns(OpenStruct)
+    end
+    instance_eval(&$shared_tests)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+
+require 'activerecord'
+
+gem 'mcmire-protest'
+require 'protest'
+gem 'mcmire-matchy'
+require 'matchy'
+gem 'mcmire-mocha'
+require 'mocha'
+require 'mocha-protest-integration'
+
+Protest.report_with :documentation
+
+Protest::Utils::BacktraceFilter::ESCAPE_PATHS << %r|test/unit| << %r|matchy| << %r|mocha-protest-integration|
+
+# soon to be mocha-matchy-integration
+class Protest::TestCase
+  custom_matcher :have_received do |receiver, matcher, args|
+    receiver = receiver.respond_to?(:mocha) ? receiver.mocha : receiver
+    expected_method_name = args[0]
+
+    expectation = Mocha::Expectation.new(receiver, expected_method_name)
+    
+    matcher.chained_messages.each do |message|
+      expectation.send(message.name, *message.args, &message.block)
+    end
+    invocations = Mocha::Mockery.instance.invocations.select do |invocation|
+      invocation.mock.equal?(receiver)
+    end
+    matching_invocations = invocations.select do |invocation|
+      expectation.match?(invocation.method_name, *invocation.arguments)
+    end
+    expectation.invocation_count = matching_invocations.size
+    ret = expectation.verified?
+    
+    matcher.positive_failure_message = expectation.mocha_inspect
+    matcher.negative_failure_message = "You should never get this error message. You're probably saying .should_not have_received(...). Try using .should have_received(...).never instead."
+    
+    ret
+  end
+end
+
+ActiveRecord::Base.establish_connection(
+  "adapter" => "sqlite3",
+  "database" => ":memory:"
+)
+
+require 'rails/init'

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: ar_oo_select
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Elliot Winkler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-14 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mcmire-protest
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mcmire-matchy
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mcmire-mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha-protest-integration
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mash
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mcmire-openhash
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`
+email: elliot.winkler@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- ar_oo_select.gemspec
+- lib/mcmire/ar_oo_select.rb
+- lib/mcmire/ar_oo_select/ar_ext.rb
+- lib/mcmire/ar_oo_select/version.rb
+- lib/mcmire/ar_oo_select/will_paginate_ext.rb
+- rails/init.rb
+- test/ar_oo_select_test.rb
+- test/helper.rb
+has_rdoc: true
+homepage: http://github.com/mcmire/ar_oo_select
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A little gem that lets you execute lower-level ActiveRecord queries and access the resulting rows like you would by calling `find_by_sql`
+test_files: 
+- test/ar_oo_select_test.rb
+- test/helper.rb