sequel 5.18.0 → 5.20.0

data/spec/extensions/migration_spec.rb

@@ -195,6 +195,19 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
       [:drop_table, :a, {:foo=>:bar}]]
   end
   
+  it "should reverse add_foreign_key with :type option" do
+    Sequel.migration{change{alter_table(:t){add_foreign_key :b, :c, :type=>:f}}}.apply(@db, :down)
+    actions = @db.actions
+    actions.must_equal [[:alter_table, [[:drop_foreign_key, :b, {:type=>:f}]]]]
+    @db.sqls
+    db = Sequel.mock
+    args = nil
+    db.define_singleton_method(:foreign_key_list){|*a| args = a; [{:name=>:fbc, :columns=>[:b]}]}
+    db.alter_table(:t){send(*actions[0][1][0])}
+    db.sqls.must_equal ["ALTER TABLE t DROP CONSTRAINT fbc", "ALTER TABLE t DROP COLUMN b"]
+    args.must_equal [:t]
+  end
+  
   it "should reverse add_foreign_key with :foreign_key_constraint_name option" do
     Sequel.migration{change{alter_table(:t){add_foreign_key :b, :c, :foreign_key_constraint_name=>:f}}}.apply(@db, :down)
     actions = @db.actions

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -161,4 +161,12 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.save}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
   end
+
+  it "should handle overridden constraint failures as validation errors when updating" do
+    o = @c.load(:i=>3)
+    @c.pg_auto_constraint_validation_override(:items_i_ocheck, :i, "foo bar")
+    @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_ocheck']
+    proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
+    o.errors.must_equal(:i=>['foo bar'])
+  end
 end

data/spec/extensions/pg_enum_spec.rb

@@ -49,6 +49,11 @@ describe "pg_enum extension" do
     @db.sqls.first.must_equal "ALTER TYPE sch.foo RENAME TO sch.bar"
   end
 
+  it "should support #rename_enum_value method for renameing an enum value" do
+    @db.rename_enum_value(:foo, :b, :x)
+    @db.sqls.first.must_equal "ALTER TYPE foo RENAME VALUE 'b' TO 'x'"
+  end
+
   it "should support #drop_enum method for dropping an enum" do
     @db.drop_enum(:foo)
     @db.sqls.first.must_equal "DROP TYPE foo"

data/spec/extensions/s_spec.rb

@@ -29,7 +29,7 @@ describe "s extension as refinement" do
 end
 
 
-if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') # || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_ENGINE == 'jruby' && (JRUBY_VERSION >= '9.3' || (JRUBY_VERSION.match(/\A9\.2\.(\d+)/) && $1.to_i >= 7)))
 using Sequel::S
 
 describe "s extension as refinement" do

data/spec/extensions/schema_dumper_spec.rb

@@ -800,14 +800,16 @@ END_MIG
   it "should convert mysql types to ruby types" do
     def @d.schema(t, *o)
       i = 0
-      ['double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
+      ['float unsigned', 'double(15,2)', 'double(7,1) unsigned'].map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
     @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
 create_table(:x) do
   Float :c1
   Float :c2
+  Float :c3
   
-  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c2), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c1), 0)
+  check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c3), 0)
 end
 END_MIG
   end

data/spec/integration/plugin_test.rb

@@ -30,6 +30,7 @@ describe "Class Table Inheritance Plugin" do
     end 
     class ::Manager < Employee
       one_to_many :staff_members, :class=>:Staff
+      one_to_one :first_staff_member, :clone=>:staff_members, :order=>:id
     end 
     class ::Executive < Manager
     end 
@@ -150,6 +151,8 @@ describe "Class Table Inheritance Plugin" do
     m = Staff.first.manager
     m.must_equal Manager[@i4]
     m.must_be_kind_of(Executive)
+    Staff.first.update(:manager => Manager[@i3])
+    Staff.first.manager.must_equal Manager[@i3]
   end
   
   it "should handle eagerly loading many_to_one relationships" do
@@ -164,6 +167,18 @@ describe "Class Table Inheritance Plugin" do
   
   it "should handle one_to_many relationships" do
     Executive.first(:name=>'Ex').staff_members.must_equal [Staff[@i2]]
+    i6 = @db[:employees].insert(:name=>'S2', :kind=>'Staff')
+    @db[:staff].insert(:id=>i6, :manager_id=>@i4)
+    Executive.first(:name=>'Ex').add_staff_member(i6)
+    Executive.first(:name=>'Ex').staff_members{|ds| ds.order(:id)}.must_equal [Staff[@i2], Staff[i6]]
+  end
+  
+  it "should handle one_to_many relationships" do
+    Executive.first(:name=>'Ex').first_staff_member.must_equal Staff[@i2]
+    i6 = @db[:employees].insert(:name=>'S2', :kind=>'Staff')
+    @db[:staff].insert(:id=>i6, :manager_id=>@i4)
+    Executive.first(:name=>'Ex').first_staff_member = Staff[i6]
+    Executive.first(:name=>'Ex').staff_members.must_equal [Staff[i6]]
   end
   
   it "should handle eagerly loading one_to_many relationships" do

data/spec/integration/transaction_test.rb

@@ -496,6 +496,56 @@ describe "Database transactions" do
       @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.must_be_nil; raise Sequel::Rollback}
       c.must_equal 1
     end
+
+    it "should support after_commit inside savepoints with :savepoint_option" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_commit(:savepoint=>true){c = 1}}}
+      c.must_be_nil
+
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}
+      c.must_be_nil
+
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_commit(:savepoint=>true){c = 1}}}}
+      c.must_be_nil
+    end
+
+    it "should support after_rollback inside savepoints with :savepoint_option" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction(:rollback=>:always){@db.transaction(:savepoint=>true){@db.transaction(:savepoint=>true, :rollback=>:always){@db.after_rollback(:savepoint=>true){c = 1}; c.must_be_nil}; c.must_equal 1}}
+      c.must_equal 1
+
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true, :rollback=>:always){@db.transaction(:savepoint=>true){@db.after_rollback(:savepoint=>true){c = 1}}; c.must_be_nil}; c.must_equal 1}
+      c.must_equal 1
+    end
   end
 
   if DB.supports_prepared_transactions?

data/spec/model/associations_spec.rb

@@ -99,13 +99,13 @@ describe Sequel::Model, "associate" do
       class ::ParParent < Sequel::Model; end
       klass = Class.new(Sequel::Model(:nodes))
       
-      klass.many_to_one(:par_parent, :order=>:a){1}
-      klass.one_to_many(:par_parent1s, :class=>'ParParent', :limit=>12){4}
-      klass.many_to_many(:par_parent2s, :class=>:ParParent, :uniq=>true){2}
+      klass.many_to_one(:par_parent, :order=>:a){|ds| 1}
+      klass.one_to_many(:par_parent1s, :class=>'ParParent', :limit=>12){|ds| 4}
+      klass.many_to_many(:par_parent2s, :class=>:ParParent, :uniq=>true){|ds| 2}
 
       klass.many_to_one :par, :clone=>:par_parent, :select=>:b
       klass.one_to_many :par1s, :clone=>:par_parent1s, :order=>:b, :limit=>10, :block=>nil
-      klass.many_to_many(:par2s, :clone=>:par_parent2s, :order=>:c){3}
+      klass.many_to_many(:par2s, :clone=>:par_parent2s, :order=>:c){|ds| 3}
       klass.many_to_one :par3, :clone=>:par
       
       klass.association_reflection(:par).associated_class.must_equal ParParent
@@ -861,6 +861,50 @@ describe Sequel::Model, "one_to_one" do
       "UPDATE attributes SET y = 5, node_id = 1234 WHERE (id = 3)"]
   end
 
+  it "should have setter method handle associations to models with joined datasets" do
+    db = Sequel.mock
+    c = Class.new(Sequel::Model(db)) do
+      set_dataset(db[:attributes].join(:foo, :attribute_id=>:id))
+      def _insert_dataset
+        db[:attributes]
+      end
+      def _update_dataset
+        db[:attributes].where(pk_hash)
+      end
+      @instance_dataset = dataset.limit(1).naked.skip_limit_check
+      unrestrict_primary_key
+      columns :id, :node_id, :y
+    end
+
+    @c2.one_to_one :attribute, :class => c
+    attrib = c.new(:id=>3)
+
+    db.fetch = [[], {:id=>3}]
+    @c2.load(:id => 1234).attribute = attrib
+    DB.sqls.must_equal []
+    db.sqls.must_equal [
+      "SELECT * FROM (SELECT * FROM attributes INNER JOIN foo ON (foo.attribute_id = attributes.id)) AS attributes LIMIT 1",
+      "SELECT * FROM (SELECT * FROM attributes INNER JOIN foo ON (foo.attribute_id = attributes.id)) AS attributes WHERE (node_id = 1234) LIMIT 1",
+      "INSERT INTO attributes (id, node_id) VALUES (3, 1234)",
+      "SELECT * FROM (SELECT * FROM attributes INNER JOIN foo ON (foo.attribute_id = attributes.id)) AS attributes WHERE (id = 3) LIMIT 1"]
+
+    db.fetch = [[{:id=>4}], {:id=>3, :node_id=>1234}]
+    db.numrows = 1
+    @c2.load(:id => 1234).attribute = c.load(:id=>3)
+    db.sqls.must_equal [
+      "SELECT * FROM (SELECT * FROM attributes INNER JOIN foo ON (foo.attribute_id = attributes.id)) AS attributes WHERE (node_id = 1234) LIMIT 1",
+      "UPDATE attributes SET node_id = NULL WHERE (id = 4)",
+      "UPDATE attributes SET node_id = 1234 WHERE (id = 3)"]
+
+    db.fetch = [[{:id=>4}], {:id=>3, :node_id=>1234}]
+    @c2.load(:id => 1234).attribute = c.new(:id=>3)
+    db.sqls.must_equal [
+      "SELECT * FROM (SELECT * FROM attributes INNER JOIN foo ON (foo.attribute_id = attributes.id)) AS attributes WHERE (node_id = 1234) LIMIT 1",
+      "UPDATE attributes SET node_id = NULL WHERE (id = 4)",
+      "INSERT INTO attributes (id, node_id) VALUES (3, 1234)",
+      "SELECT * FROM (SELECT * FROM attributes INNER JOIN foo ON (foo.attribute_id = attributes.id)) AS attributes WHERE (id = 3) LIMIT 1"]
+  end
+
   it "should use implicit key if omitted" do
     @c2.dataset = @c2.dataset.with_fetch({})
     @c2.one_to_one :parent, :class => @c2
@@ -958,6 +1002,42 @@ describe Sequel::Model, "one_to_one" do
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE ((parent_id = 100) AND (x > 1)) ORDER BY name LIMIT 1 OFFSET 20"]
   end
 
+  it "should support :dataset options with different types of arity" do
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{model.filter(:parent_id=>pk)}
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100) LIMIT 1"]
+
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{|_| model.filter(:parent_id=>pk)}
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100) LIMIT 1"]
+
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{|_, *| model.filter(:parent_id=>pk)}
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100) LIMIT 1"]
+
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{|*| model.filter(:parent_id=>pk)}
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100) LIMIT 1"]
+  end
+
+  deprecated "should support :dataset option that requires multiple arguments" do
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{|_, _| model.filter(:parent_id=>pk)}
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100) LIMIT 1"]
+  end
+
+  deprecated "should support association block requires no arguments" do
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id do model.filter(:parent_id=>pk) end
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100)"]
+  end
+
+  deprecated "should support association block requires multiple arguments" do
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id do |_, _| model.filter(:parent_id=>pk) end
+    @c2.load(:id => 100).child_20
+    DB.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id = 100)"]
+  end
+
   it "should return nil if primary_key value is nil" do
     @c2.one_to_one :parent, :class => @c2, :primary_key=>:node_id
 

data/spec/model/plugins_spec.rb

@@ -316,3 +316,114 @@ describe "Sequel::Model.plugin" do
     a.must_equal ['sequel/plugins/something_or_other']
   end
 end
+
+describe "Sequel::Plugins.def_sequel_method" do
+  before do
+    @m = Class.new
+    @scope = @m.new
+  end
+
+  it "should define methods using block" do
+    m0 = Sequel::Plugins.def_sequel_method(@m, "x", 0){1}
+    m0.must_be_kind_of Symbol
+    m0.must_match /\A_sequel_x_\d+\z/
+    @scope.send(m0).must_equal 1
+
+    m1 = Sequel::Plugins.def_sequel_method(@m, "x", 1){|x| [x, 2]}
+    m1.must_be_kind_of Symbol
+    m1.must_match /\A_sequel_x_\d+\z/
+    @scope.send(m1, 3).must_equal [3, 2]
+  end
+
+  it "should define public methods" do
+    proc{@scope.public_send(Sequel::Plugins.def_sequel_method(@m, "x", 0){1})}.must_raise NoMethodError
+  end
+
+  it "should accept symbols as method name and return the same symbol" do
+    m0 = Sequel::Plugins.def_sequel_method(@m, :_roda_foo, 0){1}
+    m0.must_equal :_roda_foo
+    @scope.send(m0).must_equal 1
+  end
+
+  it "should handle optional arguments and splats for expected_arity 0" do
+    m2 = Sequel::Plugins.def_sequel_method(@m, "x", 0){|*x| [x, 3]}
+    @scope.send(m2).must_equal [[], 3]
+
+    m3 = Sequel::Plugins.def_sequel_method(@m, "x", 0){|x=5| [x, 4]}
+    @scope.send(m3).must_equal [5, 4]
+
+    m4 = Sequel::Plugins.def_sequel_method(@m, "x", 0){|x=6, *y| [x, y, 5]}
+    @scope.send(m4).must_equal [6, [], 5]
+  end
+
+  it "should should optional arguments and splats for expected_arity 1" do
+    m2 = Sequel::Plugins.def_sequel_method(@m, "x", 1){|y, *x| [y, x, 3]}
+    @scope.send(m2, :a).must_equal [:a, [], 3]
+
+    m3 = Sequel::Plugins.def_sequel_method(@m, "x", 1){|y, x=5| [y, x, 4]}
+    @scope.send(m3, :b).must_equal [:b, 5, 4]
+
+    m4 = Sequel::Plugins.def_sequel_method(@m, "x", 1){|y, x=6, *z| [y, x, z, 5]}
+    @scope.send(m4, :c).must_equal [:c, 6, [], 5]
+  end
+
+  deprecated "should handle differences in arity" do
+    m0 = Sequel::Plugins.def_sequel_method(@m, "x", 0){|x| [x, 1]}
+    @scope.send(m0).must_equal [nil, 1]
+
+    m1 = Sequel::Plugins.def_sequel_method(@m, "x", 1){2}
+    @scope.send(m1, 3).must_equal 2
+
+    m1 = Sequel::Plugins.def_sequel_method(@m, "x", 1){|x, y| [x, y]}
+    @scope.send(m1, 4).must_equal [4, nil]
+  end
+
+  it "should raise for unexpected expected_arity" do
+    proc{Sequel::Plugins.def_sequel_method(@m, "x", 2){|x|}}.must_raise Sequel::Error
+  end
+
+  it "should fail if a lambda with invalid arity is passed" do
+    m0 = Sequel::Plugins.def_sequel_method(@m, "x", 0, &lambda{|x| [x, 1]})
+    proc{@scope.send(m0)}.must_raise ArgumentError
+
+    m1 = Sequel::Plugins.def_sequel_method(@m, "x", 1, &lambda{2})
+    proc{@scope.send(m1, 1)}.must_raise ArgumentError
+  end
+
+  if RUBY_VERSION > '2.1'
+    it "should raise for required keyword arguments for expected_arity 0 or 1" do
+      proc{eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|b:| [b, 1]}", binding)}.must_raise Sequel::Error
+      proc{eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|c=1, b:| [c, b, 1]}", binding)}.must_raise Sequel::Error
+      proc{eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|x, b:| [b, 1]}", binding)}.must_raise Sequel::Error
+      proc{eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|x, c=1, b:| [c, b, 1]}", binding)}.must_raise Sequel::Error
+    end
+
+    it "should ignore keyword arguments for expected_arity 0" do
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|b:2| [b, 1]}", binding)).must_equal [2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|**b| [b, 1]}", binding)).must_equal [{}, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|c=1, b:2| [c, b, 1]}", binding)).must_equal [1, 2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|c=1, **b| [c, b, 1]}", binding)).must_equal [1, {}, 1]
+    end
+
+    deprecated "should ignore keyword arguments for expected_arity 0 with invalid arity" do
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|x, b:2| [x, b, 1]}", binding)).must_equal [nil, 2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|x, **b| [x, b, 1]}", binding)).must_equal [nil, {}, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|x, c=1, b:2| [x, c, b, 1]}", binding)).must_equal [nil, 1, 2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 0){|x, c=1, **b| [x, c, b, 1]}", binding)).must_equal [nil, 1, {}, 1]
+    end
+
+    deprecated "should ignore keyword arguments for expected_arity 1 with invalid arity" do
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|b:2| [b, 1]}", binding), 3).must_equal [2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|**b| [b, 1]}", binding), 3).must_equal [{}, 1]
+    end
+
+    it "should ignore keyword arguments for expected_arity 1" do
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|c=1, b:2| [c, b, 1]}", binding), 3).must_equal [3, 2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|c=1, **b| [c, b, 1]}", binding), 3).must_equal [3, {}, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|x, b:2| [x, b, 1]}", binding), 3).must_equal [3, 2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|x, **b| [x, b, 1]}", binding), 3).must_equal [3, {}, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|x, c=1, b:2| [x, c, b, 1]}", binding), 3).must_equal [3, 1, 2, 1]
+      @scope.send(eval("Sequel::Plugins.def_sequel_method(@m, 'x', 1){|x, c=1, **b| [x, c, b, 1]}", binding), 3).must_equal [3, 1, {}, 1]
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.18.0
+  version: 5.20.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-01 00:00:00.000000000 Z
+date: 2019-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -202,6 +202,8 @@ extra_rdoc_files:
 - doc/release_notes/5.16.0.txt
 - doc/release_notes/5.17.0.txt
 - doc/release_notes/5.18.0.txt
+- doc/release_notes/5.19.0.txt
+- doc/release_notes/5.20.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -290,7 +292,9 @@ files:
 - doc/release_notes/5.16.0.txt
 - doc/release_notes/5.17.0.txt
 - doc/release_notes/5.18.0.txt
+- doc/release_notes/5.19.0.txt
 - doc/release_notes/5.2.0.txt
+- doc/release_notes/5.20.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.5.0.txt
@@ -845,7 +849,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby