wordnet 1.0.0 → 1.0.1

data/lib/wordnet/sense.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+#encoding: utf-8
 
 require 'wordnet' unless defined?( WordNet )
 require 'wordnet/model'
@@ -9,9 +10,16 @@ class WordNet::Sense < WordNet::Model( :senses )
 
 	set_primary_key :senseid
 
+	##
+	# The Synset this is a Sense for
 	many_to_one :synset, :key => :synsetid
+
+	##
+	# The Word this is a Sense for
 	many_to_one :word, :key => :wordid
 
+	##
+	# The lexical links between this sense and its related Synsets.
 	# Sense -> [ LexicalLinks ] -> [ Synsets ]
 	one_to_many :lexlinks,
 		:class       => :"WordNet::LexicalLink",
@@ -21,35 +29,71 @@ class WordNet::Sense < WordNet::Model( :senses )
 
 	### Generate a method that will return Synsets related by the given lexical pointer
 	### +type+.
-	def self::lexical_link( type, typekey=nil )
+	def self::lexical_link( type, typekey=nil ) # :nodoc:
 		typekey ||= type.to_s.chomp( 's' ).to_sym
 
 		self.log.debug "Generating a %p method for %p links" % [ type, typekey ]
 
 		method_body = Proc.new do
-			linkinfo = WordNet::Synset.linktype_names[ typekey ] or
+			linkinfo = WordNet::Synset.linktypes[ typekey ] or
 				raise ScriptError, "no such link type %p" % [ typekey ]
 			ssids = self.lexlinks_dataset.filter( :linkid => linkinfo[:id] ).select( :synset2id )
 			self.class.filter( :synsetid => ssids )
 		end
-		self.log.debug "  method body is: %p" % [ method_body ]
 
 		define_method( type, &method_body )
 	end
 
 
+	##
+	# Return the synsets that are lexically linked to this sense via an "also see" link.
 	lexical_link :also_see, :also
+
+	##
+	# Return the synsets that are lexically linked to this sense via an "antonym" link.
 	lexical_link :antonym
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "derivation" link.
 	lexical_link :derivation
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "domain category" link.
 	lexical_link :domain_categories, :domain_category
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "domain member
+	# category" link.
 	lexical_link :domain_member_categories, :domain_member_category
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "domain member region" link.
 	lexical_link :domain_member_region
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "domain member usage" link.
 	lexical_link :domain_member_usage
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "domain region" link.
 	lexical_link :domain_region
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "domain usage" link.
 	lexical_link :domain_usage
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "participle" link.
 	lexical_link :participle
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "pertainym" link.
 	lexical_link :pertainym
+
+	##
+	# Return the synsets that are lexically linked to this sense via a "verb group" link.
 	lexical_link :verb_group
 
+
 end # class WordNet::Sense
 

data/lib/wordnet/sumoterm.rb

@@ -1,11 +1,12 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+#encoding: utf-8
 
 require 'wordnet' unless defined?( WordNet )
 require 'wordnet/model'
 require 'wordnet/constants'
 
 
-# Experimental support for the WordNet mapping for the {Suggested Upper Merged 
+# Experimental support for the WordNet mapping for the {Suggested Upper Merged
 # Ontology}[http://www.ontologyportal.org/] (SUMO).
 # This is still a work in progress, and isn't supported by all of the WordNet-SQL
 # databases.

data/lib/wordnet/synset.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+#encoding: utf-8
 
 require 'wordnet' unless defined?( WordNet )
 require 'wordnet/constants'
@@ -45,7 +46,7 @@ require 'wordnet/model'
 #    # => [#<WordNet::Synset:0x7ffbf25c76c8 {115180528} 'point, point in
 #    #        time' (noun): [noun.time] an instant of time>]
 #
-# The synset's *hypernyms*, on the other hand, are kind of like its
+# The synset's *hyponyms*, on the other hand, are kind of like its
 # subclasses:
 #
 #    ss.hyponyms
@@ -101,7 +102,7 @@ require 'wordnet/model'
 #
 # In order to make use of this API, you'll need to be familiar with
 # {Sequel}[http://sequel.rubyforge.org/], especially
-# {Datasets}[http://sequel.rubyforge.org/rdoc/files/doc/dataset_basics_rdoc.html] and 
+# {Datasets}[http://sequel.rubyforge.org/rdoc/files/doc/dataset_basics_rdoc.html] and
 # {Model Associations}[http://sequel.rubyforge.org/rdoc/files/doc/association_basics_rdoc.html].
 # Most of Ruby-WordNet's functionality is implemented in terms of one or both
 # of these.
@@ -176,7 +177,6 @@ class WordNet::Synset < WordNet::Model( :synsets )
 	set_primary_key :synsetid
 
 	##
-	# :singleton-method:
 	# The WordNet::Words associated with the receiver
 	many_to_many :words,
 		:join_table  => :senses,
@@ -185,7 +185,6 @@ class WordNet::Synset < WordNet::Model( :synsets )
 
 
 	##
-	# :singleton-method:
 	# The WordNet::Senses associated with the receiver
 	one_to_many :senses,
 		:key         => :synsetid,
@@ -193,7 +192,6 @@ class WordNet::Synset < WordNet::Model( :synsets )
 
 
 	##
-	# :singleton-method:
 	# The WordNet::SemanticLinks indicating a relationship with other
 	# WordNet::Synsets
 	one_to_many :semlinks,
@@ -204,7 +202,6 @@ class WordNet::Synset < WordNet::Model( :synsets )
 
 
 	##
-	# :singleton-method:
 	# The WordNet::SemanticLinks pointing *to* this Synset
 	many_to_one :semlinks_to,
 		:class       => :"WordNet::SemanticLink",
@@ -213,7 +210,6 @@ class WordNet::Synset < WordNet::Model( :synsets )
 
 
 	##
-	# :singleton-method:
 	# Terms from the Suggested Upper Merged Ontology
 	many_to_many :sumo_terms,
 		:join_table  => :sumomaps,
@@ -551,7 +547,7 @@ class WordNet::Synset < WordNet::Model( :synsets )
 	# tree, you can make a traversal enumerator for it:
 	#
 	#   ss = $lex[:fencing]
-	#   # => #<WordNet::Synset:0x7fb582c24400 {101171644} 'fencing' (noun): [noun.act] the art or 
+	#   # => #<WordNet::Synset:0x7fb582c24400 {101171644} 'fencing' (noun): [noun.act] the art or
 	#      sport of fighting with swords (especially the use of foils or epees or sabres to score
 	#      points under a set of rules)>
 	#
@@ -671,13 +667,19 @@ class WordNet::Synset < WordNet::Model( :synsets )
 	# :section:
 	#
 
+	### Return the Synset's Words as an Array of Strings.
+	def wordlist
+		return self.words.map( &:to_s )
+	end
+
+
 	### Return a human-readable representation of the objects, suitable for debugging.
 	def inspect
 		return "#<%p:%0#x {%d} '%s' (%s): [%s] %s>" % [
 			self.class,
 			self.object_id * 2,
 			self.synsetid,
-			self.words.map(&:to_s).join(', '),
+			self.wordlist.join(', '),
 			self.part_of_speech,
 			self.lexical_domain,
 			self.definition,

data/lib/wordnet/word.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+# -*- ruby -*-
+#encoding: utf-8
 
 require 'wordnet' unless defined?( WordNet )
 require 'wordnet/model'
@@ -17,43 +18,43 @@ class WordNet::Word < WordNet::Model( :words )
 	#     "unq_words_lemma" UNIQUE, btree (lemma)
 	# Referenced by:
 	#     TABLE "adjpositions" CONSTRAINT "fk_adjpositions_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "bncconvtasks" CONSTRAINT "fk_bncconvtasks_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "bncimaginfs" CONSTRAINT "fk_bncimaginfs_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "bncs" CONSTRAINT "fk_bncs_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "bncspwrs" CONSTRAINT "fk_bncspwrs_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "casedwords" CONSTRAINT "fk_casedwords_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "lexlinks" CONSTRAINT "fk_lexlinks_word1id"
-	# 		FOREIGN KEY (word1id) REFERENCES words(wordid)
+	#        FOREIGN KEY (word1id) REFERENCES words(wordid)
 	#     TABLE "lexlinks" CONSTRAINT "fk_lexlinks_word2id"
-	# 		FOREIGN KEY (word2id) REFERENCES words(wordid)
+	#        FOREIGN KEY (word2id) REFERENCES words(wordid)
 	#     TABLE "morphmaps" CONSTRAINT "fk_morphmaps_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "sensemaps2021" CONSTRAINT "fk_sensemaps2021_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "sensemaps2130" CONSTRAINT "fk_sensemaps2130_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "senses20" CONSTRAINT "fk_senses20_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "senses21" CONSTRAINT "fk_senses21_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "senses" CONSTRAINT "fk_senses_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "vframemaps" CONSTRAINT "fk_vframemaps_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "vframesentencemaps" CONSTRAINT "fk_vframesentencemaps_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "vnclassmembers" CONSTRAINT "fk_vnclassmembers_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "vnframemaps" CONSTRAINT "fk_vnframemaps_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 	#     TABLE "vnrolemaps" CONSTRAINT "fk_vnrolemaps_wordid"
-	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#        FOREIGN KEY (wordid) REFERENCES words(wordid)
 
 
 	set_primary_key :wordid

data/spec/helpers.rb

@@ -0,0 +1,43 @@
+# -*- ruby -*-
+#encoding: utf-8
+# coding: utf-8
+
+# SimpleCov test coverage reporting; enable this using the :coverage rake task
+require 'simplecov' if ENV['COVERAGE']
+
+require 'rspec'
+require 'loggability/spechelpers'
+require 'wordnet'
+
+
+### RSpec helper functions.
+module WordNet::SpecHelpers
+end
+
+
+### Mock with Rspec
+RSpec.configure do |config|
+	config.run_all_when_everything_filtered = true
+	config.filter_run :focus
+	config.order = 'random'
+	config.mock_with( :rspec ) do |mock|
+		mock.syntax = :expect
+	end
+
+	if Gem::Specification.find_all_by_name( 'pg' ).empty?
+		config.filter_run_excluding( :requires_pg )
+	end
+
+	begin
+		uri = WordNet::Lexicon.default_db_uri
+		WordNet.log.info "Database tests will use: #{uri}"
+	rescue WordNet::LexiconError
+		config.filter_run_excluding( :requires_database )
+	end
+
+	config.include( WordNet::SpecHelpers )
+	config.include( Loggability::SpecHelpers )
+end
+
+# vim: set nosta noet ts=4 sw=4:
+

data/spec/wordnet/lexicon_spec.rb

@@ -1,20 +1,8 @@
-#!/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'
-
-require 'spec/lib/helpers'
-require 'wordnet'
+require 'wordnet/lexicon'
 
 
 #####################################################################
@@ -24,53 +12,48 @@ require 'wordnet'
 describe WordNet::Lexicon do
 
 	before( :all ) do
-		setup_logging()
 		@devdb = Pathname( 'wordnet-defaultdb/data/wordnet-defaultdb/wordnet30.sqlite' ).
 			expand_path
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	context "the default_db_uri method" do
 
 		it "uses the wordnet-defaultdb database gem (if available)" do
-			Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
+			expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
 				and_return( '/tmp/foo' )
-			FileTest.should_receive( :exist? ).with( '/tmp/foo/wordnet30.sqlite' ).
+			expect( FileTest ).to receive( :exist? ).with( '/tmp/foo/wordnet30.sqlite' ).
 				and_return( true )
 
-			WordNet::Lexicon.default_db_uri.should == "sqlite:/tmp/foo/wordnet30.sqlite"
+			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
-			Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).
+			expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).
 				and_return( nil )
-			FileTest.should_receive( :exist? ).with( @devdb.to_s ).
+			expect( FileTest ).to receive( :exist? ).with( @devdb.to_s ).
 				and_return( true )
 
-			WordNet::Lexicon.default_db_uri.should == "sqlite:#{@devdb}"
+			expect( WordNet::Lexicon.default_db_uri ).to eq( "sqlite:#{@devdb}" )
 		end
 
 		it "returns nil if there is no default database" do
-			Gem.should_receive( :datadir ).with( 'wordnet-defaultdb' ).
+			expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).
 				and_return( nil )
-			FileTest.should_receive( :exist? ).with( @devdb.to_s ).
+			expect( FileTest ).to receive( :exist? ).with( @devdb.to_s ).
 				and_return( false )
 
-			WordNet::Lexicon.default_db_uri.should be_nil()
+			expect( WordNet::Lexicon.default_db_uri ).to be_nil()
 		end
 
 	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 ).
+		expect( Gem ).to receive( :datadir ).with( 'wordnet-defaultdb' ).at_least( :once ).
 			and_return( nil )
-		FileTest.should_receive( :exist? ).with( @devdb.to_s ).
+		expect( FileTest ).to receive( :exist? ).with( @devdb.to_s ).
 			and_return( false )
 
 		expect {
@@ -87,36 +70,36 @@ describe WordNet::Lexicon 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' )
+				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 ]
-				rval.should be_a( WordNet::Word )
-				rval.lemma.should == 'carrot'
+				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 ]
-				ss.should be_a( WordNet::Synset )
-				ss.definition.should == 'footwear that covers the whole foot and lower leg'
+				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 all synsets for a particular word" do
 				sss = lexicon.lookup_synsets( :tree )
-				sss.should have( 7 ).members
-				sss.all? {|ss| ss.should be_a(WordNet::Synset) }
+				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 )
-				sss.should have( 4 ).members
+				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 )
-				sss.should have( 3 ).members
+				expect( sss.size ).to eq( 3 )
 			end
 
 		end
@@ -131,55 +114,55 @@ describe WordNet::Lexicon 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' )
+				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 ]
-				rval.should be_a( WordNet::Word )
-				rval.lemma.should == 'carrot'
+				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 ]
-				ss.should be_a( WordNet::Synset )
-				ss.definition.should == 'footwear that covers the whole foot and lower leg'
+				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' ]
-				ss.should be_a( WordNet::Synset )
-				ss.definition.should =~ /kick/i
+				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 ]
-				ss.should be_a( WordNet::Synset )
-				ss.definition.should =~ /cause to load/i
+				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 ]
-				ss.should be_a( WordNet::Synset )
-				ss.definition.should =~ /act of delivering/i
+				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/ )
-				sss.should have( 2 ).members
+				expect( sss.size ).to eq( 2 )
 			end
 
 			it "can constrain fetched synsets via lexical domain" do
 				sss = lexicon.lookup_synsets( :tree, 'noun.shape' )
-				sss.should have( 1 ).member
-				sss.first.should == WordNet::Synset[ 113912260 ]
+				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 )
-				sss.should have( 3 ).members
-				sss.should include(
+				expect( sss.size ).to eq( 3 )
+				expect( sss ).to include(
 					WordNet::Synset[ 113912260 ],
 					WordNet::Synset[ 111348160 ],
 					WordNet::Synset[ 113104059 ]
@@ -188,8 +171,8 @@ describe WordNet::Lexicon do
 
 			it "can constrain fetched synsets via part of speech as a Symbol word" do
 				sss = lexicon.lookup_synsets( :tree, :verb )
-				sss.should have( 4 ).members
-				sss.should include(
+				expect( sss.size ).to eq( 4 )
+				expect( sss ).to include(
 					WordNet::Synset[ 200319111 ],
 					WordNet::Synset[ 201145163 ],
 					WordNet::Synset[ 201616293 ],
@@ -198,7 +181,7 @@ describe WordNet::Lexicon do
 			end
 
 			it "includes the database adapter name in its inspect output" do
-				lexicon.inspect.should include( "postgres" )
+				expect( lexicon.inspect ).to include( "postgres" )
 			end
 
 		end