linkage 0.0.0

data/test/unit/test_import_buffer.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class UnitTests::TestImportBuffer < Test::Unit::TestCase
+  test "basic usage" do
+    buf = Linkage::ImportBuffer.new('foo:/bar/db', 'baz_table', [:qux, :thud])
+    buf.add([123, 456])
+    buf.add(['test', 'junk'])
+
+    database = mock('database')
+    Sequel.expects(:connect).with('foo:/bar/db', {}).yields(database)
+    dataset = mock('dataset')
+    database.expects(:[]).with(:baz_table).returns(dataset)
+    dataset.expects(:import).with([:qux, :thud], [[123, 456], ['test', 'junk']])
+    buf.flush
+  end
+
+  test "flush performs a no-op when buffer is empty" do
+    Sequel.expects(:connect).never
+    buf = Linkage::ImportBuffer.new('foo:/bar/db', 'baz_table', [:qux, :thud])
+    buf.flush
+  end
+
+  test "auto-flush" do
+    uri = 'foo:/bar/db'
+    table = 'baz_table'
+    headers = [:qux, :thud]
+    limit = 3
+    buf = Linkage::ImportBuffer.new(uri, table, headers, {}, limit)
+    2.times { |i| buf.add([123, 456]) }
+
+    database = mock('database')
+    Sequel.expects(:connect).with('foo:/bar/db', {}).yields(database)
+    dataset = mock('dataset')
+    database.expects(:[]).with(:baz_table).returns(dataset)
+    dataset.expects(:import).with([:qux, :thud], [[123, 456], [123, 456], ['test', 'junk']])
+    buf.add(['test', 'junk'])
+  end
+
+  test "accepts Sequel.connect options" do
+    buf = Linkage::ImportBuffer.new('foo:/bar/db', 'baz_table', [:qux, :thud], :foo => 123)
+    buf.add([123, 456])
+    buf.add(['test', 'junk'])
+
+    database = mock('database')
+    Sequel.expects(:connect).with('foo:/bar/db', :foo => 123).yields(database)
+    dataset = mock('dataset')
+    database.expects(:[]).with(:baz_table).returns(dataset)
+    dataset.expects(:import).with([:qux, :thud], [[123, 456], ['test', 'junk']])
+    buf.flush
+  end
+end

data/test/unit/test_linkage.rb

@@ -0,0 +1,6 @@
+require 'helper'
+
+module UnitTests
+  class TestLinkage < Test::Unit::TestCase
+  end
+end

data/test/unit/test_runner.rb

@@ -0,0 +1,14 @@
+require 'helper'
+
+class UnitTests::TestRunner < Test::Unit::TestCase
+  test "initialization" do
+    conf = stub("configuration")
+    runner = Linkage::Runner.new(conf, "foo:/results")
+  end
+
+  test "execute raises error" do
+    conf = stub("configuration")
+    runner = Linkage::Runner.new(conf, "foo:/results")
+    assert_raise_kind_of(NotImplementedError) { runner.execute }
+  end
+end

data/test/unit/test_single_threaded_runner.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class UnitTests::TestSingleThreadedRunner < Test::Unit::TestCase
+  test "subclass of Runner" do
+    assert_equal Linkage::Runner, Linkage::SingleThreadedRunner.superclass
+  end
+
+  test "defines execute" do
+    methods = Linkage::SingleThreadedRunner.public_instance_methods(false)
+    assert methods.include?(:execute) || methods.include?("execute")
+  end
+end

data/test/unit/test_utils.rb

@@ -0,0 +1,341 @@
+require 'helper'
+
+class UnitTests::TestUtils < Test::Unit::TestCase
+  include Linkage::Utils
+
+  test "merge two identical primary keys" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => Integer, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two boolean fields" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => TrueClass, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and an integer field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => Integer, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a bignum field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => Bignum, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a float field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => Float, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a decimal field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a decimal field with size" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a text field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:text => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a boolean field and a fixed string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two integer fields" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => Integer, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a bignum field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => Bignum, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a float field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => Float, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a decimal field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a decimal field with size" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a text field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:text => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an integer field and a fixed string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two bignum fields" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    expected = {:type => Bignum, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an bignum field and a decimal field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an bignum field and a decimal field with size" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an bignum field and a string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an bignum field and a text field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:text => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge an bignum field and a fixed string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two float fields" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => Float, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a float field and a bignum field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a float field and a decimal field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a float field and a decimal field with size" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a float field and a string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a float field and a text field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:text => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a float field and a fixed string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two decimal fields" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two decimal fields, one with size" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two decimal fields, both with size" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,1)", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [12, 2]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two decimal fields, both with size, one without scale" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10)", :type=>:decimal, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,1)", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => BigDecimal, :opts => {:size => [12, 1]}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a decimal field and a string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a decimal field with size and a string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,2)", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 13}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a decimal field and a text field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:text => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a decimal field with size and a text field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,2)", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:text => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge a decimal field and a fixed string field" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two string fields" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(20)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(20)", :type=>:string, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 20}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+
+  test "merge two string fields with different sizes" do
+    field_1 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(15)", :type=>:string, :ruby_default=>nil}
+    field_2 = {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(20)", :type=>:string, :ruby_default=>nil}
+    expected = {:type => String, :opts => {:size => 20}}
+    assert_equal(expected, merge_fields(field_1, field_2))
+    assert_equal(expected, merge_fields(field_2, field_1))
+  end
+end

metadata

@@ -0,0 +1,272 @@
+--- !ruby/object:Gem::Specification 
+name: linkage
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Jeremy Stephens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id001
+  name: sequel
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  version_requirements: *id002
+  name: bundler
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 6
+        - 4
+        version: 1.6.4
+  version_requirements: *id003
+  name: jeweler
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id004
+  name: rcov
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id005
+  name: guard-test
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 3
+        - 2
+        version: 2.3.2
+  version_requirements: *id006
+  name: test-unit
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id007
+  name: mocha
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id008
+  name: sqlite3
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id009
+  name: yard
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id010
+  name: rake
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id011
+  name: versionomy
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id012 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id012
+  name: guard-yard
+  prerelease: false
+  type: :development
+description: Wraps Sequel to perform record linkage between one or two datasets
+email: jeremy.f.stephens@vanderbilt.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.markdown
+files: 
+- .document
+- .vimrc
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- lib/linkage.rb
+- lib/linkage/configuration.rb
+- lib/linkage/dataset.rb
+- lib/linkage/expectation.rb
+- lib/linkage/field.rb
+- lib/linkage/group.rb
+- lib/linkage/import_buffer.rb
+- lib/linkage/runner.rb
+- lib/linkage/runner/single_threaded.rb
+- lib/linkage/utils.rb
+- linkage.gemspec
+- test/helper.rb
+- test/integration/test_cross_linkage.rb
+- test/integration/test_dual_linkage.rb
+- test/integration/test_self_linkage.rb
+- test/unit/test_configuration.rb
+- test/unit/test_dataset.rb
+- test/unit/test_expectation.rb
+- test/unit/test_field.rb
+- test/unit/test_group.rb
+- test/unit/test_import_buffer.rb
+- test/unit/test_linkage.rb
+- test/unit/test_runner.rb
+- test/unit/test_single_threaded_runner.rb
+- test/unit/test_utils.rb
+homepage: http://github.com/coupler/linkage
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Sequel-based record linkage
+test_files: []
+