mao 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3443824eba06c5970342e7f90928802108bb74d
-  data.tar.gz: 6a71a88dfcd6e0c3b9d71dede343620a3375409a
+  metadata.gz: 77c4066b8df0f753d381b77e61e32efefb480d9a
+  data.tar.gz: 6dc61214eb92e8d9e8778019ae2288cbd4d40e87
 SHA512:
-  metadata.gz: 1398f0c822dd799832797155f2ef89968af1b626dee60968b74475c0a64db55d471cb3a762a3543b0215b8ca8b0f0c3da1045388fefa10fa61dde96659bfaa28
-  data.tar.gz: fbe93c212204fa098813b6b5198e386a257fb2c35b4e6b278eca1cbb8d81d9830f8bea73f552bb213036b460ece5372655d618ae8d9788f02579ac745130f743
+  metadata.gz: 3bd7e041fcd8ae0a095397dc7f03e7ca720d64f28ab3a89817d73167206a62c9f2f34330c540be6440fc8276dac1973efc4a53551ae064867acee4c4ca91bf35
+  data.tar.gz: 59551232080705659ab3aec1859e3936ef9437984c7032aa20b40a6eb75a49ed281458542e938a62cc80a7dabe95d49d93940a2481bc7e01590eb7b975e477d3

data/.gitignore

@@ -16,3 +16,5 @@ test/tmp
 test/version_tmp
 tmp
 .rvmrc
+vendor
+*.swp

data/README.md

@@ -1,4 +1,4 @@
-# Mao [![Build Status](https://secure.travis-ci.org/unnali/mao.png)](http://travis-ci.org/unnali/mao) [![Dependency Status](https://gemnasium.com/unnali/mao.png)](https://gemnasium.com/unnali/mao)
+# Mao [![Build Status](https://secure.travis-ci.org/kivikakk/mao.png)](http://travis-ci.org/kivikakk/mao) [![Dependency Status](https://gemnasium.com/kivikakk/mao.png)](https://gemnasium.com/kivikakk/mao)
 
 **Mao Ain't an ORM.**
 

data/lib/mao/version.rb

@@ -1,7 +1,7 @@
 module Mao
   # The version of the last release of Mao made.  Increment when releasing a
   # new gem.
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end
 
 # vim: set sw=2 cc=80 et:

data/mao.gemspec

@@ -5,11 +5,11 @@ Gem::Specification.new do |gem|
   gem.email         = ["allen.timothy.email@gmail.com", "rubygems@kivikakk.ee"]
   gem.description   = %q{Mao Ain't an ORM}
   gem.summary       = %q{A database access layer.  Currently supports PG.}
-  gem.homepage      = "https://github.com/unnali/mao" # TBD
+  gem.homepage      = "https://github.com/kivikakk/mao"
 
-  gem.add_dependency('pg', '~> 0.14.0')
+  gem.add_dependency('pg', '~> 0.18.4')
   gem.add_development_dependency('rake')
-  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('rspec', '~> 3.0')
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/filter_spec.rb

@@ -8,120 +8,120 @@ describe Mao::Filter do
 
   describe ".finalize_or_literal" do
     context "with Mao::Filter" do
-      before { col_x.should_receive(:finalize).
+      before { expect(col_x).to receive(:finalize).
                    with(no_args).and_return("blah") }
-      it { Mao::Filter.finalize_or_literal(col_x).should eq "blah" }
+      it { expect(Mao::Filter.finalize_or_literal(col_x)).to eq "blah" }
     end
 
     context "with non-Mao::Filter" do
-      before { Mao.should_receive(:escape_literal).
+      before { expect(Mao).to receive(:escape_literal).
                    with(42).and_return("ha") }
-      it { Mao::Filter.finalize_or_literal(42).should eq "ha" }
+      it { expect(Mao::Filter.finalize_or_literal(42)).to eq "ha" }
     end
   end
 
   describe ".sql" do
     context "Arrays" do
       let(:klass) { double("klass") }
-      before { Mao::Filter.should_receive(:const_get).
+      before { expect(Mao::Filter).to receive(:const_get).
                  with(:Hullo).and_return(klass) }
-      before { klass.should_receive(:sql).with(:mao).and_return :dengxiaoping }
-      it { Mao::Filter.sql([:Hullo, :mao]).should eq :dengxiaoping }
+      before { expect(klass).to receive(:sql).with(:mao).and_return :dengxiaoping }
+      it { expect(Mao::Filter.sql([:Hullo, :mao])).to eq :dengxiaoping }
     end
 
     context "Strings" do
-      it { Mao::Filter.sql("BATTLE ROYALE").should eq "BATTLE ROYALE" }
+      it { expect(Mao::Filter.sql("BATTLE ROYALE")).to eq "BATTLE ROYALE" }
     end
   end
 
   describe "#and" do
     subject { col_x.and(col_y) }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "AND" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "AND" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#or" do
     subject { col_x.or(col_y) }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "OR" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "OR" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#==" do
     subject { col_x == col_y }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "=" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "=" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#!=" do
     subject { col_x != col_y }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "<>" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "<>" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#>" do
     subject { col_x > col_y }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq ">" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq ">" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#>=" do
     subject { col_x >= col_y }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq ">=" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq ">=" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#<" do
     subject { col_x < col_y }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "<" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "<" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#<=" do
     subject { col_x <= col_y }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "<=" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be col_y }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "<=" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be col_y }
   end
 
   describe "#null?" do
     subject { col_x.null? }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "IS" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should be_nil }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "IS" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to be_nil }
   end
 
   describe "#in" do
     subject { col_x.in([1, 2, 3]) }
 
-    it { should be_an_instance_of Mao::Filter::Binary }
-    it { subject.options[:op].should eq "IN" }
-    it { subject.options[:lhs].should be col_x }
-    it { subject.options[:rhs].should eq [1, 2, 3] }
+    it { is_expected.to be_an_instance_of Mao::Filter::Binary }
+    it { expect(subject.options[:op]).to eq "IN" }
+    it { expect(subject.options[:lhs]).to be col_x }
+    it { expect(subject.options[:rhs]).to eq [1, 2, 3] }
   end
 end
 
@@ -130,14 +130,22 @@ describe Mao::Filter::Column do
 
   context "without table" do
     subject { Mao::Filter::Column.new(:name => :Margorth) }
-    its(:finalize) { should eq [:Column, :Margorth] }
-    it { Mao::Filter.sql(subject.finalize).should eq '"Margorth"' }
+
+    describe '#finalize' do
+      subject { super().finalize }
+      it { is_expected.to eq [:Column, :Margorth] }
+    end
+    it { expect(Mao::Filter.sql(subject.finalize)).to eq '"Margorth"' }
   end
 
   context "with table" do
     subject { Mao::Filter::Column.new(:table => :Lol, :name => :Margorth) }
-    its(:finalize) { should eq [:Column, :Lol, :Margorth] }
-    it { Mao::Filter.sql(subject.finalize).should eq '"Lol"."Margorth"' }
+
+    describe '#finalize' do
+      subject { super().finalize }
+      it { is_expected.to eq [:Column, :Lol, :Margorth] }
+    end
+    it { expect(Mao::Filter.sql(subject.finalize)).to eq '"Lol"."Margorth"' }
   end
 end
 
@@ -145,8 +153,11 @@ describe Mao::Filter::Binary do
   before { prepare_spec }
   subject { Mao::Filter::Binary.new(:lhs => 42, :op => '=', :rhs => 42) }
 
-  its(:finalize) { should eq [:Binary, '=', "42", "42"] }
-  it { Mao::Filter.sql(subject.finalize).should eq "(42 = 42)" }
+  describe '#finalize' do
+    subject { super().finalize }
+    it { is_expected.to eq [:Binary, '=', "42", "42"] }
+  end
+  it { expect(Mao::Filter.sql(subject.finalize)).to eq "(42 = 42)" }
 end
 
 describe Mao::Filter::Table do
@@ -154,14 +165,14 @@ describe Mao::Filter::Table do
 
   context "non-explicit" do
     let(:some) { Mao::Filter::Table.new(Mao.query(:some), false) }
-    it { some.value.should be_an_instance_of Mao::Filter::Column }
-    it { some.value.finalize.should eq [:Column, :value] }
+    it { expect(some.value).to be_an_instance_of Mao::Filter::Column }
+    it { expect(some.value.finalize).to eq [:Column, :value] }
   end
 
   context "explicit" do
     let(:some) { Mao::Filter::Table.new(Mao.query(:some), true) }
-    it { some.value.should be_an_instance_of Mao::Filter::Column }
-    it { some.value.finalize.should eq [:Column, :some, :value] }
+    it { expect(some.value).to be_an_instance_of Mao::Filter::Column }
+    it { expect(some.value.finalize).to eq [:Column, :some, :value] }
   end
 
   context "non-extant" do

data/spec/mao_spec.rb

@@ -7,117 +7,117 @@ describe Mao do
   describe ".connect!" do
     let(:options) { double("options") }
     let(:conn) { double("conn") }
-    before { PG.should_receive(:connect).with(options).and_return(conn) }
-    before { conn.should_receive(:internal_encoding=).with(Encoding::UTF_8) }
+    before { expect(PG).to receive(:connect).with(options).and_return(conn) }
+    before { expect(conn).to receive(:internal_encoding=).with(Encoding::UTF_8) }
     before { Mao.disconnect! rescue false }
     it { Mao.connect!(options) }
     after { Mao.instance_variable_set("@conn", nil) }
   end
 
   describe ".disconnect!" do
-    before { PG::Connection.any_instance.should_receive(:close) }
+    before { expect_any_instance_of(PG::Connection).to receive(:close) }
     it { Mao.disconnect! }
   end
 
   describe ".sql" do
-    before { PG::Connection.any_instance.should_receive(:exec).
+    before { expect_any_instance_of(PG::Connection).to receive(:exec).
                  with(:x).and_return(:y) }
-    it { Mao.sql(:x).should eq :y }
+    it { expect(Mao.sql(:x)).to eq :y }
   end
 
   describe ".quote_ident" do
     context "pass-thru" do
-      before { PG::Connection.any_instance.should_receive(:quote_ident).
+      before { expect_any_instance_of(PG::Connection).to receive(:quote_ident).
                    with("table").and_return(%q{"table"}) }
-      it { Mao.quote_ident("table").should eq %q{"table"} }
+      it { expect(Mao.quote_ident("table")).to eq %q{"table"} }
     end
 
     context "Symbols" do
-      before { PG::Connection.any_instance.should_receive(:quote_ident).
+      before { expect_any_instance_of(PG::Connection).to receive(:quote_ident).
                    with("table").and_return(%q{"table"}) }
-      it { Mao.quote_ident(:table).should eq %q{"table"} }
+      it { expect(Mao.quote_ident(:table)).to eq %q{"table"} }
     end
   end
 
   describe ".escape_literal" do
     describe "verify pass-thru String" do
-      before { PG::Connection.any_instance.should_receive(:escape_literal).
+      before { expect_any_instance_of(PG::Connection).to receive(:escape_literal).
                    with("table").and_return(%q{'table'}) }
-      it { Mao.escape_literal("table").should eq %q{'table'} }
+      it { expect(Mao.escape_literal("table")).to eq %q{'table'} }
     end
 
     describe "verify not pass-thru others" do
-      before { PG::Connection.any_instance.
-                   should_not_receive(:escape_literal) }
-      it { Mao.escape_literal(nil).should eq "null" }
+      before { expect_any_instance_of(PG::Connection).
+                   not_to receive(:escape_literal) }
+      it { expect(Mao.escape_literal(nil)).to eq "null" }
     end
 
     describe "verify escape_literal-less PG::Connection" do
-      before { PG::Connection.any_instance.should_receive(:respond_to?).
+      before { expect_any_instance_of(PG::Connection).to receive(:respond_to?).
                    with(:escape_literal).and_return(false) }
-      before { PG::Connection.any_instance.should_receive(:escape_string).
+      before { expect_any_instance_of(PG::Connection).to receive(:escape_string).
                    with("xyz'hah").and_return("xyz''hah") }
-      it { Mao.escape_literal("xyz'hah").should eq %q{'xyz''hah'} }
+      it { expect(Mao.escape_literal("xyz'hah")).to eq %q{'xyz''hah'} }
     end
 
     describe "actual values" do
-      it { Mao.escape_literal("table").should eq %q{'table'} }
-      it { Mao.escape_literal(42).should eq %q{42} }
-      it { Mao.escape_literal(true).should eq %q{true} }
-      it { Mao.escape_literal(false).should eq %q{false} }
-      it { Mao.escape_literal(nil).should eq %q{null} }
-      it { Mao.escape_literal([]).should eq %q{(null)} }
-      it { Mao.escape_literal([1]).should eq %q{(1)} }
-      it { Mao.escape_literal([1, "xzy"]).should eq %q{(1, 'xzy')} }
-      it { Mao.escape_literal(Mao::Query.raw("\n\"'%")).should eq "\n\"'%" }
+      it { expect(Mao.escape_literal("table")).to eq %q{'table'} }
+      it { expect(Mao.escape_literal(42)).to eq %q{42} }
+      it { expect(Mao.escape_literal(true)).to eq %q{true} }
+      it { expect(Mao.escape_literal(false)).to eq %q{false} }
+      it { expect(Mao.escape_literal(nil)).to eq %q{null} }
+      it { expect(Mao.escape_literal([])).to eq %q{(null)} }
+      it { expect(Mao.escape_literal([1])).to eq %q{(1)} }
+      it { expect(Mao.escape_literal([1, "xzy"])).to eq %q{(1, 'xzy')} }
+      it { expect(Mao.escape_literal(Mao::Query.raw("\n\"'%"))).to eq "\n\"'%" }
 
       # Times are escaped to UTC always.
-      it { Mao.escape_literal(Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600)).
-               should eq %q{'2012-11-10 19:45:00.000000'} }
-      it { Mao.escape_literal(Time.new(2012, 11, 10, 19, 45, 0, 0)).
-               should eq %q{'2012-11-10 19:45:00.000000'} }
-      it { Mao.escape_literal(Time.new(2012, 11, 10, 19, 45, 0.1, 0)).
-               should eq %q{'2012-11-10 19:45:00.100000'} }
+      it { expect(Mao.escape_literal(Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600))).
+               to eq %q{'2012-11-10 19:45:00.000000'} }
+      it { expect(Mao.escape_literal(Time.new(2012, 11, 10, 19, 45, 0, 0))).
+               to eq %q{'2012-11-10 19:45:00.000000'} }
+      it { expect(Mao.escape_literal(Time.new(2012, 11, 10, 19, 45, 0.1, 0))).
+               to eq %q{'2012-11-10 19:45:00.100000'} }
     end
   end
 
   describe ".query" do
     subject { Mao.query(:empty) }
-    it { should be_an_instance_of Mao::Query }
-    it { should be_frozen }
+    it { is_expected.to be_an_instance_of Mao::Query }
+    it { is_expected.to be_frozen }
   end
 
   describe ".transaction" do
     context "empty" do
-      before { PG::Connection.any_instance.should_receive(:exec).
+      before { expect_any_instance_of(PG::Connection).to receive(:exec).
                    with("BEGIN") }
-      before { PG::Connection.any_instance.should_receive(:exec).
+      before { expect_any_instance_of(PG::Connection).to receive(:exec).
                    with("COMMIT") }
       it { Mao.transaction {} }
     end
 
     context "success" do
-      before { Mao.should_receive(:sql).with("BEGIN") }
-      before { Mao.should_receive(:sql).with(:some_sql).and_return :ok }
-      before { Mao.should_receive(:sql).with("COMMIT") }
-      it { Mao.transaction { Mao.sql(:some_sql) }.
-               should eq :ok }
+      before { expect(Mao).to receive(:sql).with("BEGIN") }
+      before { expect(Mao).to receive(:sql).with(:some_sql).and_return :ok }
+      before { expect(Mao).to receive(:sql).with("COMMIT") }
+      it { expect(Mao.transaction { Mao.sql(:some_sql) }).
+               to eq :ok }
     end
 
     context "failure" do
-      before { Mao.should_receive(:sql).with("BEGIN") }
-      before { Mao.should_receive(:sql).with(:some_sql).
+      before { expect(Mao).to receive(:sql).with("BEGIN") }
+      before { expect(Mao).to receive(:sql).with(:some_sql).
                    and_raise(Exception.new) }
-      before { Mao.should_receive(:sql).with("ROLLBACK") }
+      before { expect(Mao).to receive(:sql).with("ROLLBACK") }
       it { expect { Mao.transaction { Mao.sql(:some_sql) }
-                  }.to raise_exception }
+                  }.to raise_exception Exception}
     end
 
     context "rollback" do
-      before { Mao.should_receive(:sql).with("BEGIN") }
-      before { Mao.should_receive(:sql).with(:some_sql).
+      before { expect(Mao).to receive(:sql).with("BEGIN") }
+      before { expect(Mao).to receive(:sql).with(:some_sql).
                    and_raise(Mao::Rollback) }
-      before { Mao.should_receive(:sql).with("ROLLBACK") }
+      before { expect(Mao).to receive(:sql).with("ROLLBACK") }
       it { expect { Mao.transaction { Mao.sql(:some_sql) }
                   }.to_not raise_exception }
     end
@@ -125,102 +125,102 @@ describe Mao do
     context "nested transactions" do
       # Currently not supported: the inner transactions don't add transactions
       # at all.
-      before { Mao.should_receive(:sql).with("BEGIN").once }
-      before { Mao.should_receive(:sql).with("ROLLBACK").once }
+      before { expect(Mao).to receive(:sql).with("BEGIN").once }
+      before { expect(Mao).to receive(:sql).with("ROLLBACK").once }
 
       it do
-        Mao.transaction { Mao.transaction { raise Mao::Rollback } }.
-            should be_false
+        expect(Mao.transaction { Mao.transaction { raise Mao::Rollback } }).
+            to be_falsey
       end
     end
   end
 
   describe ".normalize_result" do
-    before { Mao.should_receive(:convert_type).
+    before { expect(Mao).to receive(:convert_type).
                  with("y", "zzz").and_return("q") }
-    it { Mao.normalize_result({"x" => "y"}, {:x => "zzz"}).
-             should eq({:x => "q"}) }
+    it { expect(Mao.normalize_result({"x" => "y"}, {:x => "zzz"})).
+             to eq({:x => "q"}) }
   end
 
   describe ".normalize_join_result" do
     let(:from) { double("from") }
     let(:to) { double("to") }
 
-    before { from.should_receive(:table).and_return(:from) }
-    before { from.should_receive(:col_types).and_return({:a => "integer"}) }
-    before { to.should_receive(:table).and_return(:to) }
-    before { to.should_receive(:col_types).
+    before { expect(from).to receive(:table).and_return(:from) }
+    before { expect(from).to receive(:col_types).and_return({:a => "integer"}) }
+    before { expect(to).to receive(:table).and_return(:to) }
+    before { expect(to).to receive(:col_types).
                  and_return({:b => "character varying"}) }
 
-    it { Mao.normalize_join_result(
-             {"c1" => "1", "c2" => "2"}, from, to).
-             should eq({:from => {:a => 1},
+    it { expect(Mao.normalize_join_result(
+             {"c1" => "1", "c2" => "2"}, from, to)).
+             to eq({:from => {:a => 1},
                         :to => {:b => "2"}}) }
 
-    it { Mao.normalize_join_result(
-             {"c1" => "1"}, from, to).
-             should eq({:from => {:a => 1}}) }
+    it { expect(Mao.normalize_join_result(
+             {"c1" => "1"}, from, to)).
+             to eq({:from => {:a => 1}}) }
   end
 
   describe ".convert_type" do
     context "integers" do
-      it { Mao.convert_type(nil, "integer").should be_nil }
-      it { Mao.convert_type("42", "integer").should eq 42 }
-      it { Mao.convert_type("42", "smallint").should eq 42 }
-      it { Mao.convert_type("42", "bigint").should eq 42 }
-      it { Mao.convert_type("42", "serial").should eq 42 }
-      it { Mao.convert_type("42", "bigserial").should eq 42 }
+      it { expect(Mao.convert_type(nil, "integer")).to be_nil }
+      it { expect(Mao.convert_type("42", "integer")).to eq 42 }
+      it { expect(Mao.convert_type("42", "smallint")).to eq 42 }
+      it { expect(Mao.convert_type("42", "bigint")).to eq 42 }
+      it { expect(Mao.convert_type("42", "serial")).to eq 42 }
+      it { expect(Mao.convert_type("42", "bigserial")).to eq 42 }
     end
 
     context "character" do
-      it { Mao.convert_type(nil, "character varying").should be_nil }
-      it { Mao.convert_type("blah", "character varying").
-               should eq "blah" }
-      it { Mao.convert_type("blah", "character varying").encoding.
-               should be Encoding::UTF_8 }
+      it { expect(Mao.convert_type(nil, "character varying")).to be_nil }
+      it { expect(Mao.convert_type("blah", "character varying")).
+               to eq "blah" }
+      it { expect(Mao.convert_type("blah", "character varying").encoding).
+               to be Encoding::UTF_8 }
 
-      it { Mao.convert_type(nil, "character varying(200)").should be_nil }
-      it { Mao.convert_type("blah", "character varying(200)").
-               should eq "blah" }
-      it { Mao.convert_type("blah", "character varying(200)").encoding.
-               should be Encoding::UTF_8 }
+      it { expect(Mao.convert_type(nil, "character varying(200)")).to be_nil }
+      it { expect(Mao.convert_type("blah", "character varying(200)")).
+               to eq "blah" }
+      it { expect(Mao.convert_type("blah", "character varying(200)").encoding).
+               to be Encoding::UTF_8 }
 
-      it { Mao.convert_type(nil, "text").should be_nil }
-      it { Mao.convert_type("blah", "text").
-               should eq "blah" }
-      it { Mao.convert_type("blah", "text").encoding.
-               should be Encoding::UTF_8 }
+      it { expect(Mao.convert_type(nil, "text")).to be_nil }
+      it { expect(Mao.convert_type("blah", "text")).
+               to eq "blah" }
+      it { expect(Mao.convert_type("blah", "text").encoding).
+               to be Encoding::UTF_8 }
     end
 
     context "dates" do
-      it { Mao.convert_type(nil, "timestamp without time zone").
-               should be_nil }
+      it { expect(Mao.convert_type(nil, "timestamp without time zone")).
+               to be_nil }
       # Note: without timezone is assumed to be in UTC.
-      it { Mao.convert_type("2012-11-10 19:45:00",
-                             "timestamp without time zone").
-               should eq Time.new(2012, 11, 10, 19, 45, 0, 0) }
-      it { Mao.convert_type("2012-11-10 19:45:00.1",
-                             "timestamp without time zone").
-               should eq Time.new(2012, 11, 10, 19, 45, 0.1, 0) }
+      it { expect(Mao.convert_type("2012-11-10 19:45:00",
+                             "timestamp without time zone")).
+               to eq Time.new(2012, 11, 10, 19, 45, 0, 0) }
+      it { expect(Mao.convert_type("2012-11-10 19:45:00.1",
+                             "timestamp without time zone")).
+               to eq Time.new(2012, 11, 10, 19, 45, 0.1, 0) }
     end
 
     context "booleans" do
-      it { Mao.convert_type(nil, "boolean").should be_nil }
-      it { Mao.convert_type("t", "boolean").should eq true }
-      it { Mao.convert_type("f", "boolean").should eq false }
+      it { expect(Mao.convert_type(nil, "boolean")).to be_nil }
+      it { expect(Mao.convert_type("t", "boolean")).to eq true }
+      it { expect(Mao.convert_type("f", "boolean")).to eq false }
     end
 
     context "bytea" do
-      it { Mao.convert_type(nil, "bytea").should be_nil }
-      it { Mao.convert_type("\\x5748415400", "bytea").should eq "WHAT\x00" }
-      it { Mao.convert_type("\\x5748415400", "bytea").encoding.
-               should eq Encoding::ASCII_8BIT }
+      it { expect(Mao.convert_type(nil, "bytea")).to be_nil }
+      it { expect(Mao.convert_type("\\x5748415400", "bytea")).to eq "WHAT\x00" }
+      it { expect(Mao.convert_type("\\x5748415400", "bytea").encoding).
+               to eq Encoding::ASCII_8BIT }
     end
 
     context "numeric" do
-      it { Mao.convert_type(nil, "numeric").should be_nil }
-      it { Mao.convert_type("1234567890123456.789", "numeric").
-               should eq BigDecimal.new("1234567890123456.789") }
+      it { expect(Mao.convert_type(nil, "numeric")).to be_nil }
+      it { expect(Mao.convert_type("1234567890123456.789", "numeric")).
+               to eq BigDecimal.new("1234567890123456.789") }
     end
   end
 end

data/spec/query_spec.rb

@@ -14,9 +14,20 @@ describe Mao::Query do
   describe ".new" do
     subject { Mao::Query.new(:table, {}, {}) }
 
-    its(:table) { should be_an_instance_of Symbol }
-    its(:options) { should be_frozen }
-    its(:col_types) { should be_frozen }
+    describe '#table' do
+      subject { super().table }
+      it { is_expected.to be_an_instance_of Symbol }
+    end
+
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to be_frozen }
+    end
+
+    describe '#col_types' do
+      subject { super().col_types }
+      it { is_expected.to be_frozen }
+    end
 
     context "no such table" do
       it { expect { Mao::Query.new("nonextant")
@@ -27,15 +38,29 @@ describe Mao::Query do
   describe "#with_options" do
     subject { one.with_options(:blah => 99) }
 
-    its(:table) { should be one.table }
-    its(:options) { should eq({:blah => 99}) }
+    describe '#table' do
+      subject { super().table }
+      it { is_expected.to be one.table }
+    end
+
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to eq({:blah => 99}) }
+    end
   end
 
   describe "#limit" do
     subject { some.limit(2) }
 
-    its(:options) { should include(:limit => 2) }
-    its(:sql) { should eq 'SELECT * FROM "some" LIMIT 2' }
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to include(:limit => 2) }
+    end
+
+    describe '#sql' do
+      subject { super().sql }
+      it { is_expected.to eq 'SELECT * FROM "some" LIMIT 2' }
+    end
 
     context "invalid argument" do
       it { expect { some.limit("2")
@@ -48,12 +73,12 @@ describe Mao::Query do
 
   describe "#order" do
     let(:asc) { some.order(:id, :asc) }
-    it { asc.options.should include(:order => [:id, 'ASC']) }
-    it { asc.sql.should eq 'SELECT * FROM "some" ORDER BY "id" ASC' }
+    it { expect(asc.options).to include(:order => [:id, 'ASC']) }
+    it { expect(asc.sql).to eq 'SELECT * FROM "some" ORDER BY "id" ASC' }
 
     let(:desc) { one.order(:value, :desc) }
-    it { desc.options.should include(:order => [:value, 'DESC']) }
-    it { desc.sql.should eq 'SELECT * FROM "one" ORDER BY "value" DESC' }
+    it { expect(desc.options).to include(:order => [:value, 'DESC']) }
+    it { expect(desc.sql).to eq 'SELECT * FROM "one" ORDER BY "value" DESC' }
 
     it { expect { one.order(:huh, :asc) }.to raise_exception(ArgumentError) }
     it { expect { one.order(:value) }.to raise_exception(ArgumentError) }
@@ -64,8 +89,15 @@ describe Mao::Query do
   describe "#only" do
     subject { some.only(:id, [:value]) }
 
-    its(:options) { should include(:only => [:id, :value]) }
-    its(:sql) { should eq 'SELECT "id", "value" FROM "some"' }
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to include(:only => [:id, :value]) }
+    end
+
+    describe '#sql' do
+      subject { super().sql }
+      it { is_expected.to eq 'SELECT "id", "value" FROM "some"' }
+    end
 
     context "invalid argument" do
       it { expect { some.only(42)
@@ -85,12 +117,22 @@ describe Mao::Query do
       subject { some.join(:one) { one.value == some.value }.
                     only(:one => [:id]) }
 
-      its(:options) { should include(:only => {:one => [:id]}) }
-      its(:sql) { should eq 'SELECT "one"."id" "c3" ' +
+      describe '#options' do
+        subject { super().options }
+        it { is_expected.to include(:only => {:one => [:id]}) }
+      end
+
+      describe '#sql' do
+        subject { super().sql }
+        it { is_expected.to eq 'SELECT "one"."id" "c3" ' +
                             'FROM "some" ' +
                             'INNER JOIN "one" ' +
                             'ON ("one"."value" = "some"."value")' }
-      its(:select!) { should eq [{:one => {:id => 42}}] }
+      end
+      describe '#select!' do
+        subject { super().select! }
+        it { is_expected.to eq [{:one => {:id => 42}}] }
+      end
 
       context "before #join" do
         it { expect { some.only(:some => [:id])
@@ -108,9 +150,16 @@ describe Mao::Query do
     subject { some.returning([:id], :value).
                   with_options(:insert => [{:value => "q"}]) }
 
-    its(:options) { should include(:returning => [:id, :value]) }
-    its(:sql) { should eq 'INSERT INTO "some" ("value") ' +
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to include(:returning => [:id, :value]) }
+    end
+
+    describe '#sql' do
+      subject { super().sql }
+      it { is_expected.to eq 'INSERT INTO "some" ("value") ' +
                           'VALUES (\'q\') RETURNING "id", "value"' }
+    end
 
     context "invalid argument" do
       it { expect { some.returning(42)
@@ -130,15 +179,21 @@ describe Mao::Query do
   describe "#where" do
     subject { some.where { (id == 1).or(id > 10_000) } }
     
-    its(:options) do
-      should include(:where => [:Binary,
+    describe '#options' do
+      subject { super().options }
+      it do
+      is_expected.to include(:where => [:Binary,
                                 'OR',
                                 [:Binary, '=', [:Column, :id], "1"],
                                 [:Binary, '>', [:Column, :id], "10000"]])
     end
+    end
 
-    its(:sql) { should eq 'SELECT * FROM "some" WHERE ' \
+    describe '#sql' do
+      subject { super().sql }
+      it { is_expected.to eq 'SELECT * FROM "some" WHERE ' \
                           '(("id" = 1) OR ("id" > 10000))' }
+    end
 
     context "non-extant column" do
       it { expect { some.where { non_extant_column == 42 }
@@ -149,11 +204,16 @@ describe Mao::Query do
       subject { some.join(:one) { one.value == some.value }.
                     where { one.id == 42 } }
 
-      its(:options) { should include(:where => [:Binary,
+      describe '#options' do
+        subject { super().options }
+        it { is_expected.to include(:where => [:Binary,
                                                 '=',
                                                 [:Column, :one, :id],
                                                 "42"]) }
-      its(:sql) { should eq 'SELECT "some"."id" "c1", ' +
+      end
+      describe '#sql' do
+        subject { super().sql }
+        it { is_expected.to eq 'SELECT "some"."id" "c1", ' +
                             '"some"."value" "c2", ' +
                             '"one"."id" "c3", ' +
                             '"one"."value" "c4" ' +
@@ -161,69 +221,78 @@ describe Mao::Query do
                             'INNER JOIN "one" ' +
                             'ON ("one"."value" = "some"."value") ' +
                             'WHERE ("one"."id" = 42)' }
+      end
 
-      its(:select!) { should eq(
+      describe '#select!' do
+        subject { super().select! }
+        it { is_expected.to eq(
                           [{:some => {:id => 3, :value => "你好, Dave."},
                             :one => {:id => 42, :value => "你好, Dave."}}]) }
+      end
     end
 
     context "with time values" do
-      it { times.select_first!.should eq(
+      it { expect(times.select_first!).to eq(
                {:id => 1, :time => Time.new(2012, 11, 10, 19, 45, 0, 0)}) }
 
-      it { times.where { time == Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600) }.
-               select!.length.should eq 1 }
-      it { times.where { time == Time.new(2012, 11, 10, 19, 45, 0, 0) }.
-               select!.length.should eq 1 }
-      it { times.where { time == "2012-11-10 19:45:00" }.
-               select!.length.should eq 1 }
-      it { times.where { time == "2012-11-10 19:45:00 Z" }.
-               select!.length.should eq 1 }
-      it { times.where { time == "2012-11-10 19:45:00 +00" }.
-               select!.length.should eq 1 }
-      it { times.where { time == "2012-11-10 19:45:00 +00:00" }.
-               select!.length.should eq 1 }
-      it { times.where { time == "2012-11-10 19:45:00 -00" }.
-               select!.length.should eq 1 }
-      it { times.where { time == "2012-11-10 19:45:00 -00:00" }.
-               select!.length.should eq 1 }
-
-      it { times.where { time < Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600) }.
-               select!.length.should eq 0 }
+      it { expect(times.where { time == Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600) }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == Time.new(2012, 11, 10, 19, 45, 0, 0) }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == "2012-11-10 19:45:00" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == "2012-11-10 19:45:00 Z" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == "2012-11-10 19:45:00 +00" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == "2012-11-10 19:45:00 +00:00" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == "2012-11-10 19:45:00 -00" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time == "2012-11-10 19:45:00 -00:00" }.
+               select!.length).to eq 1 }
+
+      it { expect(times.where { time < Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600) }.
+               select!.length).to eq 0 }
       context "surprising results" do
         # Timestamps are IGNORED for comparisons with "timestamp without time
         # zone".  See:
         # http://postgresql.org/docs/9.1/static/datatype-datetime.html#AEN5714
-        it { times.where { time < "2012-11-11 6:45:00 +11" }.
-                 select!.length.should eq 1 }
-        it { times.where { time < "2012-11-11 6:45:00 +1100" }.
-                 select!.length.should eq 1 }
-        it { times.where { time < "2012-11-11 6:45:00 +11:00" }.
-                 select!.length.should eq 1 }
+        it { expect(times.where { time < "2012-11-11 6:45:00 +11" }.
+                 select!.length).to eq 1 }
+        it { expect(times.where { time < "2012-11-11 6:45:00 +1100" }.
+                 select!.length).to eq 1 }
+        it { expect(times.where { time < "2012-11-11 6:45:00 +11:00" }.
+                 select!.length).to eq 1 }
       end
-      it { times.where { time <= Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600) }.
-               select!.length.should eq 1 }
-      it { times.where { time <= "2012-11-11 6:45:00 +11" }.
-               select!.length.should eq 1 }
-      it { times.where { time <= "2012-11-11 6:45:00 +1100" }.
-               select!.length.should eq 1 }
-      it { times.where { time <= "2012-11-11 6:45:00 +11:00" }.
-               select!.length.should eq 1 }
+      it { expect(times.where { time <= Time.new(2012, 11, 11, 6, 45, 0, 11 * 3600) }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time <= "2012-11-11 6:45:00 +11" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time <= "2012-11-11 6:45:00 +1100" }.
+               select!.length).to eq 1 }
+      it { expect(times.where { time <= "2012-11-11 6:45:00 +11:00" }.
+               select!.length).to eq 1 }
     end
   end
 
   describe "#join" do
     subject { some.join(:one) { one.value == some.value } }
 
-    its(:options) do
-      should include(:join => [:one,
+    describe '#options' do
+      subject { super().options }
+      it do
+      is_expected.to include(:join => [:one,
                                [:Binary,
                                 '=',
                                 [:Column, :one, :value],
                                 [:Column, :some, :value]]])
     end
+    end
 
-    its(:sql) { should eq(
+    describe '#sql' do
+      subject { super().sql }
+      it { is_expected.to eq(
       'SELECT ' +
       '"some"."id" "c1", ' +
       '"some"."value" "c2", ' +
@@ -232,22 +301,29 @@ describe Mao::Query do
       'FROM "some" ' +
       'INNER JOIN "one" ' +
       'ON ("one"."value" = "some"."value")') }
+    end
 
-    its(:select!) { should eq [{:some => {:id => 3,
+    describe '#select!' do
+      subject { super().select! }
+      it { is_expected.to eq [{:some => {:id => 3,
                                           :value => "你好, Dave."},
                                 :one => {:id => 42,
                                           :value => "你好, Dave."}}] }
+    end
 
     context "simple Hash joins" do
       subject { some.join({:one => {:value => :id}}) }
 
-      its(:options) do
-        should include(:join => [:one,
+      describe '#options' do
+        subject { super().options }
+        it do
+        is_expected.to include(:join => [:one,
                                  [:Binary,
                                   '=',
                                   [:Column, :some, :value],
                                   [:Column, :one, :id]]])
       end
+      end
     end
   end
 
@@ -260,51 +336,79 @@ describe Mao::Query do
                                     {}) }
       let(:empty_sure) { double("empty_sure") }
       let(:empty_sql) { double("empty_sql") }
-      before { empty.should_receive(:with_options).
+      before { expect(empty).to receive(:with_options).
                    with(:update => nil).
                    and_return(empty_sure) }
-      before { empty_sure.should_receive(:sql).
+      before { expect(empty_sure).to receive(:sql).
                    and_return(empty_sql) }
-      before { PG::Connection.any_instance.should_receive(:exec).
+      before { expect_any_instance_of(PG::Connection).to receive(:exec).
                    with(empty_sql).and_return(:ok) }
-      it { empty.select!.should eq :ok }
+      it { expect(empty.select!).to eq :ok }
     end
 
     context "no results" do
-      it { empty.select!.should eq [] }
+      it { expect(empty.select!).to eq [] }
     end
 
     context "one result" do
       subject { one.select! }
 
-      it { should be_an_instance_of Array }
-      it { should have(1).item }
-      its([0]) { should eq({:id => 42, :value => "你好, Dave."}) }
+      it { is_expected.to be_an_instance_of Array }
+      it 'has 1 item' do
+        expect(subject.size).to eq(1)
+      end
+
+      describe '[0]' do
+        subject { super()[0] }
+        it { is_expected.to eq({:id => 42, :value => "你好, Dave."}) }
+      end
     end
 
     context "some results" do
       subject { some.select! }
 
-      it { should be_an_instance_of Array }
-      it { should have(3).items }
+      it { is_expected.to be_an_instance_of Array }
+      it 'has 3 items' do
+        expect(subject.size).to eq(3)
+      end
+
+      describe '[0]' do
+        subject { super()[0] }
+        it { is_expected.to eq({:id => 1, :value => "Bah"}) }
+      end
+
+      describe '[1]' do
+        subject { super()[1] }
+        it { is_expected.to eq({:id => 2, :value => "Hah"}) }
+      end
 
-      its([0]) { should eq({:id => 1, :value => "Bah"}) }
-      its([1]) { should eq({:id => 2, :value => "Hah"}) }
-      its([2]) { should eq({:id => 3, :value => "你好, Dave."}) }
+      describe '[2]' do
+        subject { super()[2] }
+        it { is_expected.to eq({:id => 3, :value => "你好, Dave."}) }
+      end
     end
 
     context "various types" do
       subject { typey.select! }
 
-      it { should have(2).items }
-      its([0]) { should eq(
+      it 'has 2 items' do
+        expect(subject.size).to eq(2)
+      end
+
+      describe '[0]' do
+        subject { super()[0] }
+        it { is_expected.to eq(
         {:korea => true,
          :japan => BigDecimal.new("1234567890123456.789"),
          :china => "WHAT\x00".force_encoding(Encoding::ASCII_8BIT)}) }
-      its([1]) { should eq(
+      end
+      describe '[1]' do
+        subject { super()[1] }
+        it { is_expected.to eq(
         {:korea => false,
          :japan => BigDecimal.new("-1234567890123456.789"),
          :china => "HUH\x01\x02".force_encoding(Encoding::ASCII_8BIT)}) }
+      end
     end
   end
 
@@ -314,9 +418,9 @@ describe Mao::Query do
     let(:empty) { Mao::Query.new("empty",
                                   {},
                                   {}) }
-    before { empty.should_receive(:limit).with(1).and_return(empty) }
-    before { empty.should_receive(:select!).and_return([:ok]) }
-    it { empty.select_first!.should eq :ok }
+    before { expect(empty).to receive(:limit).with(1).and_return(empty) }
+    before { expect(empty).to receive(:select!).and_return([:ok]) }
+    it { expect(empty.select_first!).to eq :ok }
   end
 
   describe "#update!" do
@@ -326,22 +430,22 @@ describe Mao::Query do
                                     {}) }
       let(:empty_update) { double("empty_update") }
       let(:empty_sql) { double("empty_sql") }
-      before { empty.should_receive(:with_options).
+      before { expect(empty).to receive(:with_options).
                    with(:update => {:x => :y}).
                    and_return(empty_update) }
-      before { empty_update.should_receive(:sql).and_return(empty_sql) }
-      before { PG::Connection.any_instance.should_receive(:exec).
+      before { expect(empty_update).to receive(:sql).and_return(empty_sql) }
+      before { expect_any_instance_of(PG::Connection).to receive(:exec).
                    with(empty_sql).and_return(:ok) }
-      it { empty.update!(:x => :y).should eq :ok }
+      it { expect(empty.update!(:x => :y)).to eq :ok }
     end
 
     context "#sql result" do
       subject { empty.with_options(:update => {:id => 44}).sql }
-      it { should eq 'UPDATE "empty" SET "id" = 44' }
+      it { is_expected.to eq 'UPDATE "empty" SET "id" = 44' }
     end
 
     context "no matches" do
-      it { empty.update!(:value => "y").should eq 0 }
+      it { expect(empty.update!(:value => "y")).to eq 0 }
     end
 
     context "no such column" do
@@ -350,7 +454,7 @@ describe Mao::Query do
     end
 
     context "some matches" do
-      it { some.where { id <= 2 }.update!(:value => 'Meh').should eq 2 }
+      it { expect(some.where { id <= 2 }.update!(:value => 'Meh')).to eq 2 }
     end
   end
 
@@ -361,46 +465,46 @@ describe Mao::Query do
                                     {}) }
       let(:empty_insert) { double("empty_insert") }
       let(:empty_sql) { double("empty_sql") }
-      before { empty.should_receive(:with_options).
+      before { expect(empty).to receive(:with_options).
                    with(:insert => [{:x => :y}]).
                    and_return(empty_insert) }
-      before { empty_insert.should_receive(:sql).and_return(empty_sql) }
-      before { PG::Connection.any_instance.should_receive(:exec).
+      before { expect(empty_insert).to receive(:sql).and_return(empty_sql) }
+      before { expect_any_instance_of(PG::Connection).to receive(:exec).
                    with(empty_sql).and_return(:ok) }
-      it { empty.insert!([:x => :y]).should eq :ok }
+      it { expect(empty.insert!([:x => :y])).to eq :ok }
     end
 
     context "#sql result" do
       context "all columns alike" do
         subject { empty.with_options(
                       :insert => [{:id => 44}, {:id => 38}]).sql }
-        it { should eq 'INSERT INTO "empty" ("id") VALUES (44), (38)' }
+        it { is_expected.to eq 'INSERT INTO "empty" ("id") VALUES (44), (38)' }
       end
 
       context "not all columns alike" do
         subject { empty.with_options(
                       :insert => [{:id => 1}, {:value => 'z', :id => 2}]).sql }
-        it { should eq 'INSERT INTO "empty" ("id", "value") ' +
+        it { is_expected.to eq 'INSERT INTO "empty" ("id", "value") ' +
                        'VALUES (1, DEFAULT), (2, \'z\')' }
       end
     end
 
     context "result" do
       context "number of rows" do
-        it { autoid.insert!(:value => "quox").should eq 1 }
-        it { autoid.insert!({:value => "lol"}, {:value => "x"}).should eq 2 }
+        it { expect(autoid.insert!(:value => "quox")).to eq 1 }
+        it { expect(autoid.insert!({:value => "lol"}, {:value => "x"})).to eq 2 }
       end
 
       context "#returning" do
         it do
-          autoid.returning(:id).insert!(:value => "nanana").
-              should eq([{:id => 1}])
-          autoid.returning(:id).insert!(:value => "ha").
-              should eq([{:id => 2}])
-          autoid.returning(:id).insert!(:value => "bah").
-              should eq([{:id => 3}])
-          autoid.returning(:id).insert!({:value => "a"}, {:value => "b"}).
-              should eq([{:id => 4}, {:id => 5}])
+          expect(autoid.returning(:id).insert!(:value => "nanana")).
+              to eq([{:id => 1}])
+          expect(autoid.returning(:id).insert!(:value => "ha")).
+              to eq([{:id => 2}])
+          expect(autoid.returning(:id).insert!(:value => "bah")).
+              to eq([{:id => 3}])
+          expect(autoid.returning(:id).insert!({:value => "a"}, {:value => "b"})).
+              to eq([{:id => 4}, {:id => 5}])
         end
       end
     end
@@ -408,8 +512,8 @@ describe Mao::Query do
 
   describe "reconnection" do
     it do
-      Mao.query(:one).select!.should be_an_instance_of Array
-      pending
+      expect(Mao.query(:one).select!).to be_an_instance_of Array
+      skip
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mao
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Timothy Leslie Allen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-27 00:00:00.000000000 Z
+date: 2015-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.18.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 0.18.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -43,16 +43,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 description: Mao Ain't an ORM
 email:
 - allen.timothy.email@gmail.com
@@ -79,7 +79,7 @@ files:
 - spec/mao_spec.rb
 - spec/query_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/unnali/mao
+homepage: https://github.com/kivikakk/mao
 licenses: []
 metadata: {}
 post_install_message: 
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: A database access layer.  Currently supports PG.