squirm 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+spec/coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.yardopts

@@ -0,0 +1,4 @@
+--files=*.md
+--protected
+--list-undoc
+--exclude lib/squirm/version

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Norman Clarke and Business Vision S.A.
+
+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,77 @@
+# Squirm
+
+Squirm is a database library that facilitates working with Postgres and stored
+procedures.
+
+## About
+
+Squirm is not stable yet. Feel free to play around with it, but unless you want
+to contribute to its development, you probably shouldn't use it for anything
+sensitive.
+
+It currently provides:
+
+* A basic connection pool
+* A little syntactic sugar around the pg gem
+* Class for accessing stored procedures as if they were Ruby procs
+
+Here's a quick demo of how you might use it:
+
+    -- Your database
+    CREATE TABLE "users" (
+      "name"  VARCHAR(256),
+      "email" VARCHAR(64) NOT NULL UNIQUE
+    );
+
+    CREATE SCHEMA "users";
+
+    CREATE FUNCTION "users"."create"(_email text, _name text) RETURNS integer AS $$
+      DECLARE
+        new_id integer;
+      BEGIN
+        INSERT INTO "users" (email, name) VALUES (_email, _name)
+          RETURNING id INTO new_id;
+        IF FOUND THEN
+          RETURN new_id;
+        END IF;
+      END;
+    $$ LANGUAGE 'plpgsql';
+
+    Squirm.connect dbname: "your_database"
+    create = Squirm::Procedure.new("create", schema: "users")
+    id = create.call(email: "johndoe@example.com", name: "John Doe")
+
+In and of itself, Squirm offers very little, but is meant to be a basic building
+block for other libraries.
+
+One such library is Squirm Model, which is currently under development.
+
+This library will offer an ActiveModel-compatible, ORM-like library that uses
+stored procedures and SQL rather than generating the SQL for you. Stay tuned
+for more details.
+
+## Author
+
+Norman Clarke <nclarke@bvision.com>
+
+## License
+
+Copyright (c) 2011 Norman Clarke and Business Vision S.A.
+
+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/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/clean'
+require 'rake/testtask'
+
+CLEAN.include "pkg", "spec/coverage", "doc", "*.gem"
+
+task default: :test
+
+task :gem do
+  sh "gem build squirm.gemspec"
+end
+
+task :test do
+  Rake::TestTask.new do |t|
+    t.libs << "spec"
+    t.test_files = FileList["spec/*_spec.rb"]
+    t.verbose = false
+  end
+end

data/lib/squirm.rb

@@ -0,0 +1,65 @@
+require "squirm/core"
+require "squirm/pool"
+require "squirm/procedure"
+
+=begin
+Squirm is an experimental anti-ORM for database-loving programmers who want to
+take full advantage of the advanced functionality offered by Postgres. With
+Squirm, you write your entire database layer using the tools of the domain
+experts: SQL and stored procedures. Muahahahahaha!
+
+== Using it
+
+First of all you should know that this is experimental, and in-progress. So you
+might want to exercise lots of caution. Don't build your mission critical app on
+top of Squirm now, or possibly ever.
+
+=== Getting a connection
+
+Squirm comes with a very simple, threadsafe connection pool.
+
+    Squirm.connect dbname: "postgres", pool_size: 5, timeout: 5
+
+=== Performing queries
+
+The `Squirm.use` method will check out a connection and yield it to the block
+you pass. The connection is a vanilla instance of PGConn, so all of Postgres's
+functionality is directly exposed to you without any sugar or intermediaries.
+
+When the block returns, the connection is checked back into the pool.
+
+    # conn is a PGconn instance
+    Squirm.use do |conn|
+      conn.exec "SELECT * FROM users" do |result|
+        puts result.first
+      end
+    end
+
+    # shorthand for above
+    Squirm.exec "SELECT * FROM users" do |result|
+      puts result.first
+    end
+
+`Squirm.use` executes the block inside a new thread, and set the currently
+checked out connection as a thread local variable, so that calls to Squirm.exec
+inside the block will use the same connection. It will wait for the thread to
+return and then return the block's return value.
+
+=== Accessing a stored procedure
+
+Accessing an API you create is simple:
+
+    procedure = Squirm::Procedure.new "create", schema: "users"
+    procedure.call email: "john@example.com", name: "John Doe"
+
+You can also get easy access to the functions that ship with Postgres, if for
+some reason you want to use them:
+
+    proc = Squirm::Procedure.new("date", schema: "pg_catalog", args: "abstime")
+    proc.call("Jan 1, 2011") #=> "2011-01-01"
+
+=end
+module Squirm
+  Rollback, Timeout = 2.times.map { Class.new RuntimeError }
+  extend Core
+end

data/lib/squirm/core.rb

@@ -0,0 +1,86 @@
+require "pg"
+require "thread"
+
+module Squirm
+
+  # The core DSL used by Squirm.
+  module Core
+
+    # Establishes a connection pool.
+    # @param [Hash] options The connection options
+    # @option options [String] :pool Use the given pool rather than Squirm's.
+    # @option options [Fixnum] :timeout The pool timeout.
+    # @option options [Fixnum] :pool_size The pool size.
+    def connect(options = {})
+      return @pool = options[:pool] if options[:pool]
+      options   = options.dup
+      timeout   = options.delete(:timeout) || 5
+      pool_size = options.delete(:pool_size) || 1
+      @pool     = Squirm::Pool.new(timeout)
+      pool_size.times do
+        conn = PGconn.open(options)
+        yield conn if block_given?
+        @pool.checkin conn
+      end
+    end
+
+    # Disconnects all pool connections and sets the pool to nil.
+    def disconnect
+      return unless pool
+      pool.map(&:close)
+      @pool = nil
+    end
+
+    # Executes the query and passes the result to the block you specify.
+    def exec(*args, &block)
+      if current = Thread.current[:squirm_connection]
+        current.exec(*args, &block)
+      else
+        use {|conn| conn.exec(*args, &block)}
+      end
+    end
+
+    # Gets the connection pool.
+    # @return [Squirm::Pool] The connection pool.
+    def pool
+      @pool if defined? @pool
+    end
+
+    # Performs a #use inside a transaction.
+    def transaction
+      use do |connection|
+        connection.transaction do |conn|
+          begin
+            yield conn
+          rescue Rollback
+            return
+          end
+        end
+      end
+    end
+
+    # Rolls back from inside a #transaction block.
+    def rollback
+      raise Rollback
+    end
+
+    # Checks out a connection and uses it for all database access inside the
+    # block.
+    def use
+      conn = @pool.checkout
+      begin
+        Thread.current[:squirm_connection] = conn
+        yield conn
+      ensure
+        Thread.current[:squirm_connection] = nil
+        @pool.checkin conn
+      end
+    end
+
+    # Quotes an SQL identifier.
+    # @return [String] The identifier.
+    def quote_ident(*args)
+      PGconn.quote_ident(*args.map(&:to_s))
+    end
+  end
+end

data/lib/squirm/pool.rb

@@ -0,0 +1,48 @@
+require "forwardable"
+require "monitor"
+require "set"
+
+module Squirm
+
+  # A ridiculously simple object pool.
+  class Pool
+    extend Forwardable
+    include Enumerable
+
+    attr_reader :connections
+    attr_accessor :timeout
+
+    def_delegator :@mutex, :synchronize
+
+    def initialize(timeout=5)
+      @mutex       = Monitor.new
+      @timeout     = timeout
+      @condition   = @mutex.new_cond
+      @queue       = []
+      @connections = Set.new
+    end
+
+    # Synchronizes iterations provided by Enumerable.
+    def each(&block)
+      synchronize { @connections.each(&block) }
+    end
+
+    # Check a connection back in.
+    def checkout
+      synchronize do
+        return @queue.shift unless @queue.empty?
+        @condition.wait(@timeout)
+        @queue.empty? ? raise(Timeout) : next
+      end
+    end
+
+    # Check out a connection.
+    def checkin(conn)
+      synchronize do
+        @connections.add conn
+        @queue.push conn
+        @condition.signal
+      end
+    end
+  end
+end

data/lib/squirm/procedure.rb

@@ -0,0 +1,218 @@
+require "pathname"
+
+module Squirm
+
+  # This class wraps access to a Postgres stored procedure, exposing it to
+  # Ruby as if it were a Ruby Proc.
+  class Procedure
+
+    # The Postgres stored procedure's name.
+    # @return [String]
+    attr :name
+
+    # The schema which holds the stored procedure. Defaults to +public+.
+    # @return [String]
+    attr :schema
+
+    # An instance of {Arguments} encapsulating information about the
+    # arguments needed to invoke the procedure.
+    # @return [Squirm::Procedure::Arguments]
+    attr :arguments
+
+    # The procedure's Postgres return type
+    # @return [String]
+    attr :return_type
+
+    # The SQL query used to invoke the stored procedure.
+    # @return [String]
+    attr :query
+
+    # Raised when an overloaded stored procedure is specified, but no argument
+    # list is given.
+    #
+    # To avoid this error when using overloaded procedures, initialize the
+    # {Squirm::Procedure} with the `:args` option.
+    class TooManyChoices < RuntimeError
+    end
+
+    # Raised when the stored procedure can not be found.
+    class NotFound < RuntimeError
+    end
+
+    # The SQL query used to load meta info about the procedure.
+    INFO_SQL = Pathname(__FILE__).dirname.join("procedure.sql").read
+
+    # Creates a new stored procedure.
+    def initialize(name, options = {})
+      @name      = name
+      @schema    = options[:schema] || 'public'
+      @arguments = Arguments.new(options[:args]) if options[:args]
+    end
+
+    # Loads meta info about the stored procedure.
+    #
+    # This action is not performed in the constructor to allow instances to
+    # be created before a database connection has been established.
+    #
+    # @return [Squirm::Procedure] The instance
+    def load
+      query = (arguments or self).info_sql
+      Squirm.exec(query, [name, schema]) do |result|
+        validate result
+        set_values_from result
+      end
+      self
+    end
+
+    # The SQL query used to get meta information about the procedure.
+    # @see INFO_SQL
+    # @return [String]
+    def info_sql
+      INFO_SQL
+    end
+
+    # Invokes the procedure.
+    def call(*args, &block)
+      Squirm.exec query, arguments.format(*args) do |result|
+        if block_given?
+          yield result
+        elsif return_type =~ /\ASETOF/
+          result.to_a
+        else
+          result.getvalue(0,0)
+        end
+      end
+    end
+
+    alias [] call
+
+    # Checks the number of values returned when looking up meta info about
+    # the procedure.
+    # @see #load
+    # @see #info_sql
+    def validate(result)
+      if result.ntuples == 0
+        raise NotFound
+      elsif result.ntuples > 1
+        raise TooManyChoices
+      end
+    end
+    private :validate
+
+    # Processes the meta info query_result, setting variables needed by the
+    # instance.
+    def set_values_from(result)
+      @arguments   = Arguments.new(result[0]['arguments'])
+      @return_type = result[0]['return_type']
+      @query       = "SELECT * FROM %s.%s(%s)" % [
+        quoted_schema,
+        quoted_name,
+        @arguments.to_params
+      ]
+    end
+    private :set_values_from
+
+    # The quoted procedure name.
+    # @return [String]
+    def quoted_name
+      Squirm.quote_ident name
+    end
+
+    # The quoted schema name.
+    # @return [String]
+    def quoted_schema
+      Squirm.quote_ident schema
+    end
+
+    # A collection of argument definitions for a stored procedure. This class
+    # delegates both to an internal hash and to its keys, so it has mixed
+    # Array/Hash-like behavior. This allows you to access arguments by offset
+    # or name.
+    #
+    # This may seem like an odd mix of behaviors but is intended to
+    # idiomatically translate Postgres's support for both named and unnamed
+    # stored procedure arguments.
+    class Arguments
+      attr :hash, :string
+
+      extend Forwardable
+      include Enumerable
+
+      def_delegator :hash, :keys
+      def_delegator :keys, :each
+
+      alias to_s string
+
+      # Gets an instance of Arguments from a string.
+      #
+      # This string can come from a lookup in the pg_proc catalog, or in the
+      # case of overloaded functions, will be specified explicitly by the
+      # programmer.
+      def initialize(string)
+        @string = string
+        @hash   = self.class.hashify(string)
+      end
+
+      # Formats arguments used to call the stored procedure.
+      #
+      # When given a anything other than a hash, the arguments are returned
+      # without modification.
+      #
+      # When given a hash, the return value is an array or arguments in the
+      # order needed when calling the procedure. Missing values are replaced by
+      # nil.
+      #
+      # @example
+      #   # Assume a stored procedure with a definition like the following:
+      #   # print_greeting(greeting text, greeter text, language text)
+      #   arguments.format(greeter: "John", greeting: "hello") #=> ["hello", "John", nil]
+      # @return Array
+      def format(*args)
+        args.first.kind_of?(Hash) ? map {|name| args[0][name]} : args
+      end
+
+      # Gets an argument's Postgres type by index or offset.
+      # @overload [](offset)
+      #   @param [Fixnum] offset The argument's offset
+      # @overload [](key)
+      #   @param [String] key The argument's name
+      # @example
+      #   arguments[0]            #=> "text"
+      #   arguments["created_at"] #=> "timestamp with time zone"
+      def [](key)
+        (key.kind_of?(Fixnum) ? keys : hash)[key]
+      end
+
+      # Gets Postgres-formatted params for use in calling the procedure.
+      # @example
+      #   arguments.to_params #=> "$1::text, $2::integer, $3::text"
+      # @return String
+      def to_params
+        @params ||= each_with_index.map do |key, index|
+          "$%s::%s" % [index.next, hash[key]]
+        end.join(", ")
+      end
+
+      # Gets an SQL query used to look up meta information about a stored
+      # procedure with a matching argument signature.
+      def info_sql
+        "#{INFO_SQL} AND pg_catalog.pg_get_function_arguments(p.oid) = '#{to_s}'"
+      end
+
+      # Converts an argument string to a hash whose keys are argument names
+      # and whose values are argument types.
+      def self.hashify(string)
+        hash = {}
+        string.split(",").map do |arg|
+          arg, type = arg.strip.split(/\s+/, 2)
+          type ||= arg
+          arg   = arg.gsub(/\s+/, '_').gsub(/\A_/, '')
+          count = hash.keys.count {|elem| elem =~ /#{arg}[\d]?/}
+          key = count == 0 ? arg : arg + count.next.to_s
+          hash[key.to_sym] = type
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/squirm/procedure.sql

@@ -0,0 +1,15 @@
+SELECT p.proname AS "name",
+  pg_catalog.pg_get_function_result(p.oid) AS "return_type",
+  pg_catalog.pg_get_function_arguments(p.oid) AS "arguments",
+  p.proargtypes AS "argtypes",
+  CASE
+    WHEN p.proisagg THEN 'agg'
+    WHEN p.proiswindow THEN 'window'
+    WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN 'trigger'
+    ELSE 'normal'
+  END AS "procedure_type"
+FROM pg_catalog.pg_proc p
+LEFT JOIN pg_catalog.pg_namespace n
+  ON n.oid = p.pronamespace
+WHERE p.proname = $1::text
+  AND n.nspname = $2::text

data/lib/squirm/version.rb

@@ -0,0 +1,3 @@
+module Squirm
+  VERSION = "0.0.2"
+end

data/spec/core_spec.rb

@@ -0,0 +1,98 @@
+require_relative "helper"
+require "ostruct"
+
+describe Squirm do
+
+  before { Squirm.disconnect }
+  after  { Squirm.disconnect }
+
+  it "should quote identifiers" do
+    assert_equal '"table"', Squirm.quote_ident("table")
+  end
+
+  describe "#connect" do
+    it "should use a pool if given" do
+      pool = OpenStruct.new
+      Squirm.connect pool: pool
+      assert_equal pool, Squirm.pool
+    end
+
+    it "should establish a connection pool" do
+      Squirm.connect $squirm_test_connection
+      assert !Squirm.pool.connections.empty?
+    end
+
+    it "should establish :pool_size connections" do
+      Squirm.connect $squirm_test_connection.merge pool_size: 2
+      assert_equal 2, Squirm.pool.connections.count
+    end
+
+    it "should set :timeout to the pool's timeout" do
+      Squirm.connect $squirm_test_connection.merge timeout: 9999
+      assert_equal 9999, Squirm.pool.timeout
+    end
+  end
+
+  describe "#disconnect" do
+    it "should close all connections" do
+      mock = MiniTest::Mock.new
+      mock.expect :close, nil
+      Squirm.instance_variable_set :@pool, [mock]
+      Squirm.disconnect
+      mock.verify
+    end
+  end
+
+  describe "#use" do
+    it "should set a connection as a Thread local var only during yield" do
+      connection = OpenStruct.new
+      Squirm.instance_variable_set :@pool, Squirm::Pool.new
+      Squirm.pool.checkin connection
+      Squirm.use do |conn|
+        assert_equal conn, Thread.current[:squirm_connection]
+      end
+      assert_nil Thread.current[:squirm_connection]
+    end
+  end
+
+  describe "#exec" do
+    it "should execute a query" do
+      Squirm.connect $squirm_test_connection
+      Squirm.exec "SELECT 'world' as hello" do |result|
+        assert_equal "world", result.getvalue(0,0)
+      end
+    end
+
+    it "should use the thread local connection if set" do
+      mock = MiniTest::Mock.new
+      mock.expect(:exec, true, [String])
+      begin
+        Thread.current[:squirm_connection] = mock
+        Squirm.exec "SELECT * FROM table"
+        mock.verify
+      ensure
+        Thread.current[:squirm_connection] = nil
+      end
+    end
+  end
+
+  describe "#transaction" do
+    it "should set the connection to a transaction state" do
+      Squirm.connect $squirm_test_connection
+      Squirm.transaction do |conn|
+        assert_equal PGconn::PQTRANS_INTRANS, conn.transaction_status
+      end
+    end
+  end
+
+  describe "#rollback" do
+    it "should exit the block" do
+      Squirm.connect $squirm_test_connection
+      Squirm.transaction do |conn|
+        Squirm.rollback
+        assert false, "rollback should have exited the block"
+      end
+    end
+  end
+
+end

data/spec/helper.rb

@@ -0,0 +1,19 @@
+if ENV["COVERAGE"]
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "rubygems"
+gem "minitest"
+require "minitest/spec"
+require 'minitest/autorun'
+require 'pg'
+
+$VERBOSE = true
+
+require "squirm"
+
+$squirm_test_connection = {dbname: "squirm_test"}

data/spec/pool_spec.rb

@@ -0,0 +1,34 @@
+require_relative "helper"
+
+describe Squirm::Pool do
+  describe "#checkout" do
+    it "should wait until timeout if all connections busy" do
+      assert try_checkout(0.05, 0.02)
+    end
+
+    it "should raise error if pool checkout times out" do
+      assert_raises Squirm::Timeout do
+        try_checkout(0.02, 0.05)
+      end
+    end
+
+    private
+
+    def try_checkout(timeout, sleep_time)
+      pool = Squirm::Pool.new(timeout)
+      pool.checkin Object.new
+      t1 = Thread.new do
+        conn = pool.checkout
+        sleep(sleep_time)
+        pool.checkin conn
+      end
+      t2 = Thread.new {
+        sleep(0.01)
+        pool.checkout
+      }
+      [t1, t2].map(&:value)
+      true
+    end
+  end
+end
+

data/spec/procedure_spec.rb

@@ -0,0 +1,137 @@
+require_relative "helper"
+
+describe Squirm::Procedure::Arguments do
+
+  it "should have a count" do
+    args = Squirm::Procedure::Arguments.new("text, text")
+    assert_equal 2, args.count
+  end
+
+  it "should number duplicate names" do
+    args = Squirm::Procedure::Arguments.new("text, text, text")
+    assert_equal :text, args[0]
+    assert_equal :text2, args[1]
+    assert_equal :text3, args[2]
+  end
+
+  it "should detect named args" do
+    args = Squirm::Procedure::Arguments.new("hello text, world text")
+    assert_equal :hello, args[0]
+    assert_equal :world, args[1]
+  end
+
+  it "should remove leading underscores from arg names" do
+    args = Squirm::Procedure::Arguments.new("_hello text, _world text")
+    assert_equal :hello, args[0]
+    assert_equal :world, args[1]
+  end
+
+  describe "#to_params" do
+    it "should give a list of numeric params" do
+      args = Squirm::Procedure::Arguments.new("text, text")
+      assert_equal "$1::text, $2::text", args.to_params
+    end
+  end
+
+  # describe "#format" do
+  #   it "should return an array of args in the proper order" do
+  #     args = Squirm::Procedure::Arguments.new("hello text, world text")
+  #   end
+  # end
+
+end
+
+describe Squirm::Procedure do
+
+  before { Squirm.disconnect }
+  after  { Squirm.disconnect }
+
+  it "should have an info SQL statement" do
+    assert_match(/SELECT/, Squirm::Procedure.new("foo").info_sql)
+  end
+
+  describe "#initialize" do
+    it "should set a default schema if none is given" do
+      procedure = Squirm::Procedure.new("foo")
+      assert_equal 'public', procedure.schema
+      assert_equal "foo", procedure.name
+    end
+
+    it "should set arguments if given" do
+      procedure = Squirm::Procedure.new("foo", :args => "bar text")
+      assert_equal 1, procedure.arguments.count
+    end
+  end
+
+  describe "#load" do
+
+    before { Squirm.connect $squirm_test_connection }
+
+    it "should set the procedure's arguments" do
+      Squirm.connect $squirm_test_connection
+      proc = Squirm::Procedure.new("regexp_matches", :args => "text, text",
+                                    :schema => "pg_catalog").load
+      assert_equal [:text, :text2], proc.arguments.to_a
+    end
+
+    it "should raise an exception if no function is found" do
+      begin
+        Squirm::Procedure.new("xxxxxx").load
+        assert false, "should have raised error"
+      rescue Squirm::Procedure::NotFound
+        assert true
+      end
+    end
+
+    it "should raise an exception if overloaded functions are loaded with no args" do
+      begin
+        Squirm::Procedure.new("date", :schema => "pg_catalog").load
+        assert false, "should have raised error"
+      rescue Squirm::Procedure::TooManyChoices
+        assert true
+      end
+    end
+
+    it "should load an overloaded functions if instance was initialized with :args" do
+      assert Squirm::Procedure.new("date", :args => "abstime", :schema => "pg_catalog").load
+    end
+
+  end
+
+  describe "#call" do
+
+    before {Squirm.connect $squirm_test_connection}
+
+    it "should yield the result to a block if given" do
+      proc = Squirm::Procedure.new("date", :args => "abstime", :schema => "pg_catalog").load
+      proc.call("Jan 1, 2011") do |result|
+        assert_instance_of PGresult, result
+      end
+    end
+
+    it "should return the value of a single-row result" do
+      proc = Squirm::Procedure.new("date", :args => "abstime", :schema => "pg_catalog").load
+      assert_equal "2011-01-01", proc.call("Jan 1, 2011")
+    end
+
+    it "should return the an array of hashes for set results" do
+      Squirm.transaction do |conn|
+        conn.exec(<<-SQL)
+          CREATE TABLE temp_table (name varchar);
+          INSERT INTO temp_table VALUES ('joe');
+          INSERT INTO temp_table VALUES ('bob');
+          CREATE FUNCTION temp_func() RETURNS SETOF temp_table AS $$
+            BEGIN
+              RETURN QUERY SELECT * FROM temp_table;
+            END;
+          $$ LANGUAGE 'plpgsql';
+        SQL
+        proc = Squirm::Procedure.new("temp_func").load
+        result = proc.call
+        assert_instance_of Array, result
+        assert_instance_of Hash, result[0]
+        Squirm.rollback
+      end
+    end
+  end
+end

data/squirm.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path("../lib/squirm/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = "squirm"
+  s.version       = Squirm::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Norman Clarke"]
+  s.email         = ["norman@njclarke.com"]
+  s.homepage      = "http://github.com/norman/squirm"
+  s.summary       = %q{"An anti-ORM for database-loving programmers"}
+  s.description   = %q{"Squirm is an anti-ORM for database-loving programmers"}
+  s.bindir        = "bin"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 1.9"
+
+  s.add_development_dependency "minitest", ">= 2.6"
+  s.add_runtime_dependency "pg", ">= 0.11.0"
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: squirm
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Norman Clarke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70156030613100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70156030613100
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &70156030612340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70156030612340
+description: ! '"Squirm is an anti-ORM for database-loving programmers"'
+email:
+- norman@njclarke.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/squirm.rb
+- lib/squirm/core.rb
+- lib/squirm/pool.rb
+- lib/squirm/procedure.rb
+- lib/squirm/procedure.sql
+- lib/squirm/version.rb
+- spec/core_spec.rb
+- spec/helper.rb
+- spec/pool_spec.rb
+- spec/procedure_spec.rb
+- squirm.gemspec
+homepage: http://github.com/norman/squirm
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: ! '"An anti-ORM for database-loving programmers"'
+test_files:
+- spec/core_spec.rb
+- spec/helper.rb
+- spec/pool_spec.rb
+- spec/procedure_spec.rb