sequel 4.10.0 → 4.11.0

data/spec/extensions/pg_json_spec.rb

@@ -8,6 +8,8 @@ describe "pg_json extension" do
     @m = m::JSONDatabaseMethods
     @hc = m::JSONHash
     @ac = m::JSONArray
+    @bhc = m::JSONBHash
+    @bac = m::JSONBArray
 
     # Create subclass in correct namespace for easily overriding methods
     j = m::JSON = JSON.dup
@@ -46,6 +48,14 @@ describe "pg_json extension" do
     @m.db_parse_json('1.1').should == 1.1
   end
 
+  it "should parse json and non-json plain strings, integers, and floats correctly in db_parse_jsonb" do
+    @m.db_parse_jsonb('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
+    @m.db_parse_jsonb('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
+    @m.db_parse_jsonb('1').should == 1
+    @m.db_parse_jsonb('"b"').should == 'b'
+    @m.db_parse_jsonb('1.1').should == 1.1
+  end
+
   it "should raise an error when attempting to parse invalid json" do
     proc{@m.parse_json('')}.should raise_error(Sequel::InvalidValue)
     proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
@@ -72,6 +82,13 @@ describe "pg_json extension" do
     @db.literal(Sequel.pg_json('a'=>'b')).should == "'{\"a\":\"b\"}'::json"
   end
 
+  it "should literalize JSONHash and JSONArray to strings correctly" do
+    @db.literal(Sequel.pg_jsonb([])).should == "'[]'::jsonb"
+    @db.literal(Sequel.pg_jsonb([1, [2], {'a'=>'b'}])).should == "'[1,[2],{\"a\":\"b\"}]'::jsonb"
+    @db.literal(Sequel.pg_jsonb({})).should == "'{}'::jsonb"
+    @db.literal(Sequel.pg_jsonb('a'=>'b')).should == "'{\"a\":\"b\"}'::jsonb"
+  end
+
   it "should have Sequel.pg_json return JSONHash and JSONArray as is" do
     a = Sequel.pg_json({})
     Sequel.pg_json(a).should equal(a)
@@ -79,22 +96,72 @@ describe "pg_json extension" do
     Sequel.pg_json(a).should equal(a)
   end
 
-  it "should have JSONHash#to_hash method for getting underlying hash" do
+  it "should have Sequel.pg_json convert jsonb values" do
+    a = {}
+    v = Sequel.pg_json(Sequel.pg_jsonb(a))
+    v.to_hash.should equal(a)
+    v.should be_a_kind_of(@hc)
+
+    a = []
+    v = Sequel.pg_json(Sequel.pg_jsonb(a))
+    v.to_a.should equal(a)
+    v.should be_a_kind_of(@ac)
+  end
+
+  it "should have Sequel.pg_jsonb return JSONBHash and JSONBArray as is" do
+    a = Sequel.pg_jsonb({})
+    Sequel.pg_jsonb(a).should equal(a)
+    a = Sequel.pg_jsonb([])
+    Sequel.pg_jsonb(a).should equal(a)
+  end
+
+  it "should have Sequel.pg_jsonb convert json values" do
+    a = {}
+    v = Sequel.pg_jsonb(Sequel.pg_json(a))
+    v.to_hash.should equal(a)
+    v.should be_a_kind_of(@bhc)
+
+    a = []
+    v = Sequel.pg_jsonb(Sequel.pg_json(a))
+    v.to_a.should equal(a)
+    v.should be_a_kind_of(@bac)
+  end
+
+  it "should have JSONHashBase#to_hash method for getting underlying hash" do
     Sequel.pg_json({}).to_hash.should be_a_kind_of(Hash)
+    Sequel.pg_jsonb({}).to_hash.should be_a_kind_of(Hash)
+  end
+
+  it "should allow aliasing json objects" do
+    @db.literal(Sequel.pg_json({}).as(:a)).should == "'{}'::json AS a"
+    @db.literal(Sequel.pg_json([]).as(:a)).should == "'[]'::json AS a"
+    @db.literal(Sequel.pg_jsonb({}).as(:a)).should == "'{}'::jsonb AS a"
+    @db.literal(Sequel.pg_jsonb([]).as(:a)).should == "'[]'::jsonb AS a"
+  end
+
+  it "should allow casting json objects" do
+    @db.literal(Sequel.pg_json({}).cast(String)).should == "CAST('{}'::json AS text)"
+    @db.literal(Sequel.pg_json([]).cast(String)).should == "CAST('[]'::json AS text)"
+    @db.literal(Sequel.pg_jsonb({}).cast(String)).should == "CAST('{}'::jsonb AS text)"
+    @db.literal(Sequel.pg_jsonb([]).cast(String)).should == "CAST('[]'::jsonb AS text)"
   end
 
-  it "should have JSONArray#to_a method for getting underlying array" do
+  it "should have JSONArrayBase#to_a method for getting underlying array" do
     Sequel.pg_json([]).to_a.should be_a_kind_of(Array)
+    Sequel.pg_jsonb([]).to_a.should be_a_kind_of(Array)
   end
 
-  it "should support using JSONHash and JSONArray as bound variables" do
+  it "should support using JSONHashBase and JSONArrayBase as bound variables" do
     @db.bound_variable_arg(1, nil).should == 1
     @db.bound_variable_arg(Sequel.pg_json([1]), nil).should == '[1]'
     @db.bound_variable_arg(Sequel.pg_json('a'=>'b'), nil).should == '{"a":"b"}'
+    @db.bound_variable_arg(Sequel.pg_jsonb([1]), nil).should == '[1]'
+    @db.bound_variable_arg(Sequel.pg_jsonb('a'=>'b'), nil).should == '{"a":"b"}'
   end
 
-  it "should support using json[] types in bound variables" do
+  it "should support using json[] and jsonb[] types in bound variables" do
     @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_json([{"a"=>1}]), Sequel.pg_json("b"=>[1, 2])]), nil).should == '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
+    @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_jsonb([{"a"=>1}]), Sequel.pg_jsonb("b"=>[1, 2])]), nil).should == '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
   end
 
   it "should parse json type from the schema correctly" do
@@ -102,23 +169,56 @@ describe "pg_json extension" do
     @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :json]
   end
 
+  it "should parse json type from the schema correctly" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'jsonb'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :jsonb]
+  end
+
   it "should support typecasting for the json type" do
     h = Sequel.pg_json(1=>2)
     a = Sequel.pg_json([1])
     @db.typecast_value(:json, h).should equal(h)
     @db.typecast_value(:json, h.to_hash).should == h
     @db.typecast_value(:json, h.to_hash).should be_a_kind_of(@hc)
+    @db.typecast_value(:json, Sequel.pg_jsonb(h)).should == h
+    @db.typecast_value(:json, Sequel.pg_jsonb(h)).should be_a_kind_of(@hc)
     @db.typecast_value(:json, a).should equal(a)
     @db.typecast_value(:json, a.to_a).should == a
     @db.typecast_value(:json, a.to_a).should be_a_kind_of(@ac)
+    @db.typecast_value(:json, Sequel.pg_jsonb(a)).should == a
+    @db.typecast_value(:json, Sequel.pg_jsonb(a)).should be_a_kind_of(@ac)
     @db.typecast_value(:json, '[]').should == Sequel.pg_json([])
+    @db.typecast_value(:json, '[]').should be_a_kind_of(@ac)
     @db.typecast_value(:json, '{"a": "b"}').should == Sequel.pg_json("a"=>"b")
+    @db.typecast_value(:json, '{"a": "b"}').should be_a_kind_of(@hc)
     proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
   end
 
+  it "should support typecasting for the jsonb type" do
+    h = Sequel.pg_jsonb(1=>2)
+    a = Sequel.pg_jsonb([1])
+    @db.typecast_value(:jsonb, h).should equal(h)
+    @db.typecast_value(:jsonb, h.to_hash).should == h
+    @db.typecast_value(:jsonb, h.to_hash).should be_a_kind_of(@bhc)
+    @db.typecast_value(:jsonb, Sequel.pg_json(h)).should == h
+    @db.typecast_value(:jsonb, Sequel.pg_json(h)).should be_a_kind_of(@bhc)
+    @db.typecast_value(:jsonb, a).should equal(a)
+    @db.typecast_value(:jsonb, a.to_a).should == a
+    @db.typecast_value(:jsonb, a.to_a).should be_a_kind_of(@bac)
+    @db.typecast_value(:jsonb, Sequel.pg_json(a)).should == a
+    @db.typecast_value(:jsonb, Sequel.pg_json(a)).should be_a_kind_of(@bac)
+    @db.typecast_value(:jsonb, '[]').should == Sequel.pg_jsonb([])
+    @db.typecast_value(:jsonb, '[]').should be_a_kind_of(@bac)
+    @db.typecast_value(:jsonb, '{"a": "b"}').should == Sequel.pg_jsonb("a"=>"b")
+    @db.typecast_value(:jsonb, '{"a": "b"}').should be_a_kind_of(@bhc)
+    proc{@db.typecast_value(:jsonb, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:jsonb, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+
   it "should return correct results for Database#schema_type_class" do
     @db.schema_type_class(:json).should == [Sequel::Postgres::JSONHash, Sequel::Postgres::JSONArray]
+    @db.schema_type_class(:jsonb).should == [Sequel::Postgres::JSONBHash, Sequel::Postgres::JSONBArray]
     @db.schema_type_class(:integer).should == Integer
   end
 end

data/spec/extensions/serialization_spec.rb

@@ -300,4 +300,23 @@ describe "Serialization plugin" do
     o.dup.deserialized_values.should == o.deserialized_values
     o.dup.deserialized_values.should_not equal(o.deserialized_values)
   end
+
+  it "should have changed_columns include serialized columns if those columns have changed" do
+    @c.plugin :serialization, :yaml, :abc, :def
+    @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
+    o = @c.first
+    o.changed_columns.should == []
+    o.abc = 1
+    o.changed_columns.should == []
+    o.abc = 1
+    o.changed_columns.should == []
+    o.abc = 2
+    o.changed_columns.should == [:abc]
+    o.def = 'hello'
+    o.changed_columns.should == [:abc]
+    o.def = 'hello'
+    o.changed_columns.should == [:abc]
+    o.def = 'hello2'
+    o.changed_columns.should == [:abc, :def]
+  end
 end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -70,19 +70,27 @@ describe Sequel::Model, "single table inheritance plugin" do
     called.should == false
   end
 
-  it "should add a before_create hook that sets the model class name for the key" do
+  it "should set the model class name when saving" do
     StiTest.new.save
     StiTestSub1.new.save
     StiTestSub2.new.save
     DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub1')) AND (id = 10)) LIMIT 1", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')", "SELECT * FROM sti_tests WHERE ((sti_tests.kind IN ('StiTestSub2')) AND (id = 10)) LIMIT 1"]
   end
 
-  it "should have the before_create hook not override an existing value" do
+  it "should handle validations on the type column field" do
+    o = StiTestSub1.new
+    def o.validate
+      errors.add(:kind, 'not present') unless kind
+    end
+    o.valid?.should == true
+  end
+
+  it "should override an existing value in the class name field" do
     StiTest.create(:kind=>'StiTestSub1')
     DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "SELECT * FROM sti_tests WHERE (id = 10) LIMIT 1"]
   end
 
-  it "should have the before_create hook handle columns with the same name as existing method names" do
+  it "should handle type column with the same name as existing method names" do
     StiTest.plugin :single_table_inheritance, :type
     StiTest.columns :id, :type
     StiTest.create

data/spec/extensions/timestamps_spec.rb

@@ -22,6 +22,16 @@ describe "Sequel::Plugins::Timestamps" do
     Sequel.datetime_class = Time
   end
   
+  it "should handle validations on the timestamp fields for new objects" do
+    @c.plugin :timestamps, :update_on_create=>true
+    o = @c.new
+    def o.validate
+      errors.add(model.create_timestamp_field, 'not present') unless send(model.create_timestamp_field)
+      errors.add(model.update_timestamp_field, 'not present') unless send(model.update_timestamp_field)
+    end
+    o.valid?.should == true
+  end
+
   it "should set the create timestamp field on creation" do
     o = @c.create
     @c.db.sqls.should == ["INSERT INTO t (created_at) VALUES ('2009-08-01')"]

data/spec/extensions/to_dot_spec.rb

@@ -108,6 +108,10 @@ END
     dot(@ds.from(Sequel.as(:a, :b))).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];"]
   end
 
+  it "should handle SQL::AliasedExpressions with column aliases" do
+    dot(@ds.from(Sequel.as(:a, :b, [:c, :d]))).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];", "3 -> 6 [label=\"columns\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":c\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":d\"];"]
+  end
+
   it "should handle SQL::CaseExpressions" do
     dot(@ds.select(Sequel.case({:a=>:b}, :c, :d))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"CaseExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":d\"];", "3 -> 5 [label=\"conditions\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":a\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"default\"];", "9 [label=\":c\"];"]
   end
@@ -117,15 +121,15 @@ END
   end
 
   it "should handle SQL::Function" do
-    dot(@ds.select{a(b)}).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: a\"];", "3 -> 4 [label=\"0\"];", "4 [label=\"Identifier\"];", "4 -> 5 [label=\"value\"];", "5 [label=\":b\"];"]
+    dot(@ds.select{a(b)}).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: a\"];", "3 -> 4 [label=\"0\"];", "4 [label=\"Identifier\"];", "4 -> 5 [label=\"value\"];", "5 [label=\":b\"];", "3 -> 6 [label=\"args\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\"Identifier\"];", "7 -> 8 [label=\"value\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"opts\"];", "9 [label=\"Hash\"];"]
   end
 
   it "should handle SQL::Subscript" do
     dot(@ds.select(Sequel.subscript(:a, 1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
   end
 
-  it "should handle SQL::WindowFunction" do
-    dot(@ds.select{sum{}.over(:partition=>:a)}).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"WindowFunction\"];", "3 -> 4 [label=\"function\"];", "4 [label=\"Function: sum\"];", "3 -> 5 [label=\"window\"];", "5 [label=\"Window\"];", "5 -> 6 [label=\"opts\"];", "6 [label=\"Hash\"];", "6 -> 7 [label=\"partition\"];", "7 [label=\":a\"];"]
+  it "should handle SQL::Function with a window" do
+    dot(@ds.select{sum{}.over(:partition=>:a)}).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: sum\"];", "3 -> 4 [label=\"args\"];", "4 [label=\"Array\"];", "3 -> 5 [label=\"opts\"];", "5 [label=\"Hash\"];", "5 -> 6 [label=\"over\"];", "6 [label=\"Window\"];", "6 -> 7 [label=\"opts\"];", "7 [label=\"Hash\"];", "7 -> 8 [label=\"partition\"];", "8 [label=\":a\"];"]
   end
 
   it "should handle SQL::PlaceholderLiteralString" do
@@ -137,7 +141,7 @@ END
   end
 
   it "should handle JOIN USING" do
-    dot(@ds.from(:a).join(:d, [:c], :table_alias=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN USING\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"alias\"];", "7 [label=\":c\"];", "5 -> 8 [label=\"using\"];", "8 [label=\"Array\"];", "8 -> 9 [label=\"0\"];", "9 [label=\":c\"];"]
+    dot(@ds.from(:a).join(:d, [:c], :table_alias=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN USING\"];", "5 -> 6 [label=\"table\"];", "6 [label=\"AliasedExpression\"];", "6 -> 7 [label=\"expression\"];", "7 [label=\":d\"];", "6 -> 8 [label=\"alias\"];", "8 [label=\":c\"];", "5 -> 9 [label=\"using\"];", "9 [label=\"Array\"];", "9 -> 10 [label=\"0\"];", "10 [label=\":c\"];"]
   end
 
   it "should handle other types" do

data/spec/integration/database_test.rb

@@ -21,7 +21,7 @@ describe Sequel::Database do
   end
 
   specify "should raise Sequel::DatabaseError on invalid SQL" do
-    proc{@db << "SELECT"}.should raise_error(Sequel::DatabaseError)
+    proc{@db << "S"}.should raise_error(Sequel::DatabaseError)
   end
 
   specify "should have Sequel::DatabaseError#sql give the SQL causing the error" do

data/spec/integration/dataset_test.rb

@@ -293,6 +293,10 @@ describe "Simple Dataset operations" do
     @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
   end
 
+  specify "should support table aliases with column aliases" do
+    DB.from(@ds.as(:i, [:x, :n])).first.should == {:x=>1, :n=>10}
+  end if DB.dataset.supports_derived_column_lists?
+
   specify "should handle true/false properly" do
     @ds.filter(Sequel::TRUE).select_map(:number).should == [10]
     @ds.filter(Sequel::FALSE).select_map(:number).should == []
@@ -907,6 +911,11 @@ describe "Sequel::Dataset#import and #multi_insert" do
     @ids.import([:i], [[10], [20], [30]], :slice_size=>3)
     @ids.all.should == [{:i=>10}, {:i=>20}, {:i=>30}]
   end
+
+  it "should import many rows at once" do
+    @ids.import([:i], (1..1000).to_a.map{|x| [x]})
+    @ids.select_order_map(:i).should == (1..1000).to_a
+  end
 end
 
 describe "Sequel::Dataset#import and #multi_insert :return=>:primary_key " do

data/spec/integration/schema_test.rb

@@ -272,12 +272,14 @@ describe "Database schema modifiers" do
 
   describe "views" do
     before do
+      @db.drop_view(:items_view2) rescue nil
       @db.drop_view(:items_view) rescue nil
       @db.create_table(:items){Integer :number}
       @ds.insert(:number=>1)
       @ds.insert(:number=>2)
     end
     after do
+      @db.drop_view(:items_view2) rescue nil
       @db.drop_view(:items_view) rescue nil
     end
 
@@ -286,6 +288,31 @@ describe "Database schema modifiers" do
       @db[:items_view].map(:number).should == [1]
     end
 
+    specify "should create views with check options correctly" do
+      @db.create_view(:items_view, @ds.where{number > 2}, :check=>true)
+      proc{@db[:items_view].insert(1)}.should raise_error(Sequel::DatabaseError)
+      @db[:items_view].insert(3)
+      @db[:items_view].select_order_map(:number).should == [3]
+      @db.create_view(:items_view2, @db[:items_view].where{number > 1}, :check=>true)
+      proc{@db[:items_view2].insert(1)}.should raise_error(Sequel::DatabaseError)
+      proc{@db[:items_view2].insert(2)}.should raise_error(Sequel::DatabaseError)
+      @db[:items_view2].insert(4)
+      @db[:items_view2].select_order_map(:number).should == [3, 4]
+      @ds.select_order_map(:number).should == [1, 2, 3, 4]
+    end if DB.supports_views_with_check_option?
+
+    specify "should create views with local check options correctly" do
+      @db.create_view(:items_view, @ds.where{number > 2})
+      @db[:items_view].insert(3)
+      @db[:items_view].select_order_map(:number).should == [3]
+      @db.create_view(:items_view2, @db[:items_view].where{number > 1}, :check=>:local)
+      proc{@db[:items_view2].insert(1)}.should raise_error(Sequel::DatabaseError)
+      @db[:items_view2].insert(2)
+      @db[:items_view2].insert(4)
+      @db[:items_view2].select_order_map(:number).should == [3, 4]
+      @ds.select_order_map(:number).should == [1, 2, 2, 3, 4]
+    end if DB.supports_views_with_local_check_option?
+
     cspecify "should create views with explicit columns correctly", :sqlite do
       @db.create_view(:items_view, @ds.where(:number=>1), :columns=>[:n])
       @db[:items_view].map(:n).should == [1]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.10.0
+  version: 4.11.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-01 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies: []
 description: The Database Toolkit for Ruby
 email: code@jeremyevans.net
@@ -127,6 +127,7 @@ extra_rdoc_files:
 - doc/release_notes/4.8.0.txt
 - doc/release_notes/4.9.0.txt
 - doc/release_notes/4.10.0.txt
+- doc/release_notes/4.11.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -224,6 +225,7 @@ files:
 - doc/release_notes/4.0.0.txt
 - doc/release_notes/4.1.0.txt
 - doc/release_notes/4.10.0.txt
+- doc/release_notes/4.11.0.txt
 - doc/release_notes/4.2.0.txt
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.4.0.txt