blackwinter-perseus_match 0.0.3

data/spec/perseus_match/list_spec.rb

@@ -0,0 +1,16 @@
+describe PerseusMatch::List, '::pair' do
+
+  before :all do
+    @phrases = %w[foo bar baz]
+    @size = @phrases.size
+  end
+
+  it 'should produce full list of pairs with correct size' do
+    PerseusMatch::List.pair(@phrases).size.should == @size ** 2
+  end
+
+  it 'should produce minimal list of pairs with correct size' do
+    PerseusMatch::List.pair(@phrases, {}, :minimal => true).size.should == (@size ** 2 - @size) / 2
+  end
+
+end

data/spec/perseus_match/token_set_spec.rb

@@ -0,0 +1,65 @@
+describe PerseusMatch::TokenSet, ' with lingo' do
+
+  before :each do
+    PerseusMatch::TokenSet.instance_variable_set(:@tokens, nil)
+  end
+
+  it 'should tokenize a string' do
+    PerseusMatch::TokenSet.tokenize('foo bar').should be_an_instance_of(PerseusMatch::TokenSet)
+  end
+
+  it 'should report strictly equal TokenSets as ==' do
+    PerseusMatch::TokenSet.new('foo bar').should == PerseusMatch::TokenSet.new('foo bar')
+  end
+
+  it 'should report strictly equal TokenSets as eql' do
+    PerseusMatch::TokenSet.new('foo bar').should be_eql(PerseusMatch::TokenSet.new('foo bar'))
+  end
+
+  it 'should report slightly equal TokenSets as ==' do
+    PerseusMatch::TokenSet.new('foo bar').should == PerseusMatch::TokenSet.new('Foo Bar')
+  end
+
+  it 'should *not* report slightly equal TokenSets as eql' do
+    PerseusMatch::TokenSet.new('foo bar').should_not be_eql(PerseusMatch::TokenSet.new('Foo Bar'))
+  end
+
+  it 'should include form in inspect' do
+    PerseusMatch::TokenSet.new('foo', []).inspect.to_s.should =~ /<foo>/
+  end
+
+end if LINGO_FOUND
+
+describe PerseusMatch::TokenSet, ' without lingo' do
+
+  before :each do
+    PerseusMatch::TokenSet.instance_variable_set(:@tokens, nil)
+  end
+
+  it 'should take a prepared file for tokenization' do
+    # prevent lingo from being used
+    lingo_base = LINGO_BASE.dup
+    LINGO_BASE.replace('')
+
+    temp = Tempfile.open('perseus_match_spec_tokens_temp') { |t|
+      t.puts *%w[<foo|?> <bar|?>]
+    }
+
+    path = temp.path
+    link = 'perseus.tokens'
+
+    Dir.chdir(File.dirname(path)) {
+      File.symlink(path, link)
+
+      PerseusMatch::TokenSet.tokenize('foo bar').should be_an_instance_of(PerseusMatch::TokenSet)
+
+      File.unlink(link)
+    }
+
+    temp.unlink
+
+    # reset lingo base
+    LINGO_BASE.replace(lingo_base)
+  end
+
+end

data/spec/perseus_match_spec.rb

@@ -0,0 +1,168 @@
+require 'rubygems'
+require 'nuggets/tempfile/open'
+require 'nuggets/util/i18n'
+
+describe PerseusMatch do
+
+  before :all do
+    @highly_similar = [
+      'Anbetung der Könige',
+      'Die Anbetung der Könige'
+    ]  # ok
+
+    @similar = [
+      # @highly_similar + ...
+      'Die Anbetung der Heiligen Drei Könige',
+      'dIE AnBeTuNg der heILIGen dREI KÖniGE'
+    ]  # ok
+
+    @unfortunately_similar = [
+      # @similar + ...
+      'Die Die Die Anbetung der Könige',
+      'Die Könige der Anbetung',
+      'Königsanbetung hoch drei'
+    ]  # *not* ok -- eventually try to drop these below the threshold
+
+    @somewhat_similar = @highly_similar + @similar + @unfortunately_similar
+
+    phrases = @somewhat_similar + [
+      'Drei mal drei macht sechs',
+      'Das Ende dieses Blödsinns',
+      ''
+    ]
+
+    temp = Tempfile.open('perseus_match_spec_temp') { |t|
+      t.puts *phrases
+    }
+
+    PerseusMatch::TokenSet.tokenize(temp.path)
+
+    temp.unlink
+
+    @matchings = PerseusMatch.match(phrases)
+  end
+
+  it 'should identify identical (non-empty) strings as identical' do
+    @matchings.each { |matching|
+      if !matching.phrase.empty? && matching.phrase == matching.target
+        inform_on_error(matching) { matching.similarity.should == 1.0 }
+      end
+    }
+  end
+
+  it 'should identify case-insensitively identical (non-empty) strings as nearly identical' do
+    @matchings.each { |matching|
+      if !matching.phrase.empty? && matching.phrase.replace_diacritics.downcase == matching.target.replace_diacritics.downcase
+        inform_on_error(matching) { matching.similarity.should > 0.95 }
+      end
+    }
+  end
+
+  it 'should identify *only* case-insensitively identical (non-empty) strings as nearly identical' do
+    @matchings.each { |matching|
+      if !matching.phrase.empty? && matching.phrase.replace_diacritics.downcase != matching.target.replace_diacritics.downcase
+        inform_on_error(matching) { matching.similarity.should < 0.98 }
+      end
+    }
+  end
+
+  it 'should identify disjunct (non-empty) strings as disjunct' do
+    @matchings.each { |matching|
+      if !matching.phrase.empty? && matching.phrase_tokens.disjoint?(matching.target_tokens)
+        inform_on_error(matching) { matching.similarity.should == 0.0 }
+      end
+    }
+  end
+
+  it 'should identify empty string as disjunct with anything, even with itself' do
+    @matchings.each { |matching|
+      if matching.phrase.empty? || matching.target.empty?
+        inform_on_error(matching) { matching.similarity.should == 0.0 }
+      end
+    }
+  end
+
+  it 'should identify certain strings as highly similar (1)' do
+    @matchings.each { |matching|
+      if @highly_similar.include?(matching.phrase) && @highly_similar.include?(matching.target)
+        inform_on_error(matching) { matching.similarity.should > 0.9 }
+      end
+    }
+  end
+
+  it 'should identify certain strings as highly similar (2)' do
+    @highly_similar.each { |phrase|
+      @highly_similar.each { |target|
+        inform_on_error([phrase, target]) { PerseusMatch.check(phrase, target, 0.9).should be_true }
+      }
+    }
+  end
+
+  it 'should identify certain strings as similar (1)' do
+    @matchings.each { |matching|
+      if @similar.include?(matching.phrase) && @similar.include?(matching.target)
+        inform_on_error(matching) { matching.similarity.should > 0.8 }
+      end
+    }
+  end
+
+  it 'should identify certain strings as similar (2)' do
+    @similar.each { |phrase|
+      @similar.each { |target|
+        inform_on_error([phrase, target]) { PerseusMatch.check(phrase, target, 0.8).should be_true }
+      }
+    }
+  end
+
+  it 'should *not* identify other strings as similar (1)' do
+    @matchings.each { |matching|
+      if @somewhat_similar.include?(matching.phrase) && !@somewhat_similar.include?(matching.target)
+        inform_on_error(matching) { matching.similarity.should_not > 0.8 }
+      end
+    }
+  end
+
+  it 'should *not* identify other strings as similar (2)' do
+    @matchings.each { |matching|
+      if @somewhat_similar.include?(matching.phrase) && !@somewhat_similar.include?(matching.target)
+        inform_on_error(matching) { PerseusMatch.check(matching.phrase, matching.target, 0.8).should be_false }
+      end
+    }
+  end
+
+  it 'should be symmetrical' do
+    similarities = {}
+
+    @matchings.each { |matching|
+      if similarity = similarities[[matching.target, matching.phrase]]
+        inform_on_error(matching) { similarity.should == matching.similarity }
+      else
+        similarities[[matching.phrase, matching.target]] = matching.similarity
+      end
+    }
+  end
+
+  it 'should calculate pair distance' do
+    PerseusMatch.distance('foo', 'bar').class.should < Numeric
+  end
+
+  it 'should be clusterable' do
+    PerseusMatch.cluster(@somewhat_similar).should be_an_instance_of(Array)
+  end
+
+  it 'should be checkable (1)' do
+    PerseusMatch.check('foo', 'bar', 0, :>=).should be_true
+  end
+
+  it 'should be checkable (2)' do
+    lambda {
+      begin
+        PerseusMatch.check!('foo', 'bar', 0, :>)
+      rescue PerseusMatch::CheckFailedError => err
+        err.to_s.should =~ /0/
+        raise err
+      end
+    }.should raise_error(PerseusMatch::CheckFailedError)
+  end
+
+end if LINGO_FOUND

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+unless Object.const_defined?(:PerseusMatch)
+  $: << File.join(File.dirname(__FILE__), '..', 'lib')
+  require 'perseus_match'
+end
+
+def inform_on_error(*args)
+  begin
+    yield
+  rescue Spec::Expectations::ExpectationNotMetError => err
+    unless args.empty?
+      puts
+      p *args 
+      puts
+    end
+
+    raise
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: blackwinter-perseus_match
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Jens Wille
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-09 00:00:00 -08:00
+default_executable: perseus_match
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-backports
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-nuggets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+description: Fuzzy string matching based on linguistic analysis
+email: jens.wille@uni-koeln.de
+executables: 
+- perseus_match
+extensions: []
+
+extra_rdoc_files: 
+- COPYING
+- ChangeLog
+- README
+files: 
+- lib/perseus_match/list.rb
+- lib/perseus_match/version.rb
+- lib/perseus_match/token_set.rb
+- lib/perseus_match/cluster.rb
+- lib/perseus_match.rb
+- bin/perseus_match
+- Rakefile
+- COPYING
+- ChangeLog
+- LINGO_BASE
+- README
+- spec/spec_helper.rb
+- spec/perseus_match/list_spec.rb
+- spec/perseus_match/cluster_spec.rb
+- spec/perseus_match/token_set_spec.rb
+- spec/perseus_match_spec.rb
+has_rdoc: true
+homepage: http://prometheus.rubyforge.org/perseus_match
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- perseus_match Application documentation
+- --main
+- README
+- --charset
+- UTF-8
+- --all
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: prometheus
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Fuzzy string matching based on linguistic analysis
+test_files: []
+