bisque 0.1.0

data/.document

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

data/.rspec

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@bisque

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'activerecord', '>= 3.0.0'
+gem 'pg'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.1.0"
+  gem "jeweler", "~> 1.8.4"
+  gem "simplecov", ">= 0"
+  gem 'spork'
+  gem 'pry'
+end

data/Gemfile.lock

@@ -0,0 +1,65 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    coderay (1.0.7)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    i18n (0.6.0)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    method_source (0.8)
+    multi_json (1.3.6)
+    pg (0.14.0)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    slop (3.3.3)
+    spork (0.9.2)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.0.0)
+  bundler (~> 1.1.0)
+  jeweler (~> 1.8.4)
+  pg
+  pry
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  simplecov
+  spork

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jeremy Holland
+
+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,108 @@
+= bisque
+
+Bisque is meant to ease the pain of "reporting"-style ad-hoc SQL queries in ActiveRecord. Most of the time, I see (and am guilty of having executed myself) solutions to this problem in one of two styles:
+
+== Fugly: New scopes / class methods / find_by_sql
+
+*Example*:
+
+  class HooHah < ActiveRecord::Base
+    scope :some_ridiculous_reporting_query, select(<<-RUBY
+        MOFO_OBSCURE_SQL_FUNCTION(some_table.some_column) AS some_non_column_field
+      RUBY
+      ).joins(<<-RUBY
+        INNER JOIN god_knows_what ON some_computationally_difficult_calculation = 5
+      RUBY
+      )
+  end
+
+*Pros*: You get to use the existing ActiveRecord::Base hot mustard to execute your queries, parse them to fields on instances of the class, and handle them as collections
+
+*Cons*: Your reports are ultimately instances of some model - but most reports are not that at all! They're aggregate views over your models, and trying to cram them into existing instances forces you to conflate two very distinct concepts in the domain.
+
+== Even Fuglier: Query straight from the connection, then use the raw result or OpenStruct it in order to achieve some measure of separation
+
+*Example*:
+
+  results = ActiveRecord::Base.connection.execute <<-RUBY
+    SELECT MOFO_OBSCURE_SQL_FUNCTION(some_table.some_column) AS some_non_column_field FROM umpteen_thousand_tables
+    INNER JOIN god_knows_what ON some_computationally_difficult_calculation = 5
+  RUBY
+
+  results.each do |row|
+    #ARGGHH
+  end
+
+*Pros*: Avoids the conflation of the report with models it doesn't represent
+*Cons*: Pretty much everything else. Lots of boilerplate.
+
+== Help Arrives!
+
+Enter Bisque. Bisque provides a simple way of defining Report classes, each with its own query and designated parameters, as well as a way to dynamically define methods on its rows. Bisque will translate any returned datatypes into their AR analog, and in general help you keep your jazz organized and tight. Here's how to use it:
+
+=== Step 1: Define a report class
+
+Reports inherit from Bisque::Report, and have the following API:
+
+  class FooReport < Bisque::Report
+    query <<-RUBY
+      SELECT
+        SUM(o.total) AS total,
+        MEAN(o.total) AS average
+      FROM
+        orders o
+      INNER JOIN
+        customers c ON c.id = o.customer_id
+      WHERE
+        o.store_type = :store_type
+        AND
+        c.id = :customer_id
+    RUBY
+
+    defaults :store_type => "digital"
+
+    rows do
+      def total_in_cents
+        total*100
+      end
+    end
+  end
+
+==== Bisque::Report.query
+Every report *must* have a query. Define it here, using colon-prefixed words to designate parameters
+
+==== Bisque::Report.defaults
+This method takes a hash of defaults, if any, for the parameters in your query. Each parameter must either have some default set for it, or be passed a value at runtime (see instantiatino below)
+
+==== Bisque::Report.rows
+If you wish to define custom methods on each individual row item of the report, define them here, and they will be evaluated in the context of the dynamically generated row class (which will be namespaced the same as the report class and named <YourReportClassName>Row).
+
+=== Step 2: Instantiate the report
+To use run a given report, just create a new instance of it. Each report instance is enumerable and so may be iterated over as usual.
+
+  report = FooReport.new :customer_id => 42
+
+You must provide a hash of values for each parameter (that doesn't have a default) defined in the query, or a Bisque::MissingParameterException will be raised and the report will not be executed.
+
+If you have defined any custom row methods (via the rows block discussed above), you may call them on each item of the iterator as one would expect:
+
+  puts report.first.total_in_cents
+
+== In closing
+For the time being, Bisque supports PostgreSQL exclusively (db-agnositicism is broken due to the necessities associated with typecasting dynamically selected values), because I virtually never use anything else and wanted this gem out there ASAP for my own purposes. I sincerely doubt I'll ever get around to extending it for support of other AR-supported dbs, but if one of you fine folks would like to do so, submit a pull request as described below and I'll happily include it. Of course, any other improvements, feature requests, etc. will be considered and taken into account - I would like to see this grow into a highly versatile tool, so suggest away!
+
+== Contributing to bisque
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Jeremy Holland. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "bisque"
+  gem.homepage = "http://github.com/awebneck/bisque"
+  gem.license = "MIT"
+  gem.summary = %Q{A simple gem for ease of use in generating reports with ActiveRecord}
+  gem.description = %Q{Bisque exists to ease the organizational pain of having to attach reporting and ad-hoc queries to ActiveRecord models in order to get any class-like behavior out of them by providing a new class and DSL for that express purpose.}
+  gem.email = "jeremy@jeremypholland.com"
+  gem.authors = ["Jeremy Holland"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bisque #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bisque.gemspec

@@ -0,0 +1,84 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "bisque"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jeremy Holland"]
+  s.date = "2012-09-01"
+  s.description = "Bisque exists to ease the organizational pain of having to attach reporting and ad-hoc queries to ActiveRecord models in order to get any class-like behavior out of them by providing a new class and DSL for that express purpose."
+  s.email = "jeremy@jeremypholland.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bisque.gemspec",
+    "lib/bisque.rb",
+    "lib/bisque/exceptions.rb",
+    "lib/bisque/report.rb",
+    "lib/bisque/report_row.rb",
+    "spec/bisque/exceptions_spec.rb",
+    "spec/bisque/report_row_spec.rb",
+    "spec/bisque/report_spec.rb",
+    "spec/bisque_spec.rb",
+    "spec/resources/models.rb",
+    "spec/resources/schema.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/awebneck/bisque"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "A simple gem for ease of use in generating reports with ActiveRecord"
+
+  if s.respond_to? :specification_version then
+    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"])
+      s.add_runtime_dependency(%q<pg>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<spork>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 3.0.0"])
+      s.add_dependency(%q<pg>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<spork>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 3.0.0"])
+    s.add_dependency(%q<pg>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<spork>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+  end
+end
+

data/lib/bisque/exceptions.rb

@@ -0,0 +1,4 @@
+module Bisque
+  class MissingParameterException < Exception; end
+  class MissingQueryException < Exception; end
+end

data/lib/bisque/report.rb

@@ -0,0 +1,146 @@
+module Bisque
+  class Report
+    include Enumerable
+
+    attr_accessor :params, :sql
+
+    def initialize(params={})
+      @params = self.class.defaults.merge params
+      @sql = self.class.query.dup
+      self.class.params.each do |param|
+        value = @params[param]
+        raise Bisque::MissingParameterException, "Missing parameter :#{param} for construction of #{self.class} - please provide a value for this parameter to the constructor or define a default." if value.nil?
+        @sql.gsub!(/:#{param}/, sanitize_and_sqlize(value))
+      end
+      @results = ActiveRecord::Base.connection.execute @sql
+      extract_datatypes
+      construct_converted
+    end
+
+    def each
+      if block_given?
+        @converted.each do |r|
+          yield r
+        end
+      else
+        Enumerator.new self, :each
+      end
+    end
+
+    def [](index)
+      @converted[index]
+    end
+
+    def last
+      @converted.last
+    end
+
+    def to_s
+      "#{self.class}: #{count} result#{'s' if count != 1}"
+    end
+
+    protected
+      def sanitize_and_sqlize(value)
+        if value.is_a? Array
+          "(#{value.map { |v| sanitize_and_sqlize(v) }.join(",")})"
+        else
+          ActiveRecord::Base.connection.quote(value)
+        end
+      end
+
+      def extract_datatypes
+        sql = "SELECT"
+        @results.fields.each_with_index do |f, i|
+          sql << " UNION SELECT" if i > 0
+          sql << " format_type(#{@results.ftype(i)}, #{@results.fmod(i)}) AS type, #{ActiveRecord::Base.sanitize(f)} AS key"
+        end
+        typeresults = ActiveRecord::Base.connection.execute(sql)
+        @types = {}
+        typeresults.to_a.each do |typeresult|
+          @types[typeresult['key'].intern] = typeresult['type']
+        end
+      end
+
+      def construct_converted
+        @converted = []
+        @results.to_a.each do |r|
+          @converted << self.class.row_class.new( r.merge(r) { |k, v| convert_value(k,v) })
+        end
+      end
+
+      def convert_value(key, value)
+        return value if value.nil?
+        case @types[key.intern]
+        when /integer/
+          value.to_i
+        when /decimal/
+          value.to_f
+        when /float/
+          value.to_f
+        when /numeric/
+          value.to_f
+        when /precision/
+          value.to_f
+        when /boolean/
+          value == 't'
+        when /date/
+          Date.parse value
+        when /timestamp/
+          Time.parse value
+        when /bytea/
+          ActiveRecord::Base.connection.unescape_bytea(value)
+        else
+          value.to_s
+        end
+      end
+
+    class << self
+      def default(key, val)
+        @defaults ||= {}
+        @defaults[key] = val
+      end
+
+      def defaults(hash=nil)
+        if hash
+          @defaults ||= {}
+          @defaults.merge! hash
+        else
+          @defaults || {}
+        end
+      end
+
+      def query(qstr=nil)
+        if qstr
+          @qstr = qstr.strip
+          @params = qstr.scan(/:\w+/).map { |p| p.gsub(/:/,'').intern }
+        else
+          raise Bisque::MissingQueryException, "Bisque Report #{self} missing query definition." if @qstr.nil?
+          @qstr
+        end
+      end
+
+      def rows(&block)
+        if block_given?
+          carray = self.to_s.split(/::/)
+          carray.last << 'Row'
+          @row_class = carray.join('::')
+          c =  Class.new(Bisque::ReportRow)
+          c.class_eval(&block)
+          Object.const_set @row_class, c
+        end
+      end
+
+      def row_class
+        return Bisque::ReportRow if @row_class.nil?
+        names = @row_class.split('::')
+        names.reduce(Object) do |mod, name|
+          mod.const_defined?(name) ? mod.const_get(name) : mod.const_missing(name)
+        end
+      end
+
+      def params
+        @params || []
+      end
+    end
+  end
+end

data/lib/bisque/report_row.rb

@@ -0,0 +1,12 @@
+module Bisque
+  class ReportRow
+    def initialize(hash)
+      @fields = hash
+      hash.keys.each do |k|
+        unless self.respond_to? k
+          self.singleton_class.send(:define_method, k) { @fields[k] }
+        end
+      end
+    end
+  end
+end

data/lib/bisque.rb

@@ -0,0 +1,6 @@
+require 'bisque/exceptions'
+require 'bisque/report_row'
+require 'bisque/report'
+
+module Bisque
+end

data/spec/bisque/exceptions_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Bisque Exceptions" do
+  describe Bisque::MissingQueryException do
+    it "should be an Exception" do
+      Bisque::MissingQueryException.ancestors.should include Exception
+    end
+  end
+  describe Bisque::MissingParameterException do
+    it "should be an Exception" do
+      Bisque::MissingQueryException.ancestors.should include Exception
+    end
+  end
+end

data/spec/bisque/report_row_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Bisque::ReportRow do
+  before :all do
+    Frobnitz.create :name => 'Howdy',
+                    :description => 'Here is some text',
+                    :score => 12,
+                    :cost => 48.22,
+                    :numberish => Math::PI,
+                    :timish => Time.now - (60*60*24*3),
+                    :summed_at => Time.now + (60*60*24*3),
+                    :created_on => Date.new(2012),
+                    :boolish => true,
+                    :binny => "\x00\x01\x02\x03"
+    Frobnitz.create :name => 'Slam',
+                    :description => 'Here is some other text',
+                    :score => 8,
+                    :cost => 12.53,
+                    :numberish => Math::E,
+                    :timish => Time.now + (60*60*24*3),
+                    :summed_at => Time.now - (60*60*24*3),
+                    :created_on => Date.new(2011),
+                    :boolish => false,
+                    :binny => "\x03\x02\x01\x00"
+  end
+
+  describe "construction" do
+    it "should be an instance of Bisque::ReportRow if the rows block is undefined" do
+      f = FooReport.new
+      f.first.should be_a Bisque::ReportRow
+    end
+
+    it "should be an instance of the dynamically created Row class if the rows block is defined" do
+      f = FooeyReport.new :corn => 'hat'
+      f.first.should be_a FooeyReportRow
+    end
+  end
+
+  describe "instance methods" do
+    it "should provide an accessor method for each field in the report" do
+      f = FooReport.new
+      r = f.first
+      r.name.should == 'Howdy'
+      r.description.should == 'Here is some text'
+      r.score.should == 12
+      r.cost.should == 48.22
+      ((Math::PI - r.numberish).abs < 0.001).should == true
+      r.timish.should_not be_nil
+      r.summed_at.should_not be_nil
+      r.created_on.should_not be_nil
+      r.boolish.should == true
+      r.binny.should == "\x00\x01\x02\x03"
+    end
+
+    it "should respond to calls defined in the rows block" do
+      f = FooeyReport.new :corn => 'hat'
+      f.first.whoop.should == 'silly'
+    end
+  end
+
+  after(:all) do
+    Frobnitz.destroy_all
+  end
+end

data/spec/bisque/report_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe Bisque::Report do
+  describe "class methods" do
+    describe "query" do
+      it "should return the query specified in the class" do
+        FooReport.query.should == "SELECT * FROM frobnitzs"
+        BarReport.query.should == "SELECT * FROM frobnitzs WHERE name = :corn"
+      end
+
+      it "should raise a Bisque::MissingQueryException if no query is defined" do
+        lambda { NoQueryReport.query }.should raise_error Bisque::MissingQueryException
+      end
+    end
+
+    describe "params" do
+      it "should return an empty array if no parameters exist" do
+        FooReport.params.should be_a Array
+        FooReport.params.should be_empty
+      end
+
+      it "should return a list of the parameters extracted from the query if present" do
+        FooReport.params.should be_a Array
+        BarReport.params.length.should == 1
+        BarReport.params.should include :corn
+      end
+    end
+
+    describe "defaults" do
+      it "should return an empty hash if no defaults exist" do
+        BarReport.defaults.should be_a Hash
+        BarReport.defaults.should be_empty
+      end
+
+      it "should return an empty hash of default values specified by the defaults class method" do
+        BazReport.defaults.should be_a Hash
+        BazReport.defaults[:corn].should == 'hat'
+      end
+
+      it "should return an empty hash of default values specified by the default class method" do
+        QuuxReport.defaults.should be_a Hash
+        QuuxReport.defaults[:slip].should == 'paper'
+      end
+    end
+
+    describe "row_class" do
+      it "should return Bisque::ReportRow if no rows block is defined" do
+        FooReport.row_class.should == Bisque::ReportRow
+      end
+
+      it "should return the dynamic class defined by the report's class if a rows block is defined" do
+        FunReport.row_class.should == FunReportRow
+      end
+    end
+  end
+
+  describe "behaviors" do
+    it "should be Enumerable" do
+      FooReport.should include Enumerable
+    end
+  end
+
+  describe "instance methods" do
+    before :all do
+      Frobnitz.create :name => 'Howdy',
+                      :description => 'Here is some text',
+                      :score => 12,
+                      :cost => 48.22,
+                      :numberish => Math::PI,
+                      :timish => Time.now - (60*60*24*3),
+                      :summed_at => Time.now + (60*60*24*3),
+                      :created_on => Date.new(2012),
+                      :boolish => true,
+                      :binny => "\x00\x01\x02\x03"
+      Frobnitz.create :name => 'Slam',
+                      :description => 'Here is some other text',
+                      :score => 8,
+                      :cost => 12.53,
+                      :numberish => Math::E,
+                      :timish => Time.now + (60*60*24*3),
+                      :summed_at => Time.now - (60*60*24*3),
+                      :created_on => Date.new(2011),
+                      :boolish => false,
+                      :binny => "\x03\x02\x01\x00"
+    end
+
+    describe "construction" do
+      it "should be constructable with no arguments if the query designates no parameters" do
+        lambda { FooReport.new }.should_not raise_error
+      end
+
+      it "should be constructable with no arguments if the query designates parameters and defaults therefor" do
+        lambda { BazReport.new }.should_not raise_error
+      end
+
+      it "should raise a Bisque::MissingParameterException if the query designates parameters but no defaults, and it is constructed with no arguments" do
+        lambda { BarReport.new }.should raise_error Bisque::MissingParameterException
+      end
+
+      it "should accept a hash of parameters" do
+        lambda { BarReport.new :corn => 'cheese' }.should_not raise_error
+      end
+    end
+
+    describe "to_s" do
+      it "should return the name of the class and a count of resulting rows" do
+        f = FooReport.new
+        f.to_s.should == 'FooReport: 2 results'
+      end
+    end
+
+    describe "each" do
+      it "should return an enumerator of the results if called without a block" do
+        f = FooReport.new
+        e = f.each
+        e.should be_a Enumerator
+        e.count.should == 2
+      end
+
+      it "should loop over the results, passing each result to the block if called with a block" do
+        f = FooReport.new
+        i = 0
+        f.each do |r|
+          i += 1
+        end
+        i.should == 2
+      end
+    end
+
+    describe "[]" do
+      it "should allow array access to the results" do
+        f = FooReport.new
+        f[0].should be_a Bisque::ReportRow
+        f[1].should be_a Bisque::ReportRow
+        f[0].should_not == f[1]
+      end
+    end
+
+    describe "last" do
+      it "should return the last result" do
+        f = FooReport.new
+        f.last.should == f[1]
+      end
+    end
+
+    describe "params" do
+      it "should return the hash of specified parameters if there are no defaults" do
+        b = BarReport.new :corn => 'chili'
+        b.params.should == {:corn => 'chili'}
+      end
+
+      it "should return the hash of defaults overridden with specified parameters if defaults are defind" do
+        b = BazReport.new
+        b.params.should == {:corn => 'hat'}
+        b = BazReport.new :corn => 'powder'
+        b.params.should == {:corn => 'powder'}
+      end
+    end
+
+    describe "sql" do
+      it "should return the report's query with the parameters interpolated thereto" do
+        p = ParamReport.new :name => 'test',
+                            :description => 'testagain',
+                            :score => 12,
+                            :cost => 34.12,
+                            :numberish => 123.35583,
+                            :created_at => Time.new(2012,1,1,5,0,0),
+                            :timish => Time.new(2012,1,1,6,0,0),
+                            :summed_at => Time.new(2012,1,1,7,0,0),
+                            :created_on => Date.new(2012,2,1),
+                            :boolish => true,
+                            :binny => "\x00\x01\x02\x03"
+        p.sql.should == "SELECT * FROM frobnitzs WHERE name = 'test' AND description = 'testagain' AND score = 12 AND cost = 34.12 AND numberish = 123.35583 AND created_at = '2012-01-01 05:00:00.000000' AND timish = '2012-01-01 06:00:00.000000' AND summed_at = '2012-01-01 07:00:00.000000' AND created_on = '2012-02-01' AND boolish = 't' AND binny = ''"
+      end
+    end
+
+    after(:all) do
+      Frobnitz.destroy_all
+    end
+  end
+end

data/spec/bisque_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Bisque do
+  it "should define the Bisque::Report class" do
+    lambda { Bisque::Report }.should_not raise_error
+  end
+  it "should define the Bisque::ReportRow class" do
+    lambda { Bisque::ReportRow }.should_not raise_error
+  end
+  it "should define the Bisque::MissingQueryException class" do
+    lambda { Bisque::MissingQueryException }.should_not raise_error
+  end
+  it "should define the Bisque::MissingParameterException class" do
+    lambda { Bisque::MissingParameterException }.should_not raise_error
+  end
+end

data/spec/resources/models.rb

@@ -0,0 +1,46 @@
+class Frobnitz < ActiveRecord::Base
+end
+
+class NoQueryReport < Bisque::Report
+end
+
+class FooReport < Bisque::Report
+  query "SELECT * FROM frobnitzs"
+end
+
+class FooeyReport < Bisque::Report
+  query "SELECT * FROM frobnitzs"
+  rows do
+    def whoop
+      'silly'
+    end
+  end
+end
+
+class BarReport < Bisque::Report
+  query "SELECT * FROM frobnitzs WHERE name = :corn"
+end
+
+class BazReport < Bisque::Report
+  query "SELECT * FROM frobnitzs WHERE name = :corn"
+  defaults :corn => 'hat'
+end
+
+class QuuxReport < Bisque::Report
+  query "SELECT * FROM frobnitzs WHERE name = :corn"
+  default :slip, 'paper'
+end
+
+class FunReport < Bisque::Report
+  query "SELECT * FROM frobnitzs WHERE name = :corn"
+  default :slip, 'paper'
+  rows do
+    def whoop
+      'silly'
+    end
+  end
+end
+
+class ParamReport < Bisque::Report
+  query "SELECT * FROM frobnitzs WHERE name = :name AND description = :description AND score = :score AND cost = :cost AND numberish = :numberish AND created_at = :created_at AND timish = :timish AND summed_at = :summed_at AND created_on = :created_on AND boolish = :boolish AND binny = :binny"
+end

data/spec/resources/schema.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :frobnitzs, :force => true do |t|
+    t.column :name, :string
+    t.column :description, :text
+    t.column :score, :integer
+    t.column :cost, :decimal, :precision => 5, :scale => 2
+    t.column :numberish, :float
+    t.column :created_at, :datetime
+    t.column :timish, :timestamp
+    t.column :summed_at, :time
+    t.column :created_on, :date
+    t.column :boolish, :boolean
+    t.column :binny, :binary
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'active_record'
+require 'fileutils'
+require 'bisque'
+require 'pry'
+
+DB_USER = 'bisque'
+DB_PASS = 'bisquepass1234'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+def stfu
+  begin
+    orig_stderr = $stderr.clone
+    orig_stdout = $stdout.clone
+    $stderr.reopen File.new('/dev/null', 'w')
+    $stdout.reopen File.new('/dev/null', 'w')
+    retval = yield
+  rescue Exception => e
+    $stdout.reopen orig_stdout
+    $stderr.reopen orig_stderr
+    raise e
+  ensure
+    $stdout.reopen orig_stdout
+    $stderr.reopen orig_stderr
+  end
+  retval
+end
+
+RSpec.configure do |config|
+  dir = File.dirname(__FILE__)
+  dbconfig = {
+     'adapter' => 'postgresql',
+     'encoding' => 'unicode',
+     'database' => 'bisque_development',
+     'pool' => 5,
+     'username' => DB_USER,
+     'password' => DB_PASS}
+
+  config.before(:all) do
+    ENV["RAILS_ENV"] ||= "test"
+    ActiveRecord::Base.establish_connection dbconfig.merge 'database' => 'postgres', 'schema_search_path' => 'public'
+    ActiveRecord::Base.connection.create_database dbconfig['database'], dbconfig
+    ActiveRecord::Base.remove_connection
+    ActiveRecord::Base.configurations = {'test' => dbconfig}
+    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+    ActiveRecord::Migration.verbose = false
+    stfu do
+      load "#{dir}/resources/schema.rb"
+      load "#{dir}/resources/models.rb"
+    end
+  end
+
+  config.after(:all) do
+    ActiveRecord::Base.remove_connection
+    ActiveRecord::Base.establish_connection dbconfig.merge 'database' => 'postgres', 'schema_search_path' => 'public'
+    ActiveRecord::Base.connection.drop_database dbconfig['database']
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: bisque
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Holland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &11122500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *11122500
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &11120660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *11120660
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &11118060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *11118060
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &11115660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *11115660
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &11552740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *11552740
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &11546320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: *11546320
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &11036180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11036180
+- !ruby/object:Gem::Dependency
+  name: spork
+  requirement: &11035140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11035140
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &11032380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11032380
+description: Bisque exists to ease the organizational pain of having to attach reporting
+  and ad-hoc queries to ActiveRecord models in order to get any class-like behavior
+  out of them by providing a new class and DSL for that express purpose.
+email: jeremy@jeremypholland.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bisque.gemspec
+- lib/bisque.rb
+- lib/bisque/exceptions.rb
+- lib/bisque/report.rb
+- lib/bisque/report_row.rb
+- spec/bisque/exceptions_spec.rb
+- spec/bisque/report_row_spec.rb
+- spec/bisque/report_spec.rb
+- spec/bisque_spec.rb
+- spec/resources/models.rb
+- spec/resources/schema.rb
+- spec/spec_helper.rb
+homepage: http://github.com/awebneck/bisque
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -468949534080404133
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A simple gem for ease of use in generating reports with ActiveRecord
+test_files: []