wordnet 1.0.0.pre.136 → 1.0.0.pre.139

data/History.rdoc

@@ -1,4 +1,4 @@
-== v1.0.0 [2012-01-30] Michael Granger <ged@FaerieMUD.org>
+== v1.0.0 [2012-08-22] Michael Granger <ged@FaerieMUD.org>
 
 Converted to use Sequel and wnsql.
 

data/README.rdoc

@@ -4,25 +4,64 @@
 
 == Description
 
-This library is a Ruby interface to WordNet®. WordNet® is an online
-lexical reference system whose design is inspired by current
-psycholinguistic theories of human lexical memory. English nouns, verbs,
-adjectives and adverbs are organized into synonym sets, each
+This library is a Ruby interface to WordNet®[http://wordnet.princeton.edu/].
+WordNet® is an online lexical reference system whose design is inspired
+by current psycholinguistic theories of human lexical memory. English
+nouns, verbs, adjectives and adverbs are organized into synonym sets, each
 representing one underlying lexical concept. Different relations link
 the synonym sets.
 
-It uses WordNet-SQL, which is a conversion of the lexicon flatfiles into
-a relational database format. You can either install the 'wordnet-
-defaultdb' gem, which packages up the SQLite3 version of WordNet-SQL, or
-install your own and point the lexicon at it by passing a Sequel URL to
-the constructor.
+This library uses WordNet-SQL[http://wnsql.sourceforge.net/], which is a
+conversion of the lexicon flatfiles into a relational database format. You
+can either install the 'wordnet-defaultdb' gem, which packages up the
+SQLite3 version of WordNet-SQL, or install your own and point the lexicon
+at it by passing 
+{Sequel connection parameters}[http://sequel.rubyforge.org/rdoc/files/doc/opening_databases_rdoc.html]
+to the constructor.
 
+=== Usage
+
+There are three major parts to this library:
+
+[WordNet::Lexicon]   the interface to the dictionary, used to connect to the
+                     database and look up Words and Synsets.
+[WordNet::Word]      the English word entries in the Lexicon that are mapped
+                     to Synsets via one or more Senses.
+[WordNet::Synset]    the main artifact of WordNet: a "synonym set". These
+                     are connected to one or more Words through a Sense,
+                     and are connected to each other via SemanticLinks.
+
+The other object classes exist mostly as a way of representing relationships
+between the main three:
+
+[WordNet::Sense]         represents a link between one or more Words and
+                         one or more Synsets for one meaning of the word.
+[WordNet::SemanticLink]  represents a link between Synsets
+[WordNet::LexicalLink]   represents a link between Words in Synsets
+[WordNet::Morph]         an interface to a lookup table of irregular word
+                         forms mapped to their base form (lemma)
+
+The last class (WordNet::Model) is the abstract superclass for all the others,
+and inherits most of its functionality from Sequel::Model, the ORM layer
+of the Sequel toolkit. It's mostly just a container for the database
+connection, with some convenience methods to allow the database connection
+to be deferred until runtime instead of when the library loads.
+
+The library also comes with the beginnings of support for the SUMO-WordNet
+mapping:
+
+[WordNet::SumoTerm]      {Suggested Upper Merged Ontology}[http://www.ontologyportal.org/]
+                         terms, with associations back to related Synsets.
+
+This is only supported by a subset of the WordNetSQL databases, and there
+is a fair amount of work left to be done before it's really functional. Drop
+me a note if you're interested in working on this.
 
 
 == Requirements
 
-* Ruby >= 1.9.2
-* Sequel >= 3.29.0
+* Ruby >= 1.9.3
+* Sequel >= 3.38.0
 
 
 == Authors

data/Rakefile

@@ -32,6 +32,7 @@ hoespec = Hoe.spec( 'wordnet' ) do
 	self.dependency 'loggability', '~> 0.5'
 	self.dependency 'sqlite3',     '~> 1.3', :developer
 	self.dependency 'rspec',       '~> 2.7', :developer
+	self.dependency 'simplecov',   '~> 0.6', :developer
 
 	self.spec_extras[:licenses] = ["BSD"]
 	self.spec_extras[:post_install_message] = %{
@@ -74,3 +75,9 @@ end
 # Rebuild the ChangeLog immediately before release
 task :prerelease => 'ChangeLog'
 
+# Simplecov
+desc "Build a coverage report"
+task :coverage do
+	ENV["COVERAGE"] = 'yes'
+	Rake::Task[:spec].invoke
+end

data/lib/wordnet.rb

@@ -21,8 +21,8 @@ module WordNet
 	REVISION = %q$Revision: $
 
 	# Abort if not >=1.9.2
-	abort "This version of WordNet requires Ruby 1.9.2 or greater." unless
-		RUBY_VERSION >= '1.9.2'
+	abort "This version of WordNet requires Ruby 1.9.3 or greater." unless
+		RUBY_VERSION >= '1.9.3'
 
 
 	### Lexicon exception - something has gone wrong in the internals of the

data/lib/wordnet/lexicallink.rb

@@ -10,11 +10,15 @@ class WordNet::LexicalLink < WordNet::Model( :lexlinks )
 
 	set_primary_key [:word1id, :synset1id, :word2id, :synset2id, :linkid]
 
+	##
+	# The WordNet::Sense the link is pointing *from*.
 	many_to_one :origin,
 		:class       => :"WordNet::Sense",
 		:key         => :synset1id,
 		:primary_key => :synsetid
 
+	##
+	# The WordNet::Synset the link is pointing *to*.
 	one_to_many :target,
 		:class       => :"WordNet::Synset",
 		:key         => :synsetid,

data/lib/wordnet/lexicon.rb

@@ -10,8 +10,115 @@ require 'wordnet/synset'
 require 'wordnet/word'
 
 
-# WordNet lexicon class - abstracts access to the WordNet lexical
-# database, and provides factory methods for looking up words and synsets.
+# WordNet lexicon class - provides access to the WordNet lexical
+# database, and provides factory methods for looking up words[rdoc-ref:WordNet::Word]
+# and synsets[rdoc-ref:WordNet::Synset].
+#
+# == Creating a Lexicon
+#
+# To create a Lexicon, either point it at a database using [Sequel database connection
+# criteria]{http://sequel.rubyforge.org/rdoc/files/doc/opening_databases_rdoc.html}:
+#
+#     lex = WordNet::Lexicon.new( 'postgres://localhost/wordnet30' )
+#     # => #<WordNet::Lexicon:0x7fd192a76668 postgres://localhost/wordnet30>
+#
+#     # Another way of doing the same thing:
+#     lex = WordNet::Lexicon.new( adapter: 'postgres', database: 'wordnet30', host: 'localhost' )
+#     # => #<WordNet::Lexicon:0x7fd192d374b0 postgres>
+#
+# Alternatively, if you have the 'wordnet-defaultdb' gem (which includes an
+# embedded copy of the SQLite WordNET-SQL database) installed, just call ::new
+# without any arguments:
+#
+#     lex = WordNet::Lexicon.new
+#     # => #<WordNet::Lexicon:0x7fdbfac1a358 sqlite:[...]/gems/wordnet-defaultdb-1.0.1
+#     #     /data/wordnet-defaultdb/wordnet30.sqlite>
+#
+# == Looking Up Synsets
+#
+# Once you have a Lexicon created, the main lookup method for Synsets is
+# #[], which will return the first of any Synsets that are found:
+#
+#    synset = lex[ :language ]
+#    # => #<WordNet::Synset:0x7fdbfaa987a0 {105650820} 'language, speech' (noun):
+#    #      [noun.cognition] the mental faculty or power of vocal communication>
+#
+# If you want to look up *all* matching Synsets, use the #lookup_synsets
+# method:
+#
+#    synsets = lex.lookup_synsets( :language )
+#    # => [#<WordNet::Synset:0x7fdbfaac46c0 {105650820} 'language, speech' (noun):
+#    #       [noun.cognition] the mental faculty or power of vocal
+#    #       communication>,
+#    #     #<WordNet::Synset:0x7fdbfaac45a8 {105808557} 'language, linguistic process'
+#    #       (noun): [noun.cognition] the cognitive processes involved
+#    #       in producing and understanding linguistic communication>,
+#    #     #<WordNet::Synset:0x7fdbfaac4490 {106282651} 'language, linguistic
+#    #       communication' (noun): [noun.communication] a systematic means of
+#    #       communicating by the use of sounds or conventional symbols>,
+#    #     #<WordNet::Synset:0x7fdbfaac4378 {106304059} 'language, nomenclature,
+#    #       terminology' (noun): [noun.communication] a system of words used to
+#    #       name things in a particular discipline>,
+#    #     #<WordNet::Synset:0x7fdbfaac4260 {107051975} 'language, lyric, words'
+#    #       (noun): [noun.communication] the text of a popular song or musical-comedy
+#    #       number>,
+#    #     #<WordNet::Synset:0x7fdbfaac4120 {107109196} 'language, oral communication,
+#    #       speech, speech communication, spoken communication, spoken language,
+#    #       voice communication' (noun): [noun.communication] (language)
+#    #       communication by word of mouth>]
+#
+# Sometime, the first Synset isn't necessarily what you want; you want to look up
+# a particular one. Both #[] and #lookup_synsets also provide several
+# ways of filtering or selecting synsets.
+#
+# The first is the ability to select one based on its offset:
+#
+#    lex[ :language, 2 ]
+#    # => #<WordNet::Synset:0x7ffa78e74d78 {105808557} 'language, linguistic
+#    #       process' (noun): [noun.cognition] the cognitive processes involved in
+#    #       producing and understanding linguistic communication>
+#
+# You can also select one with a particular word in its definition:
+#
+#    lex[ :language, 'sounds' ]
+#    # => #<WordNet::Synset:0x7ffa78ee01b8 {106282651} 'linguistic communication,
+#    #       language' (noun): [noun.communication] a systematic means of
+#    #       communicating by the use of sounds or conventional symbols>
+#
+# If you're using a database that supports using regular expressions (e.g.,
+# PostgreSQL), you can use that to select one with a matching definition:
+#
+#    lex[ :language, %r:name.*discipline: ]
+#    # => #<WordNet::Synset:0x7ffa78f235a8 {106304059} 'language, nomenclature,
+#    #       terminology' (noun): [noun.communication] a system of words used
+#    #       to name things in a particular discipline>
+#
+# You can also select certain parts of speech:
+#
+#    lex[ :right, :noun ]
+#    # => #<WordNet::Synset:0x7ffa78f30b68 {100351000} 'right' (noun):
+#    #       [noun.act] a turn toward the side of the body that is on the south
+#    #       when the person is facing east>
+#    lex[ :right, :verb ]
+#    # => #<WordNet::Synset:0x7ffa78f09590 {200199659} 'correct, right, rectify'
+#    #       (verb): [verb.change] make right or correct>
+#    lex[ :right, :adjective ]
+#    # => #<WordNet::Synset:0x7ffa78ea8060 {300631391} 'correct, right'
+#    #       (adjective): [adj.all] free from error; especially conforming to
+#    #       fact or truth>
+#    lex[ :right, :adverb ]
+#    # => #<WordNet::Synset:0x7ffa78e5b2d8 {400032299} 'powerful, mightily,
+#    #       mighty, right' (adverb): [adv.all] (Southern regional intensive)
+#    #       very; to a great degree>
+#
+# or by lexical domain, which is a more-specific part of speech (see
+# <tt>WordNet::Synset.lexdomains.keys</tt> for the list of valid ones):
+#
+#    lex.lookup_synsets( :right, 'verb.social' )
+#    # => [#<WordNet::Synset:0x7ffa78d817e0 {202519991} 'redress, compensate,
+#    #       correct, right' (verb): [verb.social] make reparations or amends
+#    #       for>]
+#
 class WordNet::Lexicon
 	extend Loggability
 	include WordNet::Constants
@@ -19,19 +126,9 @@ class WordNet::Lexicon
 	# Loggability API -- log to the WordNet module's logger
 	log_to :wordnet
 
-	# class LogTracer
-	# 	def method_missing( sym, msg, &block )
-	# 		if msg =~ /does not exist/
-	# 			$stderr.puts ">>> DOES NOT EXIST TRACE"
-	# 			$stderr.puts( caller(1).grep(/wordnet/i) )
-	# 		end
-	# 	end
-	# end
-
 
 	# Add the logger device to the default options after it's been loaded
 	WordNet::DEFAULT_DB_OPTIONS.merge!( :logger => [Loggability[WordNet]] )
-	# WordNet::DEFAULT_DB_OPTIONS.merge!( :logger => [LogTracer.new] )
 
 
 	### Get the Sequel URI of the default database, if it's installed.
@@ -73,35 +170,53 @@ class WordNet::Lexicon
 	### Create a new WordNet::Lexicon object that will use the database connection specified by
 	### the given +dbconfig+.
 	def initialize( *args )
-		uri = if args.empty?
-				WordNet::Lexicon.default_db_uri or
-					raise WordNet::LexiconError,
-						"No default WordNetSQL database! You can install it via the " +
-						"wordnet-defaultdb gem, or download a version yourself from " +
-						"http://sourceforge.net/projects/wnsql/"
-
-			elsif args.first.is_a?( String )
-				args.shift
-			else
-				nil
-			end
+		if args.empty?
+			self.initialize_with_defaultdb( args.shift )
+		elsif args.first.is_a?( String )
+			self.initialize_with_uri( *args )
+		else
+			self.initialize_with_opthash( args.shift )
+		end
+
+		@db.sql_log_level = :debug
+		WordNet::Model.db = @db
+	end
+
+
+	### Connect to the WordNet DB using an optional options hash.
+	def initialize_with_defaultdb( options )
+		uri = WordNet::Lexicon.default_db_uri or raise WordNet::LexiconError,
+			"No default WordNetSQL database! You can install it via the " +
+			"wordnet-defaultdb gem, or download a version yourself from " +
+			"http://sourceforge.net/projects/wnsql/"
+		@db = self.connect( uri, options )
+	end
 
-		options = WordNet::DEFAULT_DB_OPTIONS.merge( args.shift || {} )
+
+	### Connect to the WordNet DB using a URI and an optional options hash.
+	def initialize_with_uri( uri, options )
+		@db = self.connect( uri, options )
+	end
+
+
+	### Connect to the WordNet DB using a connection options hash.
+	def initialize_with_opthash( options )
+		@db = self.connect( nil, options )
+	end
+
+
+	### Connect to the WordNet DB and return a Sequel::Database object.
+	def connect( uri, options )
+		options = WordNet::DEFAULT_DB_OPTIONS.merge( options || {} )
 
 		if uri
 			self.log.debug "Connecting using uri + options style: uri = %s, options = %p" %
 				[ uri, options ]
-			@db = Sequel.connect( uri, options )
+			return Sequel.connect( uri, options )
 		else
 			self.log.debug "Connecting using hash style connect: options = %p" % [ options ]
-			@db = Sequel.connect( options )
+			return Sequel.connect( options )
 		end
-
-		@uri = @db.uri
-		self.log.debug "  setting model db to: %s" % [ @uri ]
-
-		@db.sql_log_level = :debug
-		WordNet::Model.db = @db
 	end
 
 
@@ -175,7 +290,7 @@ class WordNet::Lexicon
 
 			when Range
 				self.log.debug "  limiting to range of senses: %p" % [ arg ]
-				dataset = dataset.limit( arg.end - arg.begin, arg.begin - 1 )
+				dataset = dataset.limit( arg.entries.length, arg.begin - 1 )
 
 			when Regexp
 				self.log.debug "  filter: definition =~ %p" % [ arg ]
@@ -213,7 +328,11 @@ class WordNet::Lexicon
 	### Return a human-readable string representation of the Lexicon, suitable for
 	### debugging.
 	def inspect
-		return "#<%p:%0#x %s>" % [ self.class, self.object_id * 2, self.db.url ]
+		return "#<%p:%0#x %s>" % [
+			self.class,
+			self.object_id * 2,
+			self.db.url || self.db.adapter_scheme
+		]
 	end
 
 

data/lib/wordnet/model.rb

@@ -46,7 +46,7 @@ module WordNet
 			end
 
 			self.descendents.each do |subclass|
-				self.log.info "Resetting database connection for: %p to: %p" % [ subclass, newdb ]
+				self.log.debug "Resetting database connection for: %p to: %p" % [ subclass, newdb ]
 				subclass.db = newdb
 			end
 		end

data/lib/wordnet/morph.rb

@@ -7,12 +7,37 @@ require 'wordnet/model'
 class WordNet::Morph < WordNet::Model( :morphs )
 	include WordNet::Constants
 
+	#                 Table "public.morphs"
+	#  Column  |         Type          |     Modifiers
+	# ---------+-----------------------+--------------------
+	#  morphid | integer               | not null default 0
+	#  morph   | character varying(70) | not null
+	# Indexes:
+	#     "pk_morphs" PRIMARY KEY, btree (morphid)
+	#     "unq_morphs_morph" UNIQUE, btree (morph)
+	# Referenced by:
+	#     TABLE "morphmaps" CONSTRAINT "fk_morphmaps_morphid" FOREIGN KEY (morphid) REFERENCES morphs(morphid)
+	#
+
 	set_primary_key :morphid
 
-	many_to_one :word,
+	#                 Table "public.morphmaps"
+	#  Column  |     Type     |           Modifiers
+	# ---------+--------------+-------------------------------
+	#  wordid  | integer      | not null default 0
+	#  pos     | character(1) | not null default NULL::bpchar
+	#  morphid | integer      | not null default 0
+	# Indexes:
+	#     "pk_morphmaps" PRIMARY KEY, btree (morphid, pos, wordid)
+	#     "k_morphmaps_morphid" btree (morphid)
+	#     "k_morphmaps_wordid" btree (wordid)
+	# Foreign-key constraints:
+	#     "fk_morphmaps_morphid" FOREIGN KEY (morphid) REFERENCES morphs(morphid)
+	#     "fk_morphmaps_wordid" FOREIGN KEY (wordid) REFERENCES words(wordid)
+	many_to_many :words,
 		:join_table => :morphmaps,
-		:left_key => :wordid,
-		:right_key => :morphid
+		:right_key  => :wordid,
+		:left_key   => :morphid
 
 
 	### Return the stringified word; alias for #lemma.

data/lib/wordnet/sumoterm.rb

@@ -5,17 +5,72 @@ require 'wordnet/model'
 require 'wordnet/constants'
 
 
-# SUMO terms
+# 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.
 class WordNet::SumoTerm < WordNet::Model( :sumoterms )
 	include WordNet::Constants
 
+	#                       Table "public.sumoterms"
+	#         Column         |          Type          |     Modifiers
+	# -----------------------+------------------------+--------------------
+	#  sumoid                | integer                | not null default 0
+	#  sumoterm              | character varying(128) | not null
+	#  ischildofattribute    | boolean                |
+	#  ischildoffunction     | boolean                |
+	#  ischildofpredicate    | boolean                |
+	#  ischildofrelation     | boolean                |
+	#  iscomparisonop        | boolean                |
+	#  isfunction            | boolean                |
+	#  isinstance            | boolean                |
+	#  islogical             | boolean                |
+	#  ismath                | boolean                |
+	#  isquantifier          | boolean                |
+	#  isrelationop          | boolean                |
+	#  issubclass            | boolean                |
+	#  issubclassofattribute | boolean                |
+	#  issubclassoffunction  | boolean                |
+	#  issubclassofpredicate | boolean                |
+	#  issubclassofrelation  | boolean                |
+	#  issubrelation         | boolean                |
+	#  issuperclass          | boolean                |
+	#  issuperrelation       | boolean                |
+	# Indexes:
+	#     "pk_sumoterms" PRIMARY KEY, btree (sumoid)
+	#     "unq_sumoterms_sumoterm" UNIQUE, btree (sumoterm)
+	# Referenced by:
+	#     TABLE "sumomaps" CONSTRAINT "fk_sumomaps_sumoid" FOREIGN KEY (sumoid) REFERENCES sumoterms(sumoid)
+	#     TABLE "sumoparsemaps" CONSTRAINT "fk_sumoparsemaps_sumoid" FOREIGN KEY (sumoid) REFERENCES sumoterms(sumoid)
 	set_primary_key :sumoid
 
+
+	#
+	# Associations
+	#
+
 	# SUMO Term -> [ SUMO Map ] -> [ Synset ]
+
+	#             Table "public.sumomaps"
+	#   Column   |     Type     |     Modifiers
+	# -----------+--------------+--------------------
+	#  synsetid  | integer      | not null default 0
+	#  sumoid    | integer      | not null default 0
+	#  sumownrel | character(1) | not null
+	# Indexes:
+	#     "pk_sumomaps" PRIMARY KEY, btree (synsetid)
+	#     "k_sumomaps_sumoid" btree (sumoid)
+	#     "k_sumomaps_sumownrel" btree (sumownrel)
+	# Foreign-key constraints:
+	#     "fk_sumomaps_sumoid" FOREIGN KEY (sumoid) REFERENCES sumoterms(sumoid)
+	#     "fk_sumomaps_synsetid" FOREIGN KEY (synsetid) REFERENCES synsets(synsetid)
+
+	##
+	# WordNet::Synsets that are related to this term
 	many_to_many :synsets,
 		:join_table => :sumomaps,
-		:left_key => :sumoid,
-		:right_key => :synsetid
+		:left_key   => :sumoid,
+		:right_key  => :synsetid
 
 end # class WordNet::SumoTerm
 

data/lib/wordnet/synset.rb

@@ -11,31 +11,53 @@ require 'wordnet/model'
 # WordNet lexical database. A synonym set is a set of words that are
 # interchangeable in some context.
 #
-#   ss = WordNet::Synset[ 106286395 ]
-#   # => #<WordNet::Synset @values={:synsetid=>106286395, :pos=>"n",
-#       :lexdomainid=>10,
-#       :definition=>"a unit of language that native speakers can identify"}>
+# We can either fetch the synset from a connected Lexicon:
 #
-#   ss.words.map( &:lemma )
-#   # => ["word"]
+#    lexicon = WordNet::Lexicon.new( 'postgres://localhost/wordnet30' )
+#    ss = lexicon[ :first, 'time' ]
+#    # => #<WordNet::Synset:0x7ffbf2643bb0 {115265518} 'commencement, first,
+#    #       get-go, offset, outset, start, starting time, beginning, kickoff,
+#    #       showtime' (noun): [noun.time] the time at which something is
+#    #       supposed to begin>
 #
-#   ss.hypernyms
-#   # => [#<WordNet::Synset @values={:synsetid=>106284225, :pos=>"n",
-#       :lexdomainid=>10,
-#       :definition=>"one of the natural units into which [...]"}>]
+# or if you've already created a Lexicon, use its connection indirectly to
+# look up a Synset by its ID:
 #
-#   ss.hyponyms
-#   # => [#<WordNet::Synset @values={:synsetid=>106287620, :pos=>"n",
-#       :lexdomainid=>10,
-#       :definition=>"a word or phrase spelled by rearranging [...]"}>,
-#     #<WordNet::Synset @values={:synsetid=>106287859, :pos=>"n",
-#       :lexdomainid=>10,
-#       :definition=>"a word (such as a pronoun) used to avoid [...]"}>,
-#     #<WordNet::Synset @values={:synsetid=>106288024, :pos=>"n",
-#       :lexdomainid=>10,
-#       :definition=>"a word that expresses a meaning opposed [...]"}>,
-#     ...
-#    ]
+#    ss = WordNet::Synset[ 115265518 ]
+#    # => #<WordNet::Synset:0x7ffbf257e928 {115265518} 'commencement, first,
+#    #       get-go, offset, outset, start, starting time, beginning, kickoff,
+#    #       showtime' (noun): [noun.time] the time at which something is
+#    #       supposed to begin>
+#
+# You can fetch a list of the lemmas (base forms) of the words included in the
+# synset:
+#
+#    ss.words.map( &:lemma )
+#    # => ["commencement", "first", "get-go", "offset", "outset", "start",
+#    #     "starting time", "beginning", "kickoff", "showtime"]
+#
+# But the primary reason for a synset is its lexical and semantic links to
+# other words and synsets. For instance, its *hypernym* is the equivalent
+# of its superclass: it's the class of things of which the receiving
+# synset is a member.
+#
+#    ss.hypernyms
+#    # => [#<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
+# subclasses:
+#
+#    ss.hyponyms
+#    # => [#<WordNet::Synset:0x7ffbf25d83b0 {115142167} 'birth' (noun):
+#    #       [noun.time] the time when something begins (especially life)>,
+#    #     #<WordNet::Synset:0x7ffbf25d8298 {115268993} 'threshold' (noun):
+#    #       [noun.time] the starting point for a new state or experience>,
+#    #     #<WordNet::Synset:0x7ffbf25d8180 {115143012} 'incipiency,
+#    #       incipience' (noun): [noun.time] beginning to exist or to be
+#    #       apparent>,
+#    #     #<WordNet::Synset:0x7ffbf25d8068 {115266164} 'starting point,
+#    #       terminus a quo' (noun): [noun.time] earliest limiting point>]
 #
 class WordNet::Synset < WordNet::Model( :synsets )
 	include WordNet::Constants
@@ -313,12 +335,12 @@ class WordNet::Synset < WordNet::Model( :synsets )
 
 
 	### Return any sample sentences.
-    def samples
-        return self.db[:samples].
+	def samples
+		return self.db[:samples].
 			filter( synsetid: self.synsetid ).
 			order( :sampleid ).
-			map( :sample ).all
-    end
+			map( :sample )
+	end
 
 
 	#

data/lib/wordnet/word.rb

@@ -58,6 +58,10 @@ class WordNet::Word < WordNet::Model( :words )
 
 	set_primary_key :wordid
 
+	#
+	# Associations
+	#
+
 	##
 	# The WordNet::Sense objects that relate the word with its Synsets
 	one_to_many :senses,
@@ -79,6 +83,19 @@ class WordNet::Word < WordNet::Model( :words )
 		:right_key => :morphid
 
 
+	#
+	# Dataset methods
+	#
+
+	##
+	# Return a dataset for words matching the given +lemma+.
+	def_dataset_method( :by_lemma ) {|lemma| filter( lemma: lemma ) }
+
+
+	#
+	# Other methods
+	#
+
 	### Return the stringified word; alias for #lemma.
 	def to_s
 		return self.lemma

data/spec/lib/helpers.rb

@@ -11,6 +11,18 @@ BEGIN {
 	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
 }
 
+# SimpleCov test coverage reporting; enable this using the :coverage rake task
+if ENV['COVERAGE']
+	$stderr.puts "\n\n>>> Enabling coverage report.\n\n"
+	require 'simplecov'
+	SimpleCov.start do
+		add_filter 'spec'
+		add_group "Needing tests" do |file|
+			file.covered_percent < 90
+		end
+	end
+end
+
 require 'rspec'
 require 'loggability/spechelpers'
 require 'wordnet'

data/spec/wordnet/lexicon_spec.rb

@@ -33,6 +33,7 @@ describe WordNet::Lexicon do
 		reset_logging()
 	end
 
+
 	context "the default_db_uri method" do
 
 		it "uses the wordnet-defaultdb database gem (if available)" do
@@ -80,77 +81,126 @@ describe WordNet::Lexicon do
 
 	context "with the default database", :requires_database => true do
 
-		before( :all ) do
-			@lexicon = WordNet::Lexicon.new
-		end
+		let( :lexicon ) { WordNet::Lexicon.new }
 
 		context "via its index operator" do
 
 			it "can look up a Synset by ID" do
-				rval = @lexicon[ 101219722 ]
+				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 = lexicon[ 21338 ]
 				rval.should be_a( WordNet::Word )
 				rval.lemma.should == 'carrot'
 			end
 
 			it "can look up the synset for a word and a sense" do
-				ss = @lexicon[ :boot, 3 ]
+				ss = lexicon[ :boot, 3 ]
 				ss.should be_a( WordNet::Synset )
 				ss.definition.should == '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) }
+			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
+			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
+			end
+
 		end
 
 	end
 
 	context "with a PostgreSQL database", :requires_pg do
 
-		before( :all ) do
-			@lexicon = WordNet::Lexicon.new( 'postgres://localhost/wordnet30' )
-		end
+		let( :lexicon ) { WordNet::Lexicon.new(adapter: 'postgres', host: 'localhost', database: 'wordnet30') }
 
 		context "via its index operator" do
 
 			it "can look up a Synset by ID" do
-				rval = @lexicon[ 101219722 ]
+				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 = lexicon[ 21338 ]
 				rval.should be_a( WordNet::Word )
 				rval.lemma.should == 'carrot'
 			end
 
 			it "can look up the synset for a word and a sense" do
-				ss = @lexicon[ :boot, 3 ]
+				ss = lexicon[ :boot, 3 ]
 				ss.should be_a( WordNet::Synset )
 				ss.definition.should == '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 = lexicon[ :boot, 'kick' ]
 				ss.should be_a( WordNet::Synset )
 				ss.definition.should =~ /kick/i
 			end
 
 			it "can look up a synset for a word and a part of speech" do
-				ss = @lexicon[ :boot, :verb ]
+				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 = lexicon[ :boot, :n ]
 				ss.should be_a( WordNet::Synset )
 				ss.definition.should =~ /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
+			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 ]
+			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(
+					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 )
+				sss.should have( 4 ).members
+				sss.should 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
+				lexicon.inspect.should include( "postgres" )
+			end
+
 		end
 	end
 

data/spec/wordnet/semanticlink_spec.rb

@@ -3,7 +3,7 @@
 BEGIN {
 	require 'pathname'
 
-	basedir = Pathname.new( __FILE__ ).dirname.parent
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
 	libdir = basedir + 'lib'
 
 	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
@@ -24,12 +24,6 @@ describe WordNet::SemanticLink, :requires_database => true do
 
 	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
@@ -37,6 +31,26 @@ describe WordNet::SemanticLink, :requires_database => true do
 	end
 
 
+	let( :lexicon ) { WordNet::Lexicon.new  }
+	let( :word )    { lexicon[96814]        } # 'parody'
+	let( :synset )  { word.synsets.first    }
+	let( :semlink ) { synset.semlinks.first }
+
+
+	it "links two synsets together" do
+		semlink.origin.should be_a( WordNet::Synset )
+		semlink.target.should be_a( WordNet::Synset )
+	end
+
+	it "has a Symbolic type" do
+		semlink.type.should == :hypernym
+	end
+
+	it "has a human-readable type name" do
+		semlink.typename.should == 'hypernym'
+	end
+
+
 end
 
 

data/spec/wordnet/synset_spec.rb

@@ -55,31 +55,29 @@ describe WordNet::Synset, :requires_database => true do
 
 	context "for 'floor, level, storey, story (noun)' [103365991]" do
 
-		before( :each ) 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)
-			@synset = WordNet::Synset[ 103365991 ]
-		end
+		# 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] }
 
 
 		it "knows what lexical domain it's from" do
-			@synset.lexical_domain.should == 'noun.artifact'
+			synset.lexical_domain.should == 'noun.artifact'
 		end
 
 		it "can make a Sequel dataset for any of its semantic link relationships" do
-			ds = @synset.semanticlink_dataset( :member_meronyms )
+			ds = synset.semanticlink_dataset( :member_meronyms )
 			ds.should be_a( Sequel::Dataset )
 			ds.first_source_table.should == :synsets
 		end
 
 		it "can make an Enumerator for any of its semantic link relationships" do
-			enum = @synset.semanticlink_enum( :member_meronyms )
+			enum = synset.semanticlink_enum( :member_meronyms )
 			enum.should be_a( Enumerator )
 		end
 
 		it "can recursively traverse its semantic links" do
-			res = @synset.traverse( :hypernyms ).to_a
+			res = synset.traverse( :hypernyms ).to_a
 			res.should have( 6 ).members
 			res.should == [
 				WordNet::Synset[ 104341686 ],
@@ -92,7 +90,7 @@ describe WordNet::Synset, :requires_database => true do
 		end
 
 		it "can return an Enumerator for recursively traversing its semantic links" do
-			enum = @synset.traverse( :hypernyms )
+			enum = synset.traverse( :hypernyms )
 
 			enum.next.should == WordNet::Synset[ 104341686 ]
 			enum.next.should == WordNet::Synset[ 100021939 ]
@@ -104,24 +102,45 @@ describe WordNet::Synset, :requires_database => true do
 				enum.next
 			}.to raise_error( StopIteration )
 		end
+	end
 
 
-		end
-
 	context "for 'knight (noun)' [110238375]" do
 
-		before( :each ) do
-			@synset = @lexicon[ :knight, "noble" ]
-		end
+		let( :synset ) { @lexicon[:knight, "noble"] }
 
 		it "can find the hypernym that it and another synset share in common through the intersection operator" do
-			res = @synset | @lexicon[ :squire ]
+			res = synset | @lexicon[ :squire ]
 			res.should == @lexicon[:person]
 		end
 
+		it "knows what part of speech it's for" do
+			synset.part_of_speech.should == '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 " +
+				"arms and chivalry; today in Great Britain a person honored by the sovereign for personal " +
+				"merit (hypernym: 1, hyponym: 6, instance hyponym: 1)"
+		end
+
 	end
 
 
+	context "for 'congener (noun)' [100003993]" do
+
+		let( :synset ) { @lexicon[:congener] }
+
+		it "can look up its sample sentences" do
+			synset.samples.should have( 2 ).members
+			synset.samples.should include(
+				"lard was also used, though its congener, butter, was more frequently employed",
+				"the American shopkeeper differs from his European congener"
+			)
+		end
+
+	end
+
 
 end
 

data/spec/wordnet/word_spec.rb

@@ -25,12 +25,6 @@ describe WordNet::Word, :requires_database => true do
 
 	before( :all ) do
 		setup_logging( :fatal )
-		@lexicon = WordNet::Lexicon.new
-	end
-
-	before( :each ) do
-		# 'run'
-		@word = @lexicon[ 113377 ]
 	end
 
 	after( :all ) do
@@ -38,19 +32,100 @@ describe WordNet::Word, :requires_database => true do
 	end
 
 
-	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 )
+	let( :lexicon ) { WordNet::Lexicon.new }
+
+
+	context "the Word for 'run'" do
+
+		let( :word ) { lexicon[113377] }
+
+		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 )
+		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 )
+		end
+
+		it "has a dataset for selecting noun synsets" do
+			word.nouns.should be_a( Sequel::Dataset )
+			word.nouns.should have( 16 ).members
+			ss = word.nouns.all
+			ss.should include(
+				lexicon[ :run, 'sequence' ],
+				lexicon[ :run, 'baseball' ],
+				lexicon[ :run, 'act of running' ],
+				lexicon[ :run, 'testing' ]
+			)
+		end
+
+		it "has a dataset for selecting verb synsets" do
+			word.verbs.should be_a( Sequel::Dataset )
+			word.verbs.should have( 41 ).members
+			ss = word.verbs.all
+			ss.should include(
+				lexicon[ :run, 'compete' ],
+				lexicon[ :run, 'be diffused' ],
+				lexicon[ :run, 'liquid' ],
+				lexicon[ :run, 'move fast' ]
+			)
+		end
+
+	end
+
+
+	context "the Word for 'light'" 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
+			ss = word.adjectives.all
+			ss.should include(
+				lexicon[ :light, 'weight' ],
+				lexicon[ :light, 'emit', :adjective ],
+				lexicon[ :light, 'color' ]
+			)
+		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
+			ss = word.adjective_satellites.all
+			ss.should include(
+				lexicon[ :light, 'soil' ],
+				lexicon[ :light, 'calories' ],
+				lexicon[ :light, 'entertainment' ]
+			)
+		end
+
 	end
 
-	it "knows what synsets it has" do
-		senses = @word.senses
-		synsets = @word.synsets
 
-		synsets.should have( senses.length ).members
-		synsets.first.senses.should include( senses.first )
+	context "the Word for 'lightly'" 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
+			ss = word.adverbs.all
+			ss.should include(
+				lexicon[ :lightly, 'indifference' ],
+				lexicon[ :lightly, 'indulging' ],
+				lexicon[ :lightly, 'little weight' ],
+				lexicon[ :lightly, 'quantity' ]
+			)
+		end
+
 	end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wordnet
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.136
+  version: 1.0.0.pre.139
   prerelease: 
 platform: ruby
 authors:
@@ -36,7 +36,7 @@ cert_chain:
   YUhDS0xaZFNLai9SSHVUT3QrZ2JsUmV4OEZBaDhOZUEKY21saFhlNDZwWk5K
   Z1dLYnhaYWg4NWpJang5NWhSOHZPSStOQU01aUg5a09xSzEzRHJ4YWNUS1Bo
   cWo1UGp3RgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-date: 2012-08-15 00:00:00.000000000 Z
+date: 2012-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -150,6 +150,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
@@ -166,28 +182,16 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
-description: ! 'This library is a Ruby interface to WordNet®. WordNet® is an online
-
-  lexical reference system whose design is inspired by current
-
-  psycholinguistic theories of human lexical memory. English nouns, verbs,
-
-  adjectives and adverbs are organized into synonym sets, each
-
-  representing one underlying lexical concept. Different relations link
-
-  the synonym sets.
-
-
-  It uses WordNet-SQL, which is a conversion of the lexicon flatfiles into
-
-  a relational database format. You can either install the ''wordnet-
-
-  defaultdb'' gem, which packages up the SQLite3 version of WordNet-SQL, or
-
-  install your own and point the lexicon at it by passing a Sequel URL to
-
-  the constructor.'
+description: ! "This library is a Ruby interface to WordNet®[http://wordnet.princeton.edu/].\nWordNet®
+  is an online lexical reference system whose design is inspired\nby current psycholinguistic
+  theories of human lexical memory. English\nnouns, verbs, adjectives and adverbs
+  are organized into synonym sets, each\nrepresenting one underlying lexical concept.
+  Different relations link\nthe synonym sets.\n\nThis library uses WordNet-SQL[http://wnsql.sourceforge.net/],
+  which is a\nconversion of the lexicon flatfiles into a relational database format.
+  You\ncan either install the 'wordnet-defaultdb' gem, which packages up the\nSQLite3
+  version of WordNet-SQL, or install your own and point the lexicon\nat it by passing
+  \n{Sequel connection parameters}[http://sequel.rubyforge.org/rdoc/files/doc/opening_databases_rdoc.html]\nto
+  the constructor."
 email:
 - ged@FaerieMUD.org
 executables: []
@@ -268,5 +272,5 @@ rubyforge_project: wordnet
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: This library is a Ruby interface to WordNet®
+summary: This library is a Ruby interface to WordNet®[http://wordnet.princeton.edu/]
 test_files: []