wordnet 1.0.1 → 1.1.0

data/spec/wordnet/lexicon_spec.rb

@@ -11,50 +11,14 @@ require 'wordnet/lexicon'
 
 describe WordNet::Lexicon do
 
-	before( :all ) do
-		@devdb = Pathname( 'wordnet-defaultdb/data/wordnet-defaultdb/wordnet30.sqlite' ).
-			expand_path
-	end
-
-
-	context "the default_db_uri method" do
-
-		it "uses the wordnet-defaultdb database gem (if available)" do
-			expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
-				and_return( '/tmp/foo' )
-			expect( FileTest ).to receive( :exist? ).with( '/tmp/foo/wordnet30.sqlite' ).
-				and_return( true )
-
-			expect( WordNet::Lexicon.default_db_uri ).to eq( "sqlite:/tmp/foo/wordnet30.sqlite" )
-		end
-
-		it "uses the development version of the wordnet-defaultdb database gem if it's " +
-		   "not installed" do
-			expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).
-				and_return( nil )
-			expect( FileTest ).to receive( :exist? ).with( @devdb.to_s ).
-				and_return( true )
-
-			expect( WordNet::Lexicon.default_db_uri ).to eq( "sqlite:#{@devdb}" )
-		end
-
-		it "returns nil if there is no default database" do
-			expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).
-				and_return( nil )
-			expect( FileTest ).to receive( :exist? ).with( @devdb.to_s ).
-				and_return( false )
-
-			expect( WordNet::Lexicon.default_db_uri ).to be_nil()
-		end
-
+	let( :devdb ) do
+		Pathname( 'wordnet-defaultdb/data/wordnet-defaultdb/wordnet31.sqlite' ).expand_path
 	end
 
 
 	it "raises an exception if created with no arguments and no defaultdb is available" do
-		expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
+		expect( WordNet::DefaultDB ).to receive( :uri ).at_least( :once ).
 			and_return( nil )
-		expect( FileTest ).to receive( :exist? ).with( @devdb.to_s ).
-			and_return( false )
 
 		expect {
 			WordNet::Lexicon.new
@@ -62,129 +26,97 @@ describe WordNet::Lexicon do
 	end
 
 
-	context "with the default database", :requires_database => true do
+	context "via its index operator" do
 
-		let( :lexicon ) { WordNet::Lexicon.new }
+		let( :lexicon ) { WordNet::Lexicon.new($dburi) }
 
-		context "via its index operator" do
 
-			it "can look up a Synset by ID" do
-				rval = lexicon[ 101219722 ]
-				expect( rval ).to be_a( WordNet::Synset )
-				expect( rval.words.map( &:to_s ) ).to include( 'carrot' )
-			end
+		it "can look up a Synset by ID" do
+			rval = lexicon[ 101222212 ]
+			# Can't use "be_a", as on failure it does Array(WordNet::Synset), which explodes to
+			# all synsets in the database
+			expect( rval.class ).to eq( WordNet::Synset )
+			expect( rval.words.map( &:to_s ) ).to include( 'carrot' )
+		end
 
-			it "can look up a Word by ID" do
-				rval = lexicon[ 21338 ]
-				expect( rval ).to be_a( WordNet::Word )
-				expect( rval.lemma ).to eq( 'carrot' )
-			end
+		it "can look up a Word by ID" do
+			rval = lexicon[ 21346 ]
+			expect( rval.class ).to eq( WordNet::Word )
+			expect( rval.lemma ).to eq( 'carrot' )
+		end
 
-			it "can look up the synset for a word and a sense" do
-				ss = lexicon[ :boot, 3 ]
-				expect( ss ).to be_a( WordNet::Synset )
-				expect( ss.definition ).to eq( 'footwear that covers the whole foot and lower leg' )
-			end
+		it "can look up the synset for a word and a sense" do
+			ss = lexicon[ :boot, 3 ]
+			expect( ss.class ).to eq( WordNet::Synset )
+			expect( ss.definition ).to eq( 'footwear that covers the whole foot and lower leg' )
+		end
 
-			it "can look up all synsets for a particular word" do
-				sss = lexicon.lookup_synsets( :tree )
-				expect( sss.size ).to eq( 7 )
-				expect( sss ).to all( be_a(WordNet::Synset) )
-			end
+		it "can look up all synsets for a particular word" do
+			sss = lexicon.lookup_synsets( :tree )
+			expect( sss.size ).to eq( 7 )
+			expect( sss ).to all( be_a(WordNet::Synset) )
+		end
 
-			it "can constrain fetched synsets to a certain range of results" do
-				sss = lexicon.lookup_synsets( :tree, 1..4 )
-				expect( sss.size ).to eq( 4 )
-			end
+		it "can constrain fetched synsets to a certain range of results" do
+			sss = lexicon.lookup_synsets( :tree, 1..4 )
+			expect( sss.size ).to eq( 4 )
+		end
 
-			it "can constrain fetched synsets to a certain (exclusive) range of results" do
-				sss = lexicon.lookup_synsets( :tree, 1...4 )
-				expect( sss.size ).to eq( 3 )
-			end
+		it "can constrain fetched synsets to a certain (exclusive) range of results" do
+			sss = lexicon.lookup_synsets( :tree, 1...4 )
+			expect( sss.size ).to eq( 3 )
+		end
 
+		it "can look up a synset for a word and a substring of its definition" do
+			ss = lexicon[ :boot, 'kick' ]
+			expect( ss.class ).to eq( WordNet::Synset )
+			expect( ss.definition ).to match( /kick/i )
 		end
 
-	end
+		it "can look up a synset for a word and a part of speech" do
+			ss = lexicon[ :boot, :verb ]
+			expect( ss.class ).to eq( WordNet::Synset )
+			expect( ss.definition ).to match( /cause to load/i )
+		end
+
+		it "can look up a synset for a word and an abbreviated part of speech" do
+			ss = lexicon[ :boot, :n ]
+			expect( ss.class ).to eq( WordNet::Synset )
+			expect( ss.definition ).to match( /delivering a blow with the foot/i )
+		end
+
+		it "can constrain fetched synsets with a Regexp match against its definition", :requires_pg do
+			sss = lexicon.lookup_synsets( :tree, /plant/ )
+			expect( sss.size ).to eq( 2 )
+		end
 
-	context "with a PostgreSQL database", :requires_pg do
-
-		let( :lexicon ) { WordNet::Lexicon.new('postgres:/wordnet30') }
-
-		context "via its index operator" do
-
-			it "can look up a Synset by ID" do
-				rval = lexicon[ 101219722 ]
-				expect( rval ).to be_a( WordNet::Synset )
-				expect( rval.words.map(&:to_s) ).to include( 'carrot' )
-			end
-
-			it "can look up a Word by ID" do
-				rval = lexicon[ 21338 ]
-				expect( rval ).to be_a( WordNet::Word )
-				expect( rval.lemma ).to eq( 'carrot' )
-			end
-
-			it "can look up the synset for a word and a sense" do
-				ss = lexicon[ :boot, 3 ]
-				expect( ss ).to be_a( WordNet::Synset )
-				expect( ss.definition ).to eq( 'footwear that covers the whole foot and lower leg' )
-			end
-
-			it "can look up a synset for a word and a substring of its definition" do
-				ss = lexicon[ :boot, 'kick' ]
-				expect( ss ).to be_a( WordNet::Synset )
-				expect( ss.definition ).to match( /kick/i )
-			end
-
-			it "can look up a synset for a word and a part of speech" do
-				ss = lexicon[ :boot, :verb ]
-				expect( ss ).to be_a( WordNet::Synset )
-				expect( ss.definition ).to match( /cause to load/i )
-			end
-
-			it "can look up a synset for a word and an abbreviated part of speech" do
-				ss = lexicon[ :boot, :n ]
-				expect( ss ).to be_a( WordNet::Synset )
-				expect( ss.definition ).to match( /act of delivering/i )
-			end
-
-			it "can constrain fetched synsets with a Regexp match against its definition" do
-				sss = lexicon.lookup_synsets( :tree, /plant/ )
-				expect( sss.size ).to eq( 2 )
-			end
-
-			it "can constrain fetched synsets via lexical domain" do
-				sss = lexicon.lookup_synsets( :tree, 'noun.shape' )
-				expect( sss.size ).to eq( 1 )
-				expect( sss.first ).to eq( WordNet::Synset[ 113912260 ] )
-			end
-
-			it "can constrain fetched synsets via part of speech as a single-letter Symbol" do
-				sss = lexicon.lookup_synsets( :tree, :n )
-				expect( sss.size ).to eq( 3 )
-				expect( sss ).to include(
-					WordNet::Synset[ 113912260 ],
-					WordNet::Synset[ 111348160 ],
-					WordNet::Synset[ 113104059 ]
-				)
-			end
-
-			it "can constrain fetched synsets via part of speech as a Symbol word" do
-				sss = lexicon.lookup_synsets( :tree, :verb )
-				expect( sss.size ).to eq( 4 )
-				expect( sss ).to include(
-					WordNet::Synset[ 200319111 ],
-					WordNet::Synset[ 201145163 ],
-					WordNet::Synset[ 201616293 ],
-					WordNet::Synset[ 201934205 ]
-				)
-			end
-
-			it "includes the database adapter name in its inspect output" do
-				expect( lexicon.inspect ).to include( "postgres" )
-			end
+		it "can constrain fetched synsets via lexical domain" do
+			sss = lexicon.lookup_synsets( :tree, 'noun.shape' )
+			expect( sss.size ).to eq( 1 )
+			expect( sss.first ).to eq( WordNet::Synset[113935275 ] )
+		end
 
+		it "can constrain fetched synsets via part of speech as a single-letter Symbol" do
+			sss = lexicon.lookup_synsets( :tree, :n )
+			expect( sss.size ).to eq( 3 )
+			expect( sss ).to include(
+				lexicon[ :tree, 'actor' ],
+				lexicon[ :tree, 'figure' ],
+				lexicon[ :tree, 'plant' ]
+			)
 		end
+
+		it "can constrain fetched synsets via part of speech as a Symbol word" do
+			sss = lexicon.lookup_synsets( :tree, :verb )
+			expect( sss.size ).to eq( 4 )
+			expect( sss ).to include(
+				WordNet::Synset[ 201938064 ],
+				WordNet::Synset[ 201147629 ],
+				WordNet::Synset[ 201619197 ],
+				WordNet::Synset[ 200319912 ]
+			)
+		end
+
 	end
 
 end

data/spec/wordnet/model_spec.rb

@@ -16,12 +16,5 @@ DB = Sequel.connect( 'mock://postgres' )
 
 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
-		expect( subclass.db ).to equal( newdb )
-	end
-
 end
 

data/spec/wordnet/semanticlink_spec.rb

@@ -2,16 +2,18 @@
 require_relative '../helpers'
 
 require 'rspec'
-require 'wordnet/semanticlink'
+require 'wordnet'
 
 
 #####################################################################
 ###	C O N T E X T S
 #####################################################################
 
-describe WordNet::SemanticLink, :requires_database => true do
+describe 'WordNet::SemanticLink', :requires_database do
 
-	let( :lexicon ) { WordNet::Lexicon.new  }
+	let( :described_class ) { WordNet::SemanticLink }
+
+	let( :lexicon ) { WordNet::Lexicon.new($dburi) }
 	let( :word )    { lexicon[96814]        } # 'parody'
 	let( :synset )  { word.synsets.first    }
 	let( :semlink ) { synset.semlinks.first }

data/spec/wordnet/sense_spec.rb

@@ -2,16 +2,18 @@
 
 require_relative '../helpers'
 
-require 'wordnet/sense'
+require 'wordnet'
 
 
-describe WordNet::Sense, :requires_database => true do
+describe 'WordNet::Sense', :requires_database do
 
 	before( :all ) do
-		@lexicon = WordNet::Lexicon.new
+		@lexicon = WordNet::Lexicon.new( $dburi )
 	end
 
 
+	let( :described_class ) { WordNet::Sense }
+
 	let( :sense ) do
 		WordNet::Word[ 79712 ].senses.first
 	end

data/spec/wordnet/synset_spec.rb

@@ -2,20 +2,22 @@
 require_relative '../helpers'
 
 require 'rspec'
-require 'wordnet/synset'
 
 
 #####################################################################
 ###	C O N T E X T S
 #####################################################################
 
-describe WordNet::Synset, :requires_database => true do
+describe 'WordNet::Synset', :requires_database do
 
 	before( :all ) do
-		@lexicon = WordNet::Lexicon.new
+		@lexicon = WordNet::Lexicon.new( $dburi )
 	end
 
 
+	let( :described_class ) { WordNet::Synset }
+
+
 	it "knows what kinds of lexical domains are available" do
 		expect( described_class.lexdomains ).to be_a( Hash )
 		expect( described_class.lexdomains ).to include( 'noun.cognition' )
@@ -42,7 +44,7 @@ describe WordNet::Synset, :requires_database => true do
 		# floor, level, storey, story (noun): [noun.artifact] a structure
 		#     consisting of a room or set of rooms at a single position along a
 		#     vertical scale (hypernym: 1, hyponym: 5, part meronym: 1)
-		let( :synset ) { WordNet::Synset[103365991] }
+		let( :synset ) { @lexicon['story', :n] }
 
 
 		it "knows what lexical domain it's from" do
@@ -60,31 +62,17 @@ describe WordNet::Synset, :requires_database => true do
 			expect( enum ).to be_a( Enumerator )
 		end
 
-		it "can recursively traverse its semantic links" do
-			res = synset.traverse( :hypernyms ).to_a
-			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 )
 
-			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 )
+			expect( enum ).to be_a( Enumerator ).and( contain_exactly(
+				@lexicon['artifact', :n],
+				@lexicon['unit', :n],
+				@lexicon['object', :n],
+				@lexicon['physical entity', :n],
+				@lexicon['entity', :n],
+				@lexicon['structure', :n],
+			) )
 		end
 	end
 

data/spec/wordnet/word_spec.rb

@@ -3,21 +3,23 @@ require_relative '../helpers'
 
 require 'rspec'
 require 'wordnet'
-require 'wordnet/word'
 
 
 #####################################################################
 ###	C O N T E X T S
 #####################################################################
 
-describe WordNet::Word, :requires_database => true do
+describe 'WordNet::Word', :requires_database do
 
-	let( :lexicon ) { WordNet::Lexicon.new }
+	let( :described_class ) { WordNet::Word }
+
+	let!( :lexicon ) { WordNet::Lexicon.new($dburi) }
 
 
 	context "the Word for 'run'" do
 
-		let( :word ) { lexicon[113377] }
+		let( :word ) { described_class.by_lemma('run').first }
+
 
 		it "knows what senses it has" do
 			senses = word.senses
@@ -26,6 +28,7 @@ describe WordNet::Word, :requires_database => true do
 			expect( senses.first ).to be_a( WordNet::Sense )
 		end
 
+
 		it "knows what synsets it has" do
 			synsets = word.synsets
 
@@ -34,6 +37,7 @@ describe WordNet::Word, :requires_database => true do
 			expect( synsets.first.senses ).to include( word.senses.first )
 		end
 
+
 		it "has a dataset for selecting noun synsets" do
 			expect( word.nouns ).to be_a( Sequel::Dataset )
 			expect( word.nouns.count ).to eq( 16 )
@@ -46,6 +50,7 @@ describe WordNet::Word, :requires_database => true do
 			)
 		end
 
+
 		it "has a dataset for selecting verb synsets" do
 			expect( word.verbs ).to be_a( Sequel::Dataset )
 			expect( word.verbs.count ).to eq( 41 )
@@ -63,7 +68,8 @@ describe WordNet::Word, :requires_database => true do
 
 	context "the Word for 'light'" do
 
-		let( :word ) { lexicon[77458] }
+		let( :word ) { described_class.by_lemma('light').first }
+
 
 		it "has a dataset for selecting adjective synsets" do
 			expect( word.adjectives ).to be_a( Sequel::Dataset )
@@ -76,6 +82,7 @@ describe WordNet::Word, :requires_database => true do
 			)
 		end
 
+
 		it "has a dataset for selecting adjective-satellite synsets" do
 			expect( word.adjective_satellites ).to be_a( Sequel::Dataset )
 			expect( word.adjective_satellites.count ).to eq( 17 )
@@ -92,7 +99,8 @@ describe WordNet::Word, :requires_database => true do
 
 	context "the Word for 'lightly'" do
 
-		let( :word ) { lexicon[77549] }
+		let( :word ) { described_class.by_lemma('lightly').first }
+
 
 		it "has a dataset for selecting adverb synsets" do
 			expect( word.adverbs ).to be_a( Sequel::Dataset )