wordnet 1.0.0 → 1.0.1

data/spec/wordnet/model_spec.rb

@@ -1,30 +1,9 @@
-#!/usr/bin/env ruby
-
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	libdir = basedir + 'lib'
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+#!/usr/bin/env rspec
+require_relative '../helpers'
 
 require 'rspec'
 require 'sequel'
 
-# Use Sequel's own spec helpers
-if Gem::Specification.respond_to?( :find_by_name )
-	sequel_spec = Gem::Specification.find_by_name( 'sequel' )
-	gem_basedir = sequel_spec.full_gem_path
-	$LOAD_PATH.unshift( gem_basedir ) unless $LOAD_PATH.include?( gem_basedir )
-else
-	gem_basedir = Pathname( Gem.required_location('sequel', 'sequel.rb') ).dirname.parent.to_s
-	$LOAD_PATH.unshift( gem_basedir ) unless $LOAD_PATH.include?( gem_basedir )
-end
-require 'spec/model/spec_helper'
-
-require 'spec/lib/helpers'
 require 'wordnet'
 require 'wordnet/model'
 
@@ -33,27 +12,16 @@ require 'wordnet/model'
 ###	C O N T E X T S
 #####################################################################
 
-describe WordNet::Model do
+DB = Sequel.connect( 'mock://postgres' )
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	before( :each ) do
-		MODEL_DB.reset
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
+describe WordNet::Model do
 
 	it "propagates database handle changes to all of its subclasses" do
 		subclass = WordNet::Model( :tests )
 		newdb = Sequel.mock
 		WordNet::Model.db = newdb
-		subclass.db.should equal( newdb )
+		expect( subclass.db ).to equal( newdb )
 	end
 
-
 end
 

data/spec/wordnet/semanticlink_spec.rb

@@ -1,17 +1,7 @@
-#!/usr/bin/env ruby
-
-BEGIN {
-	require 'pathname'
-
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-	libdir = basedir + 'lib'
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+#!/usr/bin/env rspec
+require_relative '../helpers'
 
 require 'rspec'
-require 'spec/lib/helpers'
 require 'wordnet/semanticlink'
 
 
@@ -20,16 +10,6 @@ require 'wordnet/semanticlink'
 #####################################################################
 
 describe WordNet::SemanticLink, :requires_database => true do
-	include WordNet::SpecHelpers
-
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	let( :lexicon ) { WordNet::Lexicon.new  }
 	let( :word )    { lexicon[96814]        } # 'parody'
@@ -38,16 +18,16 @@ describe WordNet::SemanticLink, :requires_database => true do
 
 
 	it "links two synsets together" do
-		semlink.origin.should be_a( WordNet::Synset )
-		semlink.target.should be_a( WordNet::Synset )
+		expect( semlink.origin ).to be_a( WordNet::Synset )
+		expect( semlink.target ).to be_a( WordNet::Synset )
 	end
 
 	it "has a Symbolic type" do
-		semlink.type.should == :hypernym
+		expect( semlink.type ).to eq( :hypernym )
 	end
 
 	it "has a human-readable type name" do
-		semlink.typename.should == 'hypernym'
+		expect( semlink.typename ).to eq( 'hypernym' )
 	end
 
 

data/spec/wordnet/sense_spec.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../helpers'
+
+require 'wordnet/sense'
+
+
+describe WordNet::Sense, :requires_database => true do
+
+	before( :all ) do
+		@lexicon = WordNet::Lexicon.new
+	end
+
+
+	let( :sense ) do
+		WordNet::Word[ 79712 ].senses.first
+	end
+
+
+	it "has a dataset for its 'also_see' lexical links" do
+		expect( sense.also_see ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'antonym' lexical links" do
+		expect( sense.antonym ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'derivation' lexical links" do
+		expect( sense.derivation ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'domain_categories' lexical links" do
+		expect( sense.domain_categories ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'domain_member_categories' lexical links" do
+		expect( sense.domain_member_categories ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'domain_member_region' lexical links" do
+		expect( sense.domain_member_region ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'domain_member_usage' lexical links" do
+		expect( sense.domain_member_usage ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'domain_region' lexical links" do
+		expect( sense.domain_region ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'domain_usage' lexical links" do
+		expect( sense.domain_usage ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'participle' lexical links" do
+		expect( sense.participle ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'pertainym' lexical links" do
+		expect( sense.pertainym ).to be_a( Sequel::Dataset )
+	end
+
+
+	it "has a dataset for its 'verb_group' lexical links" do
+		expect( sense.verb_group ).to be_a( Sequel::Dataset )
+	end
+
+end
+

data/spec/wordnet/synset_spec.rb

@@ -1,17 +1,7 @@
-#!/usr/bin/env ruby
-
-BEGIN {
-	require 'pathname'
-
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-	libdir = basedir + 'lib'
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+#!/usr/bin/env rspec
+require_relative '../helpers'
 
 require 'rspec'
-require 'spec/lib/helpers'
 require 'wordnet/synset'
 
 
@@ -20,36 +10,30 @@ require 'wordnet/synset'
 #####################################################################
 
 describe WordNet::Synset, :requires_database => true do
-	include WordNet::SpecHelpers
 
 	before( :all ) do
-		setup_logging( :fatal )
 		@lexicon = WordNet::Lexicon.new
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "knows what kinds of lexical domains are available" do
-		described_class.lexdomains.should be_a( Hash )
-		described_class.lexdomains.should include( 'noun.cognition' )
-		described_class.lexdomains['noun.cognition'].should be_a( Hash )
-		described_class.lexdomains['noun.cognition'][:pos].should == 'n'
+		expect( described_class.lexdomains ).to be_a( Hash )
+		expect( described_class.lexdomains ).to include( 'noun.cognition' )
+		expect( described_class.lexdomains['noun.cognition'] ).to be_a( Hash )
+		expect( described_class.lexdomains['noun.cognition'][:pos] ).to eq( 'n' )
 	end
 
 	it "knows what kinds of semantic links are available" do
-		described_class.linktypes.should be_a( Hash )
+		expect( described_class.linktypes ).to be_a( Hash )
 		hypernym = described_class.linktypes[:hypernym]
-		hypernym.should be_a( Hash )
-		hypernym[:typename].should == 'hypernym'
-		hypernym[:recurses].should be_true()
+		expect( hypernym ).to be_a( Hash )
+		expect( hypernym[:typename] ).to eq( 'hypernym' )
+		expect( hypernym[:recurses] ).to be_truthy()
 	end
 
 	it "knows what parts of speech are supported" do
-		described_class.postypes.should be_a( Hash )
-		described_class.postypes['noun'].should == :n
+		expect( described_class.postypes ).to be_a( Hash )
+		expect( described_class.postypes['noun'] ).to eq( :n )
 	end
 
 
@@ -62,42 +46,42 @@ describe WordNet::Synset, :requires_database => true do
 
 
 		it "knows what lexical domain it's from" do
-			synset.lexical_domain.should == 'noun.artifact'
+			expect( synset.lexical_domain ).to eq( 'noun.artifact' )
 		end
 
 		it "can make a Sequel dataset for any of its semantic link relationships" do
 			ds = synset.semanticlink_dataset( :member_meronyms )
-			ds.should be_a( Sequel::Dataset )
-			ds.first_source_table.should == :synsets
+			expect( ds ).to be_a( Sequel::Dataset )
+			expect( ds.first_source_table ).to eq( :synsets )
 		end
 
 		it "can make an Enumerator for any of its semantic link relationships" do
 			enum = synset.semanticlink_enum( :member_meronyms )
-			enum.should be_a( Enumerator )
+			expect( enum ).to be_a( Enumerator )
 		end
 
 		it "can recursively traverse its semantic links" do
 			res = synset.traverse( :hypernyms ).to_a
-			res.should have( 6 ).members
-			res.should == [
+			expect( res.size ).to eq( 6 )
+			expect( res ).to eq([
 				WordNet::Synset[ 104341686 ],
 				WordNet::Synset[ 100021939 ],
 				WordNet::Synset[ 100003553 ],
 				WordNet::Synset[ 100002684 ],
 				WordNet::Synset[ 100001930 ],
 				WordNet::Synset[ 100001740 ],
-			]
+			])
 		end
 
 		it "can return an Enumerator for recursively traversing its semantic links" do
 			enum = synset.traverse( :hypernyms )
 
-			enum.next.should == WordNet::Synset[ 104341686 ]
-			enum.next.should == WordNet::Synset[ 100021939 ]
-			enum.next.should == WordNet::Synset[ 100003553 ]
-			enum.next.should == WordNet::Synset[ 100002684 ]
-			enum.next.should == WordNet::Synset[ 100001930 ]
-			enum.next.should == WordNet::Synset[ 100001740 ]
+			expect( enum.next ).to eq( WordNet::Synset[ 104341686 ] )
+			expect( enum.next ).to eq( WordNet::Synset[ 100021939 ] )
+			expect( enum.next ).to eq( WordNet::Synset[ 100003553 ] )
+			expect( enum.next ).to eq( WordNet::Synset[ 100002684 ] )
+			expect( enum.next ).to eq( WordNet::Synset[ 100001930 ] )
+			expect( enum.next ).to eq( WordNet::Synset[ 100001740 ] )
 			expect {
 				enum.next
 			}.to raise_error( StopIteration )
@@ -111,17 +95,19 @@ describe WordNet::Synset, :requires_database => true do
 
 		it "can find the hypernym that it and another synset share in common through the intersection operator" do
 			res = synset | @lexicon[ :squire ]
-			res.should == @lexicon[:person]
+			expect( res ).to eq( @lexicon[:person] )
 		end
 
 		it "knows what part of speech it's for" do
-			synset.part_of_speech.should == 'noun'
+			expect( synset.part_of_speech ).to eq( 'noun' )
 		end
 
 		it "stringifies as a readable definition" do
-			synset.to_s.should == "knight (noun): [noun.person] originally a person of noble birth trained to " +
+			expect(
+				synset.to_s
+			).to eq( "knight (noun): [noun.person] originally a person of noble birth trained to " +
 				"arms and chivalry; today in Great Britain a person honored by the sovereign for personal " +
-				"merit (hypernym: 1, hyponym: 6, instance hyponym: 1)"
+				"merit (hypernym: 1, hyponym: 6, instance hyponym: 1)" )
 		end
 
 	end
@@ -132,8 +118,8 @@ describe WordNet::Synset, :requires_database => true do
 		let( :synset ) { @lexicon[:congener] }
 
 		it "can look up its sample sentences" do
-			synset.samples.should have( 2 ).members
-			synset.samples.should include(
+			expect( synset.samples.size ).to eq( 2 )
+			expect( synset.samples ).to include(
 				"lard was also used, though its congener, butter, was more frequently employed",
 				"the American shopkeeper differs from his European congener"
 			)

data/spec/wordnet/word_spec.rb

@@ -1,17 +1,7 @@
-#!/usr/bin/env ruby
-
-BEGIN {
-	require 'pathname'
-
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-	libdir = basedir + 'lib'
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
+#!/usr/bin/env rspec
+require_relative '../helpers'
 
 require 'rspec'
-require 'spec/lib/helpers'
 require 'wordnet'
 require 'wordnet/word'
 
@@ -21,16 +11,6 @@ require 'wordnet/word'
 #####################################################################
 
 describe WordNet::Word, :requires_database => true do
-	include WordNet::SpecHelpers
-
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	let( :lexicon ) { WordNet::Lexicon.new }
 
@@ -41,24 +21,24 @@ describe WordNet::Word, :requires_database => true do
 
 		it "knows what senses it has" do
 			senses = word.senses
-			senses.should be_an( Array )
-			senses.should have( 57 ).members
-			senses.first.should be_a( WordNet::Sense )
+			expect( senses ).to be_an( Array )
+			expect( senses.count ).to eq( 57 )
+			expect( senses.first ).to be_a( WordNet::Sense )
 		end
 
 		it "knows what synsets it has" do
 			synsets = word.synsets
 
 			# Should have one synset per sense
-			synsets.should have( word.senses.length ).members
-			synsets.first.senses.should include( word.senses.first )
+			expect( synsets.size ).to eq( word.senses.size )
+			expect( synsets.first.senses ).to include( word.senses.first )
 		end
 
 		it "has a dataset for selecting noun synsets" do
-			word.nouns.should be_a( Sequel::Dataset )
-			word.nouns.should have( 16 ).members
+			expect( word.nouns ).to be_a( Sequel::Dataset )
+			expect( word.nouns.count ).to eq( 16 )
 			ss = word.nouns.all
-			ss.should include(
+			expect( ss ).to include(
 				lexicon[ :run, 'sequence' ],
 				lexicon[ :run, 'baseball' ],
 				lexicon[ :run, 'act of running' ],
@@ -67,10 +47,10 @@ describe WordNet::Word, :requires_database => true do
 		end
 
 		it "has a dataset for selecting verb synsets" do
-			word.verbs.should be_a( Sequel::Dataset )
-			word.verbs.should have( 41 ).members
+			expect( word.verbs ).to be_a( Sequel::Dataset )
+			expect( word.verbs.count ).to eq( 41 )
 			ss = word.verbs.all
-			ss.should include(
+			expect( ss ).to include(
 				lexicon[ :run, 'compete' ],
 				lexicon[ :run, 'be diffused' ],
 				lexicon[ :run, 'liquid' ],
@@ -86,10 +66,10 @@ describe WordNet::Word, :requires_database => true do
 		let( :word ) { lexicon[77458] }
 
 		it "has a dataset for selecting adjective synsets" do
-			word.adjectives.should be_a( Sequel::Dataset )
-			word.adjectives.should have( 8 ).members
+			expect( word.adjectives ).to be_a( Sequel::Dataset )
+			expect( word.adjectives.count ).to eq( 8 )
 			ss = word.adjectives.all
-			ss.should include(
+			expect( ss ).to include(
 				lexicon[ :light, 'weight' ],
 				lexicon[ :light, 'emit', :adjective ],
 				lexicon[ :light, 'color' ]
@@ -97,10 +77,10 @@ describe WordNet::Word, :requires_database => true do
 		end
 
 		it "has a dataset for selecting adjective-satellite synsets" do
-			word.adjective_satellites.should be_a( Sequel::Dataset )
-			word.adjective_satellites.should have( 17 ).members
+			expect( word.adjective_satellites ).to be_a( Sequel::Dataset )
+			expect( word.adjective_satellites.count ).to eq( 17 )
 			ss = word.adjective_satellites.all
-			ss.should include(
+			expect( ss ).to include(
 				lexicon[ :light, 'soil' ],
 				lexicon[ :light, 'calories' ],
 				lexicon[ :light, 'entertainment' ]
@@ -115,10 +95,10 @@ describe WordNet::Word, :requires_database => true do
 		let( :word ) { lexicon[77549] }
 
 		it "has a dataset for selecting adverb synsets" do
-			word.adverbs.should be_a( Sequel::Dataset )
-			word.adverbs.should have( 7 ).members
+			expect( word.adverbs ).to be_a( Sequel::Dataset )
+			expect( word.adverbs.count ).to eq( 7 )
 			ss = word.adverbs.all
-			ss.should include(
+			expect( ss ).to include(
 				lexicon[ :lightly, 'indifference' ],
 				lexicon[ :lightly, 'indulging' ],
 				lexicon[ :lightly, 'little weight' ],