linkage 0.1.0.pre → 0.1.0

data/test/unit/score_sets/test_database.rb

@@ -4,6 +4,54 @@ class UnitTests::TestScoreSets::TestDatabase < Test::Unit::TestCase
   def setup
     @dataset = stub('dataset')
     @database = stub('database', :[] => @dataset)
+    Sequel::Database.stubs(:===).with(@database).returns(true)
+  end
+
+  test "open_for_writing with uri string" do
+    Sequel.expects(:connect).with('foo://bar').returns(@database)
+    score_set = Linkage::ScoreSets::Database.new('foo://bar')
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing with database object" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing with filename option" do
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => 'foo.db').returns(@database)
+    score_set = Linkage::ScoreSets::Database.new(:filename => 'foo.db')
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing with default options" do
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => 'scores.db').returns(@database)
+    score_set = Linkage::ScoreSets::Database.new
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing with directory option" do
+    expected_directory = File.expand_path('foo')
+    FileUtils.expects(:mkdir_p).with(expected_directory)
+    expected_filename = File.join(expected_directory, 'scores.db')
+    Sequel.expects(:connect).with(:adapter => :sqlite, :database => expected_filename).returns(@database)
+    score_set = Linkage::ScoreSets::Database.new(:dir => 'foo')
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
   end
 
   test "open_for_writing for database with no scores table" do
@@ -106,7 +154,6 @@ class UnitTests::TestScoreSets::TestDatabase < Test::Unit::TestCase
   test "each_pair" do
     score_set = Linkage::ScoreSets::Database.new(@database)
     @database.stubs(:table_exists?).with(:scores).returns(true)
-    score_set.open_for_reading
 
     @dataset.expects(:order).with(:id_1, :id_2, :comparator_id).returns(@dataset)
     @dataset.expects(:each).multiple_yields(
@@ -119,7 +166,9 @@ class UnitTests::TestScoreSets::TestDatabase < Test::Unit::TestCase
       [{:comparator_id => 3, :id_1 => '4', :id_2 => '5', :score => 0}]
     )
     pairs = []
+    score_set.open_for_reading
     score_set.each_pair { |*args| pairs << args }
+    score_set.close
     assert_equal 4, pairs.length
 
     pair_1 = pairs.detect { |pair| pair[0] == "1" && pair[1] == "2" }
@@ -143,6 +192,13 @@ class UnitTests::TestScoreSets::TestDatabase < Test::Unit::TestCase
     assert_equal expected_4, pair_4[2]
   end
 
+  test "each_pair when not open for reading" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    assert_raise_message("not in read mode") do
+      score_set.each_pair { |*args| }
+    end
+  end
+
   test "registers itself" do
     assert_equal Linkage::ScoreSets::Database, Linkage::ScoreSet['database']
   end

data/test/unit/test_comparator.rb

@@ -84,4 +84,12 @@ class UnitTests::TestComparator < Test::Unit::TestCase
     observer.expects(:update).with(instance, record_1, record_2, 1)
     instance.score_and_notify(record_1, record_2)
   end
+
+  test "weigh requires numeric types" do
+    comparator = Linkage::Comparator.new
+    weight = stub('weight', :name => :foo, :ruby_type => { :type => String })
+    assert_raises do
+      comparator.weigh(weight)
+    end
+  end
 end

data/test/unit/test_configuration.rb

@@ -5,12 +5,12 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
     @pk_1 = stub('primary key 1', :name => :id)
     @field_1 = stub('field 1')
     @field_set_1 = stub('field set 1', :primary_key => @pk_1, :[] => @field_1)
-    @dataset_1 = stub('dataset 1', :field_set => @field_set_1)
+    @dataset_1 = stub_dataset(:field_set => @field_set_1)
     @pk_2 = stub('primary key 2', :name => :id)
     @field_2 = stub('field 2')
     @field_set_2 = stub('field set 2', :primary_key => @pk_2, :[] => @field_2)
-    @dataset_2 = stub('dataset 2', :field_set => @field_set_2)
-    @score_set = stub('score set')
+    @dataset_2 = stub_dataset(:field_set => @field_set_2)
+    @score_set = stub_instance(Linkage::ScoreSet)
     @match_set = stub('match set')
     @result_set = stub('result set', :score_set => @score_set, :match_set => @match_set)
     @compare = stub('compare')
@@ -24,6 +24,14 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
     assert_equal @result_set, config.result_set
   end
 
+  test "init with single dataset, score set, and match set" do
+    Linkage::ResultSet.expects(:new).with(@score_set, @match_set).returns(@result_set)
+    config = Linkage::Configuration.new(@dataset_1, @score_set, @match_set)
+    assert_equal @dataset_1, config.dataset_1
+    assert_nil config.dataset_2
+    assert_equal @result_set, config.result_set
+  end
+
   test "init with two datasets and result set" do
     config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
     assert_equal @dataset_1, config.dataset_1
@@ -31,14 +39,23 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
     assert_equal @result_set, config.result_set
   end
 
+  test "init with two datasets, score set, and match set" do
+    Linkage::ResultSet.expects(:new).with(@score_set, @match_set).returns(@result_set)
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @score_set, @match_set)
+    assert_equal @dataset_1, config.dataset_1
+    assert_equal @dataset_2, config.dataset_2
+    assert_equal @result_set, config.result_set
+  end
+
   test "adding comparator with set arguments and two datasets" do
     config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
 
     @field_set_1.expects(:[]).with(:foo).returns(@field_1)
     @field_set_2.expects(:[]).with(:foo).returns(@field_2)
     Linkage::Comparators::Compare.expects(:new).with([@field_1], [@field_2], :equal).returns(@compare)
-    config.compare([:foo], [:foo], :equal)
+    comp = config.compare([:foo], [:foo], :equal)
     assert_equal @compare, config.comparators[0]
+    assert_equal config.comparators[0], comp
   end
 
   test "adding comparator with set arguments and one datasets" do
@@ -47,8 +64,9 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
     @field_set_1.expects(:[]).with(:foo).returns(@field_1)
     @field_set_1.expects(:[]).with(:bar).returns(@field_2)
     Linkage::Comparators::Compare.expects(:new).with([@field_1], [@field_2], :equal).returns(@compare)
-    config.compare([:foo], [:bar], :equal)
+    comp = config.compare([:foo], [:bar], :equal)
     assert_equal @compare, config.comparators[0]
+    assert_equal config.comparators[0], comp
   end
 
   test "adding comparator with scalar arguments and two datasets" do
@@ -58,8 +76,9 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
     @field_set_2.expects(:[]).with(:foo).returns(@field_2)
     within = stub('within')
     Linkage::Comparators::Within.expects(:new).with(@field_1, @field_2, 5).returns(within)
-    config.within(:foo, :foo, 5)
+    comp = config.within(:foo, :foo, 5)
     assert_equal within, config.comparators[0]
+    assert_equal config.comparators[0], comp
   end
 
   test "score_recorder with two datasets" do
@@ -115,6 +134,14 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
     assert_equal matcher, config.matcher
   end
 
+  test "threshold requires numeric types" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+    config.compare([:foo], [:bar], :equal)
+    assert_raises do
+      config.threshold = 'dog'
+    end
+  end
+
   test "match_recorder" do
     config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
 

data/test/unit/test_dataset.rb

@@ -71,13 +71,6 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert_equal @schema, ds.schema
   end
 
-  test "database_type" do
-    ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.stubs(:db).returns(@database)
-    @database.expects(:database_type).returns(:foo)
-    assert_equal :foo, ds.database_type
-  end
-
   test "primary key" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
     pk = stub('primary key field')

data/test/unit/test_matcher.rb

@@ -3,7 +3,7 @@ require 'helper'
 class UnitTests::TestMatcher < Test::Unit::TestCase
   def setup
     @score_set = stub('score set')
-    @comparators = [stub('comparator 1'), stub('comparator 2'), stub('comparator 3')]
+    @comparators = [stub('comparator 1', :weight => nil), stub('comparator 2', :weight => nil), stub('comparator 3', :weight => nil)]
   end
 
   test "finding matches with mean and threshold" do
@@ -19,7 +19,10 @@ class UnitTests::TestMatcher < Test::Unit::TestCase
       [3, 4, {1 => 0, 2 => 1, 3 => 1}],
       [4, 5, {1 => 1, 2 => 1, 3 => 1}]
     ]
-    @score_set.expects(:each_pair).multiple_yields(*pairs)
+    seq = sequence("mean")
+    @score_set.expects(:open_for_reading).in_sequence(seq)
+    @score_set.expects(:each_pair).multiple_yields(*pairs).in_sequence(seq)
+    @score_set.expects(:close).in_sequence(seq)
 
     matcher.run
   end
@@ -37,7 +40,53 @@ class UnitTests::TestMatcher < Test::Unit::TestCase
       [3, 4, {2 => 1, 3 => 1}],
       [4, 5, {1 => 1, 2 => 1, 3 => 1}]
     ]
-    @score_set.expects(:each_pair).multiple_yields(*pairs)
+    seq = sequence("mean")
+    @score_set.expects(:open_for_reading).in_sequence(seq)
+    @score_set.expects(:each_pair).multiple_yields(*pairs).in_sequence(seq)
+    @score_set.expects(:close).in_sequence(seq)
+
+    matcher.run
+  end
+
+  test "finding matches with sum and threshold with missing scores" do
+    matcher = Linkage::Matcher.new(@comparators, @score_set, :sum, 2)
+    observer = stub('observer')
+    observer.expects(:update).with(3, 4, 2)
+    observer.expects(:update).with(4, 5, 3)
+    matcher.add_observer(observer)
+
+    pairs = [
+      [1, 2, {1 => 1, 3 => 0}],
+      [2, 3, {1 => 0, 2 => 0, 3 => 0}],
+      [3, 4, {2 => 1, 3 => 1}],
+      [4, 5, {1 => 1, 2 => 1, 3 => 1}]
+    ]
+    seq = sequence("sum")
+    @score_set.expects(:open_for_reading).in_sequence(seq)
+    @score_set.expects(:each_pair).multiple_yields(*pairs).in_sequence(seq)
+    @score_set.expects(:close).in_sequence(seq)
+
+    matcher.run
+  end
+
+  test "finding weighted matches with sum and threshold with missing scores" do
+    comparators = [stub('comparator 1', :weight => 0.50), stub('comparator 2', :weight => 0.25), stub('comparator 3', :weight => 0.25)]
+    matcher = Linkage::Matcher.new(comparators, @score_set, :sum, 0.75)
+    observer = stub('observer')
+    observer.expects(:update).with(1, 2, 0.75)
+    observer.expects(:update).with(4, 5, 1)
+    matcher.add_observer(observer)
+
+    pairs = [
+      [1, 2, {1 => 1, 3 => 1}],
+      [2, 3, {1 => 0, 2 => 0, 3 => 0}],
+      [3, 4, {2 => 1, 3 => 1}],
+      [4, 5, {1 => 1, 2 => 1, 3 => 1}]
+    ]
+    seq = sequence("sum")
+    @score_set.expects(:open_for_reading).in_sequence(seq)
+    @score_set.expects(:each_pair).multiple_yields(*pairs).in_sequence(seq)
+    @score_set.expects(:close).in_sequence(seq)
 
     matcher.run
   end

data/test/unit/test_result_set.rb

@@ -1,18 +1,12 @@
 require 'helper'
 
 class TestResultSet < Test::Unit::TestCase
-  test "score_set raises NotImplementedError" do
-    result_set = Linkage::ResultSet.new
-    assert_raises(NotImplementedError) do
-      result_set.score_set
-    end
-  end
-
-  test "match_set raises NotImplementedError" do
-    result_set = Linkage::ResultSet.new
-    assert_raises(NotImplementedError) do
-      result_set.match_set
-    end
+  test "default result set" do
+    score_set = stub('score set')
+    match_set = stub('match set')
+    result_set = Linkage::ResultSet.new(score_set, match_set)
+    assert_same score_set, result_set.score_set
+    assert_same match_set, result_set.match_set
   end
 
   test "getting a registered class" do
@@ -23,14 +17,14 @@ class TestResultSet < Test::Unit::TestCase
 
   test "registered classes required to define score_set" do
     klass = new_result_set do
-      remove_method :score_set
+      undef :score_set
     end
     assert_raises(ArgumentError) { Linkage::ResultSet.register('foo', klass) }
   end
 
   test "registered classes required to define match_set" do
     klass = new_result_set do
-      remove_method :match_set
+      undef :match_set
     end
     assert_raises(ArgumentError) { Linkage::ResultSet.register('foo', klass) }
   end

metadata

@@ -1,167 +1,195 @@
 --- !ruby/object:Gem::Specification
 name: linkage
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre
+  version: 0.1.0
 platform: ruby
 authors:
 - Jeremy Stephens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-02 00:00:00.000000000 Z
+date: 2015-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: hashery
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: versionomy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard-redcarpet-ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Performs record linkage between one or two datasets, using Sequel on
@@ -172,10 +200,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .document
-- .gitignore
-- .vimrc
-- .yardopts
+- ".document"
+- ".gitignore"
+- ".vimrc"
+- ".yardopts"
 - Gemfile
 - Gemfile-java
 - Guardfile
@@ -194,6 +222,9 @@ files:
 - lib/linkage/exceptions.rb
 - lib/linkage/field.rb
 - lib/linkage/field_set.rb
+- lib/linkage/helpers.rb
+- lib/linkage/helpers/csv.rb
+- lib/linkage/helpers/database.rb
 - lib/linkage/import_buffer.rb
 - lib/linkage/match_recorder.rb
 - lib/linkage/match_set.rb
@@ -211,6 +242,9 @@ files:
 - lib/linkage/version.rb
 - linkage.gemspec
 - linkage.gemspec-java
+- misc/uml/linkage.dia
+- misc/uml/linkage.png
+- misc/uml/linkage.svg
 - test/config.yml
 - test/helper.rb
 - test/integration/test_cross_linkage.rb
@@ -255,17 +289,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Record linkage library