sequel_migration_builder 0.4.0 → 0.4.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzVhY2M3MmE2YWZmZTk2ZDZhNzhjN2JiOTc0YmQwM2FjOWUwYTRhYg==
+    NGRmODU3NzY1NDA1MGIyNjllMjE3ODA1ZjY0ZWIyNzE3MWRjMTdhZQ==
   data.tar.gz: !binary |-
-    ZWRlMDFiMTg1ZWZiNGYyMDQ5YTZkNzVjMWJjZTc5YjVkZWRmZjlkZA==
+    NDFiMmJkZjlkNDA2YTVlMTdkODExYzY2NzQ3Yzg2ZDk4MWVmOWQxYQ==
 SHA512:
   metadata.gz: !binary |-
-    MjE5OGMyMDA2ZWE5MGZhYmM2MWViNDYwMDVkZjk0YjQ5Nzk5NmYxNDcyZGU5
-    MmM1YTNhNjM1ZmQ4YWUwY2U4NmYzYTg1Y2ZmNmFmNWNlMjlkYTU1YmRkZTA0
-    NTNlNjY5Y2ZkZmQzMWM2YjBhZWQ0ZTk4NGViMTdhMTZlZmFhYWI=
+    MjNiZjk0NTA3MmUxYWYxMmIwZjY4MDcyNjgwYjBlY2Y1ZmNiMTI3ZDJhOTU5
+    M2RjZDI2MTc3MGU4ODVmNWQ5N2ZlYzEwMGY2NzIyODc1ZjViMDM2ZTI0MTVl
+    NGI0OWRiODQ0ZDEwYWM1NGY4NjhiMzg1MzJlMmU4NGQwYjlhY2I=
   data.tar.gz: !binary |-
-    ZTYzMmU1ZGZhMTRiYjY0N2ZhNDU1NTEyNTM3YmQ1MTI2ZjY3NTExYzc3Y2Vh
-    N2Q3MDY3Zjg0YmRkNTY4YWE4NTNjYmZkMTRkMzYzODUxODkxY2VhMTAzMjk2
-    YjcxMGYwYjBjNGE3NjFkMWNiZmM2NGM5ZjQ4Yzc3MzgxOWMyY2Q=
+    ZTVlYzE0YTViNjNmNDg5MTY4ODNmOTVhYTI4ZGY1NWFlZDQxYzA1MGFjMzdj
+    YjU4YzgxOTU2ZjYxYTcwNDVjNGM0ZDZiZDdkNzAyMzg5NDI2NzNmNTMwNDY3
+    OWE0YWNiMDlhZWM4MmU2MzY0MTQ1MWI0NWFlNGFkYTM1N2NiYzM=

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

data/lib/sequel/schema/db_schema_parser.rb

@@ -43,7 +43,7 @@ module Sequel
         db_schema.map do |column|
           type = parse_type(column.last[:db_type])
           DbColumn.build_from_hash(:name        => column.first,
-                                   :default     => column.last[:ruby_default] || column.last[:default],
+                                   :default     => extract_default(column),
                                    :null        => column.last[:allow_null],
                                    :column_type => type,
                                    :unsigned    => extract_unsigned(column.last[:db_type], type),
@@ -73,12 +73,21 @@ module Sequel
         case type
         when /^int/          then :integer
         when /^tinyint\(1\)/ then :boolean
+        when /^character varying/ then :varchar
+        when /^character/ then :char
+        when /^timestamp/ then :timestamp
+        when /^numeric\(\d+,\d+\)/ then :decimal
         when /^([^(]+)/      then $1.to_sym
         end
       end
 
       private
 
+      def extract_default(column)
+        default = column.last[:ruby_default] || column.last[:default]
+        default =~ /^"identity/ ? nil : default
+      end
+
       def extract_unsigned(db_type_string, type)
         return unless DbColumn::NUMERIC_TYPES.include?(type)
         db_type_string.include?(" unsigned")

data/sequel_migration_builder.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: sequel_migration_builder 0.4.0 ruby lib
+# stub: sequel_migration_builder 0.4.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "sequel_migration_builder"
-  s.version = "0.4.0"
+  s.version = "0.4.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Roland Swingler"]
-  s.date = "2014-09-01"
+  s.date = "2014-09-02"
   s.description = "Build Sequel Migrations based on the differences between two schemas"
   s.email = "roland.swingler@gmail.com"
   s.extra_rdoc_files = [

data/spec/alter_table_operations_spec.rb

@@ -13,7 +13,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     a = build_column(:name => :foo, :column_type => :integer)
     b = build_column(:name => :foo, :column_type => :integer)
 
-    @subject.build_column_operations(a,b).should == []
+    expect(@subject.build_column_operations(a,b)).to eql([])
   end
 
   it "should return a ChangeColumn operation if the types are different" do
@@ -21,7 +21,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :smallint)
     ops = @subject.build_column_operations(a,b)
 
-    ops.first.should == "set_column_type :foo, :smallint, :default => nil"
+    expect(ops.first).to eql("set_column_type :foo, :smallint, :default => nil")
   end
 
   it "should return a ChangeColumn operation if the sizes are different" do
@@ -29,7 +29,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :char, :size => 10)
     ops = @subject.build_column_operations(a,b)
 
-    ops.first.should == "set_column_type :foo, :char, :default => nil, :size => 10"
+    expect(ops.first).to eql("set_column_type :foo, :char, :default => nil, :size => 10")
   end
 
   it "should return a ChangeColumn operation if the unsigned value is different" do
@@ -37,7 +37,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :integer, :unsigned => false)
     ops = @subject.build_column_operations(a,b)
 
-    ops.first.should == "set_column_type :foo, :integer, :default => nil, :unsigned => false"
+    expect(ops.first).to eql("set_column_type :foo, :integer, :default => nil, :unsigned => false")
   end
 
   it "should return a ChangeColumn operation to set the null value if the null value is different" do
@@ -45,7 +45,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :integer, :null => false)
     ops = @subject.build_column_operations(a,b)
 
-    ops.first.should == "set_column_allow_null :foo, false"
+    expect(ops.first).to eql("set_column_allow_null :foo, false")
   end
 
   it "should return a ChangeColumn operation to set the default if the default value is different" do
@@ -53,7 +53,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :integer, :default => 2)
     ops = @subject.build_column_operations(a,b)
 
-    ops.first.should == "set_column_default :foo, 2"
+    expect(ops.first).to eql("set_column_default :foo, 2")
   end
 
   it "should only return 1 operation if the default and other values are different" do
@@ -61,8 +61,8 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :smallint, :default => 2)
     ops = @subject.build_column_operations(a,b)
 
-    ops.size.should == 1
-    ops.first.should == "set_column_type :foo, :smallint, :default => 2"
+    expect(ops.size).to eql(1)
+    expect(ops.first).to eql("set_column_type :foo, :smallint, :default => 2")
   end
 
   it "should return a ChangeColumn operation if the elements are different" do
@@ -70,7 +70,7 @@ describe "Sequel::Schema::AlterTableOperations#build_column_operations" do
     b = build_column(:name => :foo, :column_type => :enum, :elements => ["A", "B"])
     ops = @subject.build_column_operations(a,b)
 
-    ops.first.should == "set_column_type :foo, :enum, :default => nil, :elements => [\"A\", \"B\"]"
+    expect(ops.first).to eql("set_column_type :foo, :enum, :default => nil, :elements => [\"A\", \"B\"]")
   end
 end
 
@@ -82,7 +82,7 @@ describe "Sequel::Schema::AlterTableOperations.build" do
       :columns => [build_column(:name => :foo, :column_type => :integer)]}
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
-    ops.should == []
+    expect(ops).to eql([])
   end
 
   it "should return an add column operation if the column is new" do
@@ -92,8 +92,8 @@ describe "Sequel::Schema::AlterTableOperations.build" do
       :columns => [build_column(:name => :foo, :column_type => :integer)]}
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
-    ops.size.should == 1
-    ops.first.should =~ /add_column/
+    expect(ops.size).to eql(1)
+    expect(ops.first).to match(/add_column/)
   end
 
   it "should return a drop column operation if the column has been removed" do
@@ -103,8 +103,8 @@ describe "Sequel::Schema::AlterTableOperations.build" do
       :columns => []}
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
-    ops.size.should == 1
-    ops.first.should =~ /drop_column/
+    expect(ops.size).to eql(1)
+    expect(ops.first).to match(/drop_column/)
   end
 
   it "should return a change column operation if columns are different" do
@@ -114,8 +114,8 @@ describe "Sequel::Schema::AlterTableOperations.build" do
       :columns => [build_column(:name => :foo, :column_type => :smallint)]}
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
-    ops.size.should == 1
-    ops.first.should =~ /set_column/
+    expect(ops.size).to eql(1)
+    expect(ops.first).to match(/set_column/)
   end
 
   it "should not output a drop index statement in #change if the index's column is also removed" do
@@ -125,7 +125,7 @@ describe "Sequel::Schema::AlterTableOperations.build" do
     table_b = {:name => :example_table, :indexes => {}, :columns => []}
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
 
-    ops.last.should be_nil
+    expect(ops.last).to be_nil
   end
 
   it "should not output an add_index statement if there is nothing to be done" do
@@ -135,6 +135,6 @@ describe "Sequel::Schema::AlterTableOperations.build" do
     table_b = {:name => :example_table, :indexes => {:foo_idx => {:columns => [:foo]}}, :columns => []}
 
     ops = Sequel::Schema::AlterTableOperations.build(table_a,table_b)
-    ops.should == []
+    expect(ops).to eql([])
   end
 end

data/spec/db_column_spec.rb

@@ -7,115 +7,114 @@ describe Sequel::Schema::DbColumn do
   end
 
   it "should return a #define_statement" do
-    @column.define_statement.should == "integer :foo, :null => false, :default => 10, :unsigned => true, :size => 10"
+    expect(@column.define_statement).to eql("integer :foo, :null => false, :default => 10, :unsigned => true, :size => 10")
   end
 
   it "should return a primary_key invocation if single_primary_key is set and the column is an integer" do
     @column.single_primary_key = true
-    @column.define_statement.should == "primary_key :foo, :type => :integer, :null => false, :default => 10, :unsigned => true, :size => 10"
+    expect(@column.define_statement).to eql("primary_key :foo, :type => :integer, :null => false, :default => 10, :unsigned => true, :size => 10")
   end
 
   it "should return a #drop_statement" do
-    @column.drop_statement.should == "drop_column :foo"
+    expect(@column.drop_statement).to eql("drop_column :foo")
   end
 
   it "should return an #add_statement" do
-    @column.add_statement.should == "add_column :foo, :integer, :null => false, :default => 10, :unsigned => true, :size => 10"
+    expect(@column.add_statement).to eql("add_column :foo, :integer, :null => false, :default => 10, :unsigned => true, :size => 10")
   end
 
   it "should return a #change_null statement" do
-    @column.change_null_statement.should == "set_column_allow_null :foo, false"
+    expect(@column.change_null_statement).to eql("set_column_allow_null :foo, false")
   end
 
   it "should return a #change_default statement" do
-    @column.change_default_statement.should == "set_column_default :foo, 10"
+    expect(@column.change_default_statement).to eql("set_column_default :foo, 10")
   end
 
   it "should return a #change_type statement" do
-    @column.change_type_statement.should == "set_column_type :foo, :integer, :default => 10, :unsigned => true, :size => 10"
+    expect(@column.change_type_statement).to eql("set_column_type :foo, :integer, :default => 10, :unsigned => true, :size => 10")
   end
 
   it "should be diffable with another DbColumn" do
     other = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
-    @column.diff(other).should == [:column_type].to_set
+    expect(@column.diff(other)).to eql([:column_type].to_set)
 
     other = Sequel::Schema::DbColumn.new(:foo, :integer, true, 11, true, 10, nil)
-    @column.diff(other).should == [:null, :default].to_set
+    expect(@column.diff(other)).to eql([:null, :default].to_set)
   end
 
   it "should not consider allowing null being nil different from false" do
     a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :smallint, nil, 10, true, 10, nil)
-    a.diff(b).should be_empty
-    b.diff(a).should be_empty
+    expect(a.diff(b)).to be_empty
+    expect(b.diff(a)).to be_empty
   end
 
   it "should not consider size to be different if one of the sizes is nil" do
     a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 10, true, nil, nil)
-    a.diff(b).should be_empty
-    b.diff(a).should be_empty
+    expect(a.diff(b)).to be_empty
+    expect(b.diff(a)).to be_empty
   end
 
   it "should not consider 0 to be different from null if the column does not allow nulls" do
     a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 0, true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :smallint, false, nil, true, nil, nil)
-    a.diff(b).should be_empty
-    b.diff(a).should be_empty
+    expect(a.diff(b)).to be_empty
+    expect(b.diff(a)).to be_empty
   end
 
   it "should consider 0 to be different from null if the column does allow nulls" do
     a = Sequel::Schema::DbColumn.new(:foo, :smallint, true, 0, true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :smallint, true, nil, true, nil, nil)
-    a.diff(b).should == [:default].to_set
-    b.diff(a).should == [:default].to_set
+    expect(a.diff(b)).to eql([:default].to_set)
+    expect(b.diff(a)).to eql([:default].to_set)
   end
 
   it "should consider 1 to be different from null" do
     a = Sequel::Schema::DbColumn.new(:foo, :smallint, false, 1, true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :smallint, false, nil, true, nil, nil)
-    a.diff(b).should == [:default].to_set
-    b.diff(a).should == [:default].to_set
+    expect(a.diff(b)).to eql([:default].to_set)
+    expect(b.diff(a)).to eql([:default].to_set)
   end
 
   it "should not consider '' to be different from null if the column does not allow nulls" do
     a = Sequel::Schema::DbColumn.new(:foo, :varchar, false, '', true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :varchar, false, nil, true, nil, nil)
-    a.diff(b).should be_empty
-    b.diff(a).should be_empty
+    expect(a.diff(b)).to be_empty
+    expect(b.diff(a)).to be_empty
   end
 
   it "should consider '' to be different from null if the column allows null" do
     a = Sequel::Schema::DbColumn.new(:foo, :varchar, true, '', true, 10, nil)
     b = Sequel::Schema::DbColumn.new(:foo, :varchar, true, nil, true, nil, nil)
-    a.diff(b).should == [:default].to_set
-    b.diff(a).should == [:default].to_set
+    expect(a.diff(b)).to eql([:default].to_set)
+    expect(b.diff(a)).to eql([:default].to_set)
   end
 
   it "should consider columns with different elements to be different" do
     a = Sequel::Schema::DbColumn.new(:foo, :enum, true, nil, true, nil, ["A"])
     b = Sequel::Schema::DbColumn.new(:foo, :enum, true, nil, true, nil, ["A", "B"])
-    a.diff(b).should == [:elements].to_set
-    b.diff(a).should == [:elements].to_set
+    expect(a.diff(b)).to eql([:elements].to_set)
+    expect(b.diff(a)).to eql([:elements].to_set)
   end
 
   it "should cast decimal defaults to the correct number" do
     a = Sequel::Schema::DbColumn.new(:foo, :decimal, true, '0.00', true, [4,2], nil)
     b = Sequel::Schema::DbColumn.new(:foo, :decimal, true, 0, true, [4,2], nil)
 
-    a.diff(b).should == Set.new
-    b.diff(a).should == Set.new
+    expect(a.diff(b)).to eql(Set.new)
+    expect(b.diff(a)).to eql(Set.new)
   end
 
   it "should output BigDecimal correctly in a  #define_statement" do
-    Sequel::Schema::DbColumn.new(:foo, :decimal, false, '1.1', true, [4,2], nil).
-      define_statement.should == "decimal :foo, :null => false, :default => BigDecimal.new('1.1'), :unsigned => true, :size => [4, 2]"
+    expect(Sequel::Schema::DbColumn.new(:foo, :decimal, false, '1.1', true, [4,2], nil).define_statement).to eql("decimal :foo, :null => false, :default => BigDecimal.new('1.1'), :unsigned => true, :size => [4, 2]")
   end
   
   it "should be buildable from a Hash" do
-    Sequel::Schema::DbColumn.build_from_hash(:name => "foo", 
-                                             :column_type => "integer").column_type.should == "integer"
-    Sequel::Schema::DbColumn.build_from_hash('name' => "foo", 
-                                             'column_type' => "integer").name.should == "foo"
+    expect(Sequel::Schema::DbColumn.build_from_hash(:name => "foo", 
+                                             :column_type => "integer").column_type).to eql("integer")
+    expect(Sequel::Schema::DbColumn.build_from_hash('name' => "foo", 
+                                             'column_type' => "integer").name).to eql("foo")
   end
 end

data/spec/db_index_spec.rb

@@ -2,79 +2,74 @@ require File.dirname(__FILE__) + "/spec_helper"
 
 describe Sequel::Schema::DbIndex do
   it "should have a name" do
-    Sequel::Schema::DbIndex.new('foo_index', :foo).name.should == :foo_index
+    expect(Sequel::Schema::DbIndex.new('foo_index', :foo).name).to eql(:foo_index)
   end
 
   it "can have columns" do
-    Sequel::Schema::DbIndex.new('foo_index', [:foo, :bar]).columns.should == [:foo, :bar]
+    expect(Sequel::Schema::DbIndex.new('foo_index', [:foo, :bar]).columns).to eql([:foo, :bar])
   end
 
   it "converts a single column symbol to a 1 element array of columns" do
-    Sequel::Schema::DbIndex.new('foo_index', :foo).columns.should == [:foo]
+    expect(Sequel::Schema::DbIndex.new('foo_index', :foo).columns).to eql([:foo])
   end
 
   it "is not unique by default" do
-    Sequel::Schema::DbIndex.new('foo_index', :foo).should_not be_unique
+    expect(Sequel::Schema::DbIndex.new('foo_index', :foo)).not_to be_unique
   end
 
   it "can be unique" do
-    Sequel::Schema::DbIndex.new('foo_index', :foo, true).should be_unique
+    expect(Sequel::Schema::DbIndex.new('foo_index', :foo, true)).to be_unique
   end
 
   it "should respond to multi_column?" do
-    Sequel::Schema::DbIndex.new('foo_index', :foo, true).should_not be_multi_column
-    Sequel::Schema::DbIndex.new('foo_index', [:foo, :bar], true).should be_multi_column
+    expect(Sequel::Schema::DbIndex.new('foo_index', :foo, true)).not_to be_multi_column
+    expect(Sequel::Schema::DbIndex.new('foo_index', [:foo, :bar], true)).to be_multi_column
   end
 
   it "should be equal when compared with ==" do
     i1 = Sequel::Schema::DbIndex.new('foo_idx', :foo, true)
 
-    i1.should == Sequel::Schema::DbIndex.new('foo_idx', :foo, true)
-    i1.should == Sequel::Schema::DbIndex.new('foo_idx', [:foo], true)
-    i1.should_not == Sequel::Schema::DbIndex.new('foo_idx', :foo, false)
-    i1.should_not == Sequel::Schema::DbIndex.new('foo', :foo, true)
-    i1.should_not == Sequel::Schema::DbIndex.new('foo_idx', :bar, true)
+    expect(i1).to eql(Sequel::Schema::DbIndex.new('foo_idx', :foo, true))
+    expect(i1).to eql(Sequel::Schema::DbIndex.new('foo_idx', [:foo], true))
+    expect(i1).to_not eql(Sequel::Schema::DbIndex.new('foo_idx', :foo, false))
+    expect(i1).to_not eql(Sequel::Schema::DbIndex.new('foo', :foo, true))
+    expect(i1).to_not eql(Sequel::Schema::DbIndex.new('foo_idx', :bar, true))
   end
 
   it "should be equal when compared with eql?" do
     i1 = Sequel::Schema::DbIndex.new('foo_idx', :foo, true)
 
-    i1.hash.should == Sequel::Schema::DbIndex.new('foo_idx', :foo, true).hash
-    i1.should be_eql(Sequel::Schema::DbIndex.new('foo_idx', :foo, true))
+    expect(i1.hash).to eql(Sequel::Schema::DbIndex.new('foo_idx', :foo, true).hash)
+    expect(i1).to be_eql(Sequel::Schema::DbIndex.new('foo_idx', :foo, true))
   end
 
   it "should ensure nil as unique is converted to false" do
-    ([Sequel::Schema::DbIndex.new(:foo_idx, :foo, :unique => nil)] - [Sequel::Schema::DbIndex.new(:foo_idx, :foo, :unique => false)]).should == []
+    expect(([Sequel::Schema::DbIndex.new(:foo_idx, :foo, :unique => nil)] - [Sequel::Schema::DbIndex.new(:foo_idx, :foo, :unique => false)])).to eql([])
   end
   
   it "can be built from a hash returned by Sequel::Database#indexes" do
     hsh = {:foo_idx => {:columns => [:foo], :unique => true}}
-    Sequel::Schema::DbIndex.build_from_hash(hsh).should ==
-      [Sequel::Schema::DbIndex.new(:foo_idx, :foo, true)]
+    expect(Sequel::Schema::DbIndex.build_from_hash(hsh)).
+      to eql([Sequel::Schema::DbIndex.new(:foo_idx, :foo, true)])
   end
 
   it "should have a define statement" do
-    Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).define_statement.should ==
-      "index :foo, :name => :foo_idx, :unique => true"
+    expect(Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).define_statement).to eql("index :foo, :name => :foo_idx, :unique => true")
   end
 
   it "should have a define statement for multiple columns" do
-    Sequel::Schema::DbIndex.new(:foo_idx, [:foo, :bar], true).define_statement.should ==
-      "index [:foo, :bar], :name => :foo_idx, :unique => true"
+    expect(Sequel::Schema::DbIndex.new(:foo_idx, [:foo, :bar], true).define_statement).to eql("index [:foo, :bar], :name => :foo_idx, :unique => true")
   end
 
   it "should not output the unique value if it is false" do
-    Sequel::Schema::DbIndex.new(:foo_idx, :foo).define_statement.should ==
-      "index :foo, :name => :foo_idx"
+    expect(Sequel::Schema::DbIndex.new(:foo_idx, :foo).define_statement).to eql("index :foo, :name => :foo_idx")
   end
 
   it "should have an add_index statement" do
-    Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).add_statement.should ==
-      "add_index :foo, :name => :foo_idx, :unique => true"
+    expect(Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).add_statement).to eql("add_index :foo, :name => :foo_idx, :unique => true")
   end
 
   it "should have an drop_index statement" do
-    Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).drop_statement.should ==
-      "drop_index :foo, :name => :foo_idx"
+    expect(Sequel::Schema::DbIndex.new(:foo_idx, :foo, true).drop_statement).to eql("drop_index :foo, :name => :foo_idx")
   end
 end

data/spec/db_schema_parser_spec.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__) + "/spec_helper"
 
 describe "Sequel::Schema::DbSchemaParser.for_db" do
   it "should return a DbSchemaParser" do
-    Sequel::Schema::DbSchemaParser.for_db(double(:database)).should \
-      be_kind_of(Sequel::Schema::DbSchemaParser)
+    expect(Sequel::Schema::DbSchemaParser.for_db(double(:database))).
+      to be_kind_of(Sequel::Schema::DbSchemaParser)
   end
 end
 
@@ -20,70 +20,80 @@ describe "A hash in the array returned by Sequel::Schema::DbSchemaParser#parse_t
   end
 
   it "should contain the :name of the column" do
-    @parser.parse_table_schema(@schema).first.name.should == :example_column
+    expect(@parser.parse_table_schema(@schema).first.name).to eql(:example_column)
   end
   
   it "should contain the ruby_default as the :default" do
-    @parser.parse_table_schema(@schema).first.default.should == 1
+    expect(@parser.parse_table_schema(@schema).first.default).to eql(1)
   end
   
   it "should contain whether the column can be :null" do
-    @parser.parse_table_schema(@schema).first.null.should == true
+    expect(@parser.parse_table_schema(@schema).first.null).to eql(true)
   end
   
   it "should contain a type of :integer given a int column" do
     set_db_type "int(11)"
-    @parser.parse_table_schema(@schema).first.column_type.should == :integer
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:integer)
   end
 
   it "should contain a type of :boolean given a tinyint(1) column" do
     set_db_type "tinyint(1)"
-    @parser.parse_table_schema(@schema).first.column_type.should == :boolean
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:boolean)
   end
 
   it "should contain a type of :tinyint given a tinyint column" do
     set_db_type "tinyint(4)"
-    @parser.parse_table_schema(@schema).first.column_type.should == :tinyint
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:tinyint)
   end
 
   it "should contain a type of :smallint given a smallint column" do
     set_db_type "smallint(5)"
-    @parser.parse_table_schema(@schema).first.column_type.should == :smallint
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:smallint)
   end
 
   it "should contain a type of :mediumint given a mediumint column" do
     set_db_type "mediumint(5)"
-    @parser.parse_table_schema(@schema).first.column_type.should == :mediumint
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:mediumint)
   end
 
   it "should contain a type of :bigint given a bigint column" do
     set_db_type "bigint(10)"
-    @parser.parse_table_schema(@schema).first.column_type.should == :bigint
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:bigint)
+  end
+
+  it "should contain a type of :decimal given a numeric(x,y) column" do
+    set_db_type "numeric(3,4)"
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:decimal)
+  end
+
+  it "should contain a type of :char given a character column" do
+    set_db_type "character(3)"
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:char)
   end
 
   it "should contain a :size attribute for text-like columns" do
     set_db_type "varchar(20)", :string
-    @parser.parse_table_schema(@schema).first.size.should == 20
+    expect(@parser.parse_table_schema(@schema).first.size).to eql(20)
   end
 
   it "should contain a :size attribute for decimal columns" do
     set_db_type "decimal(14,5)"
-    @parser.parse_table_schema(@schema).first.size.should == [14,5]
+    expect(@parser.parse_table_schema(@schema).first.size).to eql([14,5])
   end
 
   it "should contain a :size attribute for binary columns" do
     set_db_type "binary(16)", :blob
-    @parser.parse_table_schema(@schema).first.size.should == 16
+    expect(@parser.parse_table_schema(@schema).first.size).to eql(16)
   end
   
   it "should contain :unsigned false if a numeric column is not unsigned" do
     set_db_type "int(10)"
-    @parser.parse_table_schema(@schema).first.unsigned.should == false
+    expect(@parser.parse_table_schema(@schema).first.unsigned).to eql(false)
   end
 
   it "should contain :unsigned true if an integer column is unsigned" do
     set_db_type "int(10) unsigned"
-    @parser.parse_table_schema(@schema).first.unsigned.should == true
+    expect(@parser.parse_table_schema(@schema).first.unsigned).to eql(true)
   end
 
   it "should contain :unsigned true if a decimal column is unsigned" do
@@ -95,19 +105,35 @@ describe "A hash in the array returned by Sequel::Schema::DbSchemaParser#parse_t
                   :db_type => "decimal(10,2) unsigned", 
                   :allow_null => true   }]]
 
-    @parser.parse_table_schema(@schema).first.unsigned.should == true
+    expect(@parser.parse_table_schema(@schema).first.unsigned).to eql(true)
   end
 
   it "should not contain an :unsigned value if not a numeric column" do
     set_db_type "varchar(10)", :string
-    @parser.parse_table_schema(@schema).first.unsigned.should == nil
+    expect(@parser.parse_table_schema(@schema).first.unsigned).to eql(nil)
   end
 
   it "should contain the elements of an enum column" do
     set_db_type "enum('foo','bar')"
-    @parser.parse_table_schema(@schema).first.elements.should == ['foo', 'bar']
+    expect(@parser.parse_table_schema(@schema).first.elements).to eql(['foo', 'bar'])
   end
   
+  it "should be a varchar if the the db type is character varying" do
+    set_db_type "character varying"
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:varchar)
+  end
+
+  it "should be a timestamp if the the db type is a timestamp without time zone" do
+    set_db_type "timestamp without time zone"
+    expect(@parser.parse_table_schema(@schema).first.column_type).to eql(:timestamp)
+  end
+
+  it "should not have a default for postgres identity columns" do
+    @schema.first.last.merge!(:default => "\"identity\"(123,0)",
+                              :ruby_default => nil)
+    expect(@parser.parse_table_schema(@schema).first.default).to be_nil   
+  end
+
   def set_db_type(type, ruby_type=nil)
     @schema.first.last.merge!(:db_type => type)
     @schema.first.last.merge!(:type => ruby_type) if ruby_type
@@ -117,12 +143,12 @@ end
 describe "Sequel::Schema::DbSchemaParser#parse_db_schema" do
   it "should extract a list of table definitions from a database" do
     mock_db = double(:db)
-    mock_db.should_receive(:tables).at_least(:once).and_return([:table1])
-    mock_db.should_receive(:schema).with(:table1).and_return([])
-    mock_db.should_receive(:indexes).with(:table1, :partial => true)
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([:table1])
+    expect(mock_db).to receive(:schema).with(:table1).and_return([])
+    expect(mock_db).to receive(:indexes).with(:table1, :partial => true)
 
     @parser = Sequel::Schema::DbSchemaParser.for_db(mock_db)
-    @parser.parse_db_schema.keys.should == [:table1]
+    expect(@parser.parse_db_schema.keys).to eql([:table1])
   end
 end
 
@@ -139,7 +165,7 @@ describe "Parsing a text column" do
                  :db_type => "text", 
                  :allow_null => true   }]]
 
-    lambda { parser.parse_table_schema(schema) }.should_not raise_error
+    expect { parser.parse_table_schema(schema) }.not_to raise_error
   end
 end
 
@@ -154,7 +180,7 @@ describe "Parsing an enum column" do
                  :db_type => "enum('foo (bar)', 'baz')",
                  :allow_null => true   }]]
 
-    lambda { parser.parse_table_schema(schema) }.should_not raise_error
+    expect { parser.parse_table_schema(schema) }.not_to raise_error
   end
 
   it "should correctly parse elements with escaped '' in them" do
@@ -168,6 +194,6 @@ describe "Parsing an enum column" do
                  :allow_null => true   }]]
 
     
-    parser.parse_table_schema(schema).first.elements.should == ["don't"]
+    expect(parser.parse_table_schema(schema).first.elements).to eql(["don't"])
   end
 end

data/spec/migration_builder_spec.rb

@@ -4,8 +4,8 @@ describe Sequel::MigrationBuilder do
   
   it "should return nil if the table hash is empty and the database has no tables" do
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
-    Sequel::MigrationBuilder.new(mock_db).generate_migration({}).should be_nil
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
+    expect(Sequel::MigrationBuilder.new(mock_db).generate_migration({})).to be_nil
   end
 
   it "should produce a simple migration string given a database connection and a hash of tables" do
@@ -25,8 +25,8 @@ end
 END
     
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
-    Sequel::MigrationBuilder.new(mock_db).generate_migration(tables).should == expected
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
+    expect(Sequel::MigrationBuilder.new(mock_db).generate_migration(tables)).to eql(expected)
   end
 
   it "should produce statements for multiple new tables" do
@@ -55,13 +55,13 @@ end
 END
     
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
-    Sequel::MigrationBuilder.new(mock_db).generate_migration(tables).should == expected
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
+    expect(Sequel::MigrationBuilder.new(mock_db).generate_migration(tables)).to eql(expected)
   end
 
   it "should add the primary key of the table" do
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
     table = {
       :primary_key => :foo,
       :columns => [{:name => :foo, :column_type => :integer}, {:name => :bar, :column_type => :varchar}]
@@ -74,13 +74,12 @@ create_table :example_table do
 end
 END
 
-    Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n").
-      should == expected.strip
+    expect(Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n")).to eql(expected.strip)
   end
 
   it "should add the non-integer primary key of the table" do
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
     table = {
       :primary_key => :foo,
       :columns => [{:name => :foo, :column_type => :binary}, {:name => :bar, :column_type => :varchar}]
@@ -95,13 +94,12 @@ create_table :example_table do
 end
 END
 
-    Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n").
-      should == expected.strip
+    expect(Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n")).to eql(expected.strip)
   end
   
   it "should add the table options do the create_table statement" do
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
     table = {
       :table_options => {:engine => "myisam"},
       :columns => [{:name => :foo, :column_type => :integer}]
@@ -113,13 +111,12 @@ create_table :example_table, :engine => "myisam" do
 end
 END
 
-    Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n").
-      should == expected.strip
+    expect(Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n")).to eql(expected.strip)
   end
 
   it "should add indexes to the create_table statement" do
     mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([])
+    expect(mock_db).to receive(:tables).at_least(:once).and_return([])
     table = {
       :indexes => {:foo_index => {:columns => :foo, :unique => true}},
       :columns => [{:name => :foo, :column_type => :integer}]
@@ -133,8 +130,12 @@ create_table :example_table do
 end
 END
 
-    Sequel::MigrationBuilder.new(mock_db).create_table_statement(:example_table, table).join("\n").
-      should == expected.strip
+    result = Sequel::MigrationBuilder.
+      new(mock_db).
+      create_table_statement(:example_table, table).
+      join("\n")
+
+    expect(result).to eql(expected.strip)
   end
   
   context "when a table needs to be altered" do
@@ -144,9 +145,9 @@ END
           :columns => [{:name => :foo, :column_type => :integer}, {:name => :bar, :column_type => :varchar}]}
       }
       @mock_db = double(:database)
-      @mock_db.should_receive(:tables).at_least(:once).and_return([:example_table])
-      @mock_db.should_receive(:indexes).with(:example_table, :partial => true).and_return({})
-      @mock_db.should_receive(:schema).with(:example_table).and_return([[:foo, {:type => :integer, :db_type => "smallint(5) unsigned", :allow_null => true, :ruby_default => 10}]])
+      expect(@mock_db).to receive(:tables).at_least(:once).and_return([:example_table])
+      expect(@mock_db).to receive(:indexes).with(:example_table, :partial => true).and_return({})
+      expect(@mock_db).to receive(:schema).with(:example_table).and_return([[:foo, {:type => :integer, :db_type => "smallint(5) unsigned", :allow_null => true, :ruby_default => 10}]])
 
     end
 
@@ -161,8 +162,7 @@ change do
   end
 end
 END
-      Sequel::MigrationBuilder.new(@mock_db).
-        generate_migration_body(@tables).join("\n").should == expected.strip
+      expect(Sequel::MigrationBuilder.new(@mock_db).generate_migration_body(@tables).join("\n")).to eql(expected.strip)
     end
 
     it "should return separate alter table statements when option is set" do
@@ -185,8 +185,7 @@ change do
   end
 end
 END
-      Sequel::MigrationBuilder.new(@mock_db, :separate_alter_table_statements => true).
-        generate_migration_body(@tables).join("\n").should == expected.strip
+      expect(Sequel::MigrationBuilder.new(@mock_db, :separate_alter_table_statements => true).generate_migration_body(@tables).join("\n")).to eql(expected.strip)
     end
 
     it "should drop and add columns instead of changing them if immutable_columns is set" do
@@ -206,21 +205,7 @@ change do
   end
 end
 END
-      Sequel::MigrationBuilder.new(@mock_db, :separate_alter_table_statements => true, :immutable_columns => true).
-        generate_migration_body(tables).join("\n").should == expected.strip
+      expect(Sequel::MigrationBuilder.new(@mock_db, :separate_alter_table_statements => true, :immutable_columns => true).generate_migration_body(tables).join("\n")).to eql(expected.strip)
     end
   end
-
-  it "should drop the table if the table exists in the database but not the table hash" do
-    pending # Deal with in a later version.
-    mock_db = double(:database)
-    mock_db.should_receive(:tables).at_least(:once).and_return([:example_table])
-    
-    expected = <<-END
-change do
-  drop_table :example_table
-end
-END
-    Sequel::MigrationBuilder.new(mock_db).generate_up({}).join("\n").should == expected
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_migration_builder
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Roland Swingler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-01 00:00:00.000000000 Z
+date: 2014-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel