wordnet 0.0.5 → 1.0.0.pre.126

data/spec/linguawordnet.tests.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/ruby
+
+require "wntestcase"
+
+class LexiconTests < WordNet::TestCase
+
+	OldBaseballOffset = '00466621%n'
+	BaseballOffset = '00471613%n'
+
+	def test_perl_tests
+		synset = nil
+		synset2 = nil
+
+		begin
+			synset = @lexicon.lookup_synsets_by_key( BaseballOffset )
+		rescue WordNet::LookupError
+			synset = @lexicon.lookup_synsets_by_key( OldBaseballOffset )
+		end
+
+		assert_instance_of WordNet::Synset, synset
+
+		words = ''
+		synset.hyponyms.each do |bb_synset|
+			bb_synset.words += ["ballser"]
+			bb_synset.words.each {|word| words += "#{word}, "}
+		end
+		assert_match( /hardball/, words )
+
+		words = ''
+		synset2 = @lexicon.lookup_synsets( "travel", WordNet::Verb, 2 )
+		synset2.words.each {|word| words += "#{word}, "}
+		assert_match( /journey/, words )
+
+		assert_equal 4, @lexicon.familiarity( "boy", WordNet::Noun )
+		assert_equal "blue", @lexicon.morph( "bluest", WordNet::Adjective )
+		assert_match( /baseball/, "#{synset}" )
+	end
+end

data/spec/wordnet/lexicon_spec.rb

@@ -6,25 +6,15 @@ BEGIN {
 
 	libdir = basedir + 'lib'
 
-	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+	$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 )
 }
 
-begin
-	require 'fileutils'
-	require 'tmpdir'
-	require 'bdb'
-	require 'spec/runner'
-	require 'spec/lib/helpers'
-
-	require 'wordnet/lexicon'
-rescue LoadError
-	unless Object.const_defined?( :Gem )
-		require 'rubygems'
-		retry
-	end
-	raise
-end
+require 'rspec'
+require 'sequel'
 
+require 'spec/lib/helpers'
+require 'wordnet'
 
 
 #####################################################################
@@ -32,216 +22,136 @@ end
 #####################################################################
 
 describe WordNet::Lexicon do
-	include WordNet::SpecHelpers
-
-	TEST_WORDS = {
-		'activity'		=> WordNet::Noun,
-		'sword'			=> WordNet::Noun,
-		'density'		=> WordNet::Noun,
-		'burly'			=> WordNet::Adjective,
-		'wispy'			=> WordNet::Adjective,
-		'traditional'	=> WordNet::Adjective,
-		'sit'			=> WordNet::Verb,
-		'take'			=> WordNet::Verb,
-		'joust'			=> WordNet::Verb,
-	}
-
-
-	before( :each ) do
-		@path = make_tempdir()
-	end
 
-
-	after( :each ) do
-		FileUtils.rm_rf @path, :verbose => $DEBUG
+	before( :all ) do
+		setup_logging( :fatal )
+		@devdb = Pathname( 'wordnet-defaultdb/data/wordnet-defaultdb/wordnet30.sqlite' ).
+			expand_path
 	end
 
-	
-
-	#################################################################
-	###	T E S T S
-	#################################################################
-
-	it "defaults to being in :readonly mode" do
-		env = stub( "bdb environment handle", :open_db => nil )
-		BDB::Env.should_receive( :new ).
-			with( @path.to_s, WordNet::Lexicon::ENV_FLAGS_RO, WordNet::Lexicon::ENV_OPTIONS ).
-			and_return( env )
-
-		lex = WordNet::Lexicon.new( @path.to_s )
-
-		lex.should be_readonly()
-		lex.should_not be_readwrite()
+	after( :all ) do
+		reset_logging()
 	end
-	
-	it "can be created in :writable mode" do
-		env = stub( "bdb environment handle", :open_db => nil )
-		BDB::Env.should_receive( :new ).
-			with( @path.to_s, WordNet::Lexicon::ENV_FLAGS_RW, WordNet::Lexicon::ENV_OPTIONS ).
-			and_return( env )
 
-		lex = WordNet::Lexicon.new( @path.to_s, :writable )
+	context "the default_db_uri method" do
 
-		lex.should_not be_readonly()
-		lex.should be_readwrite()
-	end
-	
-	it "passes a read/write flagset to BDB when created in :readwrite mode" do
-		env = stub( "bdb environment handle", :open_db => nil )
-		BDB::Env.should_receive( :new ).
-			with( @path.to_s, WordNet::Lexicon::ENV_FLAGS_RW, WordNet::Lexicon::ENV_OPTIONS ).
-			and_return( env )
+		it "uses the wordnet-defaultdb database gem (if available)" do
+			Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
+				and_return( '/tmp/foo' )
+			FileTest.should_receive( :exist? ).with( '/tmp/foo/wordnet30.sqlite' ).
+				and_return( true )
 
-		lex = WordNet::Lexicon.new( @path.to_s, :readwrite )
-
-		lex.should_not be_readonly()
-		lex.should be_readwrite()
-	end
-	
-
-	describe "created in readonly mode" do
-
-		before( :each ) do
-			@env = mock( "bdb environment handle" )
-			BDB::Env.stub!( :new ).and_return( @env )
-			@env.stub!( :open_db )
-
-			@lexicon = WordNet::Lexicon.new( @path.to_s, :readonly )
+			WordNet::Lexicon.default_db_uri.should == "sqlite:/tmp/foo/wordnet30.sqlite"
 		end
 
+		it "uses the development version of the wordnet-defaultdb database gem if it's " +
+		   "not installed" do
+			Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).
+				and_return( nil )
+			FileTest.should_receive( :exist? ).with( @devdb.to_s ).
+				and_return( true )
 
-		it "doesn't try to remove logs" do
-			@env.should_not_receive( :log_archive )
-			@lexicon.clean_logs
+			WordNet::Lexicon.default_db_uri.should == "sqlite:#{@devdb}"
 		end
-		
-		
-	end
 
+		it "returns nil if there is no default database" do
+			Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).
+				and_return( nil )
+			FileTest.should_receive( :exist? ).with( @devdb.to_s ).
+				and_return( false )
 
-	describe "created in readwrite mode" do
+			WordNet::Lexicon.default_db_uri.should be_nil()
+		end
 
-		before( :each ) do
-			@env = mock( "bdb environment handle" )
-			BDB::Env.stub!( :new ).and_return( @env )
-			@env.stub!( :open_db )
+	end
 
-			@lexicon = WordNet::Lexicon.new( @path.to_s, :readwrite )
-		end
-		
 
-		it "can be closed" do
-			@env.should_receive( :close )
-			@lexicon.close
-		end
+	it "raises an exception if created with no arguments and no defaultdb is available" do
+		Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
+			and_return( nil )
+		FileTest.should_receive( :exist? ).with( @devdb.to_s ).
+			and_return( false )
 
-		it "provides a delegator for the checkpoint method of the underlying database" do
-			@env.should_receive( :checkpoint )
-			@lexicon.checkpoint
-		end
-	
-		it "provides an interface to clean up database transaction logs" do
-			@env.should_receive( :log_archive ).with( BDB::ARCH_ABS ).
-				and_return([ :log1, :log2 ])
-			File.should_receive( :chmod ).with( 0777, :log1 )
-			File.should_receive( :delete ).with( :log1 )
-			File.should_receive( :chmod ).with( 0777, :log2 )
-			File.should_receive( :delete ).with( :log2 )
-			
-			@lexicon.clean_logs
-		end
-		
-	
+		expect {
+			WordNet::Lexicon.new
+		}.to raise_error( WordNet::LexiconError, /no default wordnetsql/i )
 	end
-	
 
-	describe "with a converted WordNet database" do
+
+	context "with the default database", :requires_database => true do
 
 		before( :all ) do
-			@basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-			@datadir = @basedir + 'ruby-wordnet'
+			@lexicon = WordNet::Lexicon.new
 		end
 
-		before( :each ) do
-			pending "you haven't converted the WordNet datafiles yet -- try 'rake convert'" unless
-			 	@datadir.directory?
-
-			@lexicon = WordNet::Lexicon.new( @datadir.to_s )
-		end
+		context "via its index operator" do
 
+			it "can look up a Synset by ID" do
+				rval = @lexicon[ 101219722 ]
+				rval.should be_a( WordNet::Synset )
+				rval.words.map( &:to_s ).should include( 'carrot' )
+			end
 
-		TEST_WORDS.each do |word, pos|
-			it "returns a Fixnum value for the familiarity of #{word}(#{pos})" do
-				@lexicon.familiarity( word, pos ).should be_an_instance_of( Fixnum )
+			it "can look up a Word by ID" do
+				rval = @lexicon[ 21338 ]
+				rval.should be_a( WordNet::Word )
+				rval.lemma.should == 'carrot'
 			end
-		end
-		
-		
-		it "returns the root word as the morphological conversion of a dictionary word it knows about" do
-			@lexicon.morph( "angriest", WordNet::Adjective ).should == 'angry'
-		end
 
+			it "can look up the synset for a word and a sense" do
+				ss = @lexicon[ :boot, 3 ]
+				ss.should be_a( WordNet::Synset )
+				ss.definition.should == 'footwear that covers the whole foot and lower leg'
+			end
 
-		it "returns nil as the morphological conversion of a dictionary word it doesn't know about" do
-			@lexicon.morph( "Passomoquoddy", WordNet::Noun ).should be_nil()
 		end
 
+	end
+
+	context "with a PostgreSQL database", :requires_pg do
 
-		it "returns the 'reverse morph' of dictionary words it knows about" do
-			@lexicon.reverse_morph( "angry" ).should == 'angriest%a'
+		before( :all ) do
+			@lexicon = WordNet::Lexicon.new( 'postgres://localhost/wordnet30' )
 		end
 
+		context "via its index operator" do
 
-		it "tries looking up a failing via its morphological conversion if the original fails" do
-			synsets = @lexicon.lookup_synsets( 'angriest', WordNet::Adjective )
-			
-			synsets.should_not be_nil()
-			synsets.first.should be_an_instance_of( WordNet::Synset )
-			synsets.first.words.should include( 'angry' )
-		end
+			it "can look up a Synset by ID" do
+				rval = @lexicon[ 101219722 ]
+				rval.should be_a( WordNet::Synset )
+				rval.words.map( &:to_s ).should include( 'carrot' )
+			end
 
+			it "can look up a Word by ID" do
+				rval = @lexicon[ 21338 ]
+				rval.should be_a( WordNet::Word )
+				rval.lemma.should == 'carrot'
+			end
 
-		it "returns only the requested sense if a sense is specified" do
-			synset = @lexicon.lookup_synsets( 'run', WordNet::Verb, 4 )
-			synset.should be_an_instance_of( WordNet::Synset )
-			synset.words.first.should =~ /operate/i
-		end
-		
-		
-		it "can find every compound sense of a word in its dictionary" do
-			words = @lexicon.grep( 'thing' )
-
-			words.should have(10).members
-			words.should include( 'thing%n' )
-			words.should include( 'thing-in-itself%n' )
-			words.should include( 'thingamabob%n' )
-			words.should include( 'thingamajig%n' )
-			words.should include( 'thingmabob%n' )
-			words.should include( 'thingmajig%n' )
-			words.should include( 'things%n' )
-			words.should include( 'thingumabob%n' )
-			words.should include( 'thingumajig%n' )
-			words.should include( 'thingummy%n' )
-		end
-		
-		
-		TEST_WORDS.each do |word, pos|
-			it "can look up the synset #{word}(#{pos}) by word and part-of-speech" do
-				synsets = @lexicon.lookup_synsets( word, pos )
-
-				synsets.should have_at_least(1).members
-				synsets.each do |ss|
-					ss.should be_an_instance_of( WordNet::Synset )
-				end
+			it "can look up the synset for a word and a sense" do
+				ss = @lexicon[ :boot, 3 ]
+				ss.should be_a( WordNet::Synset )
+				ss.definition.should == 'footwear that covers the whole foot and lower leg'
 			end
-		end
 
+			it "can look up a synset for a word and a substring of its definition" do
+				ss = @lexicon[ :boot, 'kick' ]
+				ss.should be_a( WordNet::Synset )
+				ss.definition.should =~ /kick/i
+			end
 
-		it "can act as a factory for new synsets" do
-			@lexicon.create_synset( "Ruby", WordNet::Noun ).
-				should be_an_instance_of( WordNet::Synset )
-		end
+			it "can look up a synset for a word and a part of speech" do
+				ss = @lexicon[ :boot, :verb ]
+				ss.should be_a( WordNet::Synset )
+				ss.definition.should =~ /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 ]
+				ss.should be_a( WordNet::Synset )
+				ss.definition.should =~ /act of delivering/i
+			end
+		end
 	end
 
 end

data/spec/wordnet/model_spec.rb

@@ -0,0 +1,59 @@
+#!/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 )
+}
+
+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'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe WordNet::Model do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	before( :each ) do
+		MODEL_DB.reset
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	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 )
+	end
+
+
+end
+

data/spec/wordnet/semanticlink_spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+
+	basedir = Pathname.new( __FILE__ ).dirname.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 )
+}
+
+require 'rspec'
+require 'spec/lib/helpers'
+require 'wordnet/semanticlink'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe WordNet::SemanticLink, :requires_database => true do
+	include WordNet::SpecHelpers
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@lexicon = WordNet::Lexicon.new
+	end
+
+	before( :each ) do
+		@word   = @lexicon[ :parody ]
+		@synset = @word.synsets.first
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+end
+
+