wordnet 0.0.5

data/examples/clothesWithTongues.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby -w
+#
+#	Find all articles of clothing that have tongues (From the synopsis of
+#	Lingua::Wordnet::Analysis)
+#
+
+$LOAD_PATH.unshift "lib"
+require "wordnet"
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the clothes synset as the origin
+clothes = lex.lookup_synsets( "clothes", WordNet::Noun, 1 )
+puts clothes
+
+# Now look up the second sense of tongue (not the anatomical part)
+tongue = lex.lookup_synsets( "tongue", WordNet::Noun, 7 )
+puts tongue
+
+# Now traverse all hyponyms of the clothes synset, and check for "tongue" among
+# each one's meronyms. We print any that we find.
+clothes.traverse( :hyponyms ) do |syn,depth|
+	if syn.search( :meronyms, tongue )
+		puts "Has a tongue: #{syn}"
+	end
+end
+

data/examples/distance.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby -w
+#
+#	Find the distance between the first senses of two nouns
+#
+
+$LOAD_PATH.unshift "lib"
+require "wordnet"
+
+raise RuntimeError, "You must specify two nouns." if ARGV.length < 2
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the two words
+word1 = lex.lookup_synsets( ARGV[0], WordNet::Noun, 1 )
+unless word1
+	puts "Couldn't find a synset for #{ARGV[0]}."
+	exit
+end
+word2 = lex.lookup_synsets( ARGV[1], WordNet::Noun, 1 )
+unless word2
+	puts "Couldn't find a synset for #{ARGV[1]}."
+	exit
+end
+
+# Analyze the distance
+distance = word1.distance( :hypernyms, word2 )
+
+# If we got a distance, display it.
+if distance
+	puts "The hypernym distance between #{word1.words[0]} and #{word2.words[0]} is: #{distance}"
+
+# If we didn't get a distance, the second word isn't a hypernym of the first
+else
+	puts "#{word1.words[0]} is not a kind of #{word2.words[0]}, apparently."
+end
+

data/examples/domainTree.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+#
+#	Find all the domains of all senses of a given noun, and display them in a heirarchy.
+#
+
+$LOAD_PATH.unshift "lib"
+require "wordnet"
+
+raise RuntimeError, "No word specified." if ARGV.empty?
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+origins = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+
+# Use the analyzer to traverse domains of the synset, adding a string for each
+# one with indentation for the level
+origins.each_index {|i|
+	treeComponents = []
+	origins[i].traverse( :domains ) {|syn,depth|
+		treeComponents << "  #{'  ' * depth}#{syn.words[0]} -- #{syn.gloss.split(/;/)[0]}"
+	}
+
+	puts "\nDomain tree for sense #{i} of #{ARGV[0]}:\n" + treeComponents.join( "\n" )
+	puts "Tree has #{treeComponents.length} synsets."
+}

data/examples/gcs.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby -w
+#
+#	Find least general hypernymial synsets between all noun senses of two words.
+#
+
+$LOAD_PATH.unshift "lib"
+require "wordnet"
+
+raise RuntimeError, "You must specify two words." if ARGV.length != 2
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+word1Syns = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+word2Syns = lex.lookup_synsets( ARGV[1], WordNet::Noun )
+
+def debugMsg( message )
+	return unless $DEBUG
+	$stderr.puts message
+end
+
+# Use the analyzer to traverse hypernyms of the synset, adding a string for each
+# one with indentation for the level
+word1Syns.each {|syn|
+	debugMsg( ">>> Searching with #{syn.wordlist} as the origin." )
+
+	word2Syns.each {|secondSyn|
+		debugMsg( "  Comparing #{secondSyn.wordlist} to the origin." )
+
+		# The intersection of the two syns is the most-specific hypernym they
+		# share in common.
+		commonSyn = (syn | secondSyn)
+
+		if commonSyn
+			puts <<-"EOF".gsub( /^\t{3}/, '' )
+			----
+			  #{syn.words.join(', ')}
+			  #{syn.gloss}
+			and
+			  #{secondSyn.words.join(', ')}
+			  #{secondSyn.gloss}
+			are both instances of
+			  #{commonSyn.words.join(', ')}
+			  #{commonSyn.gloss}.
+			----
+			EOF
+		else
+			debugMsg( "    No synsets in common." )
+		end
+	}
+
+	debugMsg( "  done with #{syn.wordlist}" )
+}

data/examples/holonymTree.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+#
+#	Find all the holonyms of all senses of a given noun, and display them in a heirarchy.
+#
+
+$LOAD_PATH.unshift "lib"
+require "wordnet"
+
+raise RuntimeError, "No word specified." if ARGV.empty?
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+origins = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+
+# Use the analyzer to traverse holonyms of the synset, adding a string for each
+# one with indentation for the level
+origins.each_index {|i|
+	treeComponents = []
+	origins[i].traverse( :holonyms ) {|syn,depth|
+		treeComponents << "  #{'  ' * depth}#{syn.words[0]} -- #{syn.gloss.split(/;/)[0]}"
+	}
+
+	puts "\nHolonym tree for sense #{i} of #{ARGV[0]}:\n" + treeComponents.join( "\n" )
+	puts "Tree has #{treeComponents.length} synsets."
+}

data/examples/hypernymTree.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby -w
+#
+#	Find all the hypernyms of all senses of a given noun and display them in a
+#	heirarchy
+#
+
+$LOAD_PATH.unshift "lib"
+require 'wordnet'
+
+raise RuntimeError, "No word specified." if ARGV.empty?
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+origins = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+
+# Use the analyzer to traverse hypernyms of the synset, adding a string for each
+# one with indentation for the level
+origins.each_index {|i|
+	treeComponents = []
+	origins[i].traverse( :hypernyms ) {|syn,depth|
+		treeComponents << "  #{'  ' * depth}#{syn.words[0]} -- #{syn.gloss.split(/;/)[0]}"
+	}
+
+	puts "\nHypernym tree for sense #{i} of #{ARGV[0]}:\n" + treeComponents.join( "\n" )
+	puts "Tree has #{treeComponents.length} synsets."
+}

data/examples/hyponymTree.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby -w
+#
+#	Find all the hyponyms of all senses of a given noun and display them in a
+#	heirarchy
+#
+
+$LOAD_PATH.unshift "lib"
+require 'wordnet'
+
+raise RuntimeError, "No word specified." if ARGV.empty?
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+origins = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+
+# Use the analyzer to traverse hyponyms of the synset, adding a string for each
+# one with indentation for the level
+origins.each_index {|i|
+	treeComponents = []
+	origins[i].traverse( :hyponyms ) {|syn,depth|
+		treeComponents << "  #{'  ' * depth}#{syn.words[0]} -- #{syn.gloss.split(/;/)[0]}"
+	}
+
+	puts "\nHyponym tree for sense #{i} of #{ARGV[0]}:\n" + treeComponents.join( "\n" )
+	puts "Tree has #{treeComponents.length} synsets."
+}

data/examples/memberTree.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+#
+#	Find all the members of all senses of a given noun, and display them in a heirarchy.
+#
+
+$LOAD_PATH.unshift "lib"
+require "wordnet"
+
+raise RuntimeError, "No word specified." if ARGV.empty?
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+origins = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+
+# Use the analyzer to traverse members of the synset, adding a string for each
+# one with indentation for the level
+origins.each_index {|i|
+	treeComponents = []
+	origins[i].traverse( :members ) {|syn,depth|
+		treeComponents << "  #{'  ' * depth}#{syn.words[0]} -- #{syn.gloss.split(/;/)[0]}"
+	}
+
+	puts "\nMember tree for sense #{i} of #{ARGV[0]}:\n" + treeComponents.join( "\n" )
+	puts "Tree has #{treeComponents.length} synsets."
+}

data/examples/meronymTree.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby -w
+#
+#	Find all meronyms (components) of each sense of a given noun and display
+#	them heirarchically
+#
+
+$LOAD_PATH.unshift "lib"
+require 'wordnet'
+
+raise RuntimeError, "No word specified." if ARGV.empty?
+
+# Create the lexicon
+lex = WordNet::Lexicon.new
+
+# Look up the synsets for the specified word
+origins = lex.lookup_synsets( ARGV[0], WordNet::Noun )
+
+# Use the analyzer to traverse meronyms of the synset, adding a string for each
+# one with indentation for the level
+origins.each_index {|i|
+	treeComponents = []
+	origins[i].traverse( :meronyms ) {|syn,depth|
+		treeComponents << "  #{'  ' * depth}#{syn.words[0]} -- #{syn.gloss.split(/;/)[0]}"
+	}
+
+	puts "\nMeronym tree for sense #{i} of #{ARGV[0]}:\n" + treeComponents.join( "\n" )
+	puts "Tree has #{treeComponents.length} synsets."
+}
+

data/lib/wordnet.rb

@@ -0,0 +1,87 @@
+#
+# WordNet - A Ruby interface to the WordNet lexical database
+#
+# == Synopsis
+# 
+#   require "WordNet"
+# 
+#   # Create a new lexicon object
+#   lex = WordNet::Lexicon::new
+# 
+#   # Look up the synsets for "language" and "computer program"
+#   languageSynset = lex.lookup_synsets( "language", WordNet::Noun, 3 )
+#   programSynset = lex.lookup_synsets( "program", WordNet::Noun, 3 )
+# 
+#   # Create a new synset for programming languages, set its gloss, link it to its
+#   # hypernym and holonym, and save everything to the database.
+#   progLangSynset = lex.create_synset( "programming language", WordNet::Noun )
+#   progLangSynset.gloss = "a system of human-readable symbols and words "\
+#		"for encoding instructions for a computer"
+#   progLangSynset.hypernyms += languageSynset
+#   languageSynset.hyponyms += progLangSynset
+#   progLangSynset.holonyms += programSynset
+#	programSynset.stuff_meronyms += progLangSynset
+#   [ progLangSynset, programSynset, languageSynset ].each do |synset|
+# 	  synset.store
+#   end
+# 
+#   # Create a new synset for Ruby, link it, and save it
+#   rubySynset = lex.create_synset( "Ruby", Wordnet::Noun )
+#   rubySynset.gloss = "an interpreted scripting language for quick and easy object-oriented programming"
+#   rubySynset.hypernyms += languageSyn ; languageSynset.hyponyms += rubySyn
+#   rubySynset.write ; languageSynset.write
+# 
+# == Description
+#
+# This is a Ruby interface to the WordNet lexical database. It's mostly a port
+# of Dan Brian's Lingua::Wordnet Perl module, modified a bit to be more
+# Ruby-ish.
+#
+# == Author
+#
+# The Lingua::Wordnet module by Dan Brian, on which this code is based, falls under
+# the following license:
+#
+#   Copyright 1999,2000,2001 by Dan Brian.
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the same terms as Perl itself.
+#
+# Written by Michael Granger <ged@FaerieMUD.org>
+#
+# Copyright (c) 2002,2003,2005 The FaerieMUD Consortium. All rights reserved.
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the terms of the Perl Artistic License. (See
+# http://language.perl.com/misc/Artistic.html)
+#
+# == Version
+#
+#  $Id: wordnet.rb 90 2008-07-09 23:02:53Z deveiant $
+#
+
+# Try to provide underbarred alternatives for camelCased methods. Requires the
+# 'CrossCase' module.
+begin
+	require 'crosscase'
+rescue LoadError
+end
+
+### The main namespace for WordNet classes
+module WordNet
+
+	# Revision tag
+	SvnRev = %q$Rev: 90 $
+
+	# Id tag
+	SvnId = %q$Id: wordnet.rb 90 2008-07-09 23:02:53Z deveiant $
+
+	# Release version
+	VERSION = '0.0.5'
+
+	require 'wordnet/constants'
+	require 'wordnet/lexicon'
+	require 'wordnet/synset'
+
+end # module WordNet
+

data/lib/wordnet/constants.rb

@@ -0,0 +1,301 @@
+#!/usr/bin/ruby
+# 
+# This is a module containing constants used in the WordNet interface for
+# Ruby. They are contained in a module to facilitate their easy inclusion in
+# other namespaces. All constants in this module are also contained in the
+# WordNet namespace itself.
+#
+# E.g.,
+#
+#	WordNet::Adjective == WordNet::Constants::Adjective
+#
+# If you do:
+#	include WordNet::Constants
+#
+# then:
+#	Adjective == WordNet::Adjective
+# 
+# == Synopsis
+# 
+#   require 'wordnet'
+#	include WordNet::Constants
+#
+#	lex = WordNet::Lexicon::new
+#	origins = lex.lookup_synsets( "shoe", Noun )
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# == Copyright
+#
+# Copyright (c) 2003-2008 The FaerieMUD Consortium. All rights reserved.
+# 
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the terms of the Perl Artistic License. (See
+# http://language.perl.com/misc/Artistic.html)
+# 
+# == Version
+#
+#  $Id: constants.rb 90 2008-07-09 23:02:53Z deveiant $
+# 
+module WordNet
+
+	### Constant-container module
+	module Constants
+
+		# Synset syntactic-category names -> indicators
+		SYNTACTIC_CATEGORIES = {
+			:noun		=> "n",
+			:verb		=> "v",
+			:adjective	=> "a",
+			:adverb		=> "r",
+			:other		=> "s",
+		}
+		# Syntactic-category indicators -> names
+		SYNTACTIC_SYMBOLS = SYNTACTIC_CATEGORIES.invert
+
+		# Map the categories into their own constants (eg., Noun)
+		SYNTACTIC_CATEGORIES.each do |sym,val|
+			cname = sym.to_s.capitalize
+			const_set( cname, val )
+		end
+
+		# Information about pointer types is contained in the wninput(5WN)
+		# manpage.
+
+		# Synset pointer typenames -> indicators
+		POINTER_TYPES = {
+			:antonym		=> '!',
+			:hypernym		=> '@',
+			:entailment		=> '*',
+			:hyponym		=> '~',
+			:meronym		=> '%',
+			:holonym		=> '#',
+			:cause			=> '>',
+			:verb_group		=> %{$},
+			:similar_to		=> '&',
+			:participle		=> '<',
+			:pertainym		=> '\\',
+			:attribute		=> '=',
+			:derived_from	=> '\\',
+			:see_also		=> '^',
+			:derivation		=> '+',
+			:domain			=> ';',
+			:member			=> '-',
+		}
+
+		# Synset pointer indicator -> typename
+		POINTER_SYMBOLS = POINTER_TYPES.invert
+
+		# Map the pointer types into their own symbols (eg., :verb_group => VerbGroup)
+		POINTER_TYPES.each do |sym,val|
+			cname = sym.to_s.gsub( /(?:^|_)(.)/ ) { $1.upcase }
+			const_set( cname, val )
+		end
+
+		# Hypernym synset pointer types
+		HYPERNYM_TYPES = {
+			nil             => '@', # Install non-subtype methods, too
+			:instance       => '@i',
+		}
+
+		# Hypernym indicator -> type map
+		HYPERNYM_SYMBOLS = HYPERNYM_TYPES.invert
+
+		# Hyponym synset pointer types
+		HYPONYM_TYPES = {
+			nil             => '~', # Install non-subtype methods, too
+			:instance       => '~i',
+		}
+
+		# Hyponym indicator -> type map
+		HYPONYM_SYMBOLS = HYPONYM_TYPES.invert
+
+		# Meronym synset pointer types
+		MERONYM_TYPES = {
+			:member			=> '%m',
+			:stuff			=> '%s',
+			:portion		=> '%o',
+			:component		=> '%p',
+			:feature		=> '%f',
+			:phase			=> '%a',
+			:place			=> '%l',
+		}
+
+		# Meronym indicator -> type map
+		MERONYM_SYMBOLS = MERONYM_TYPES.invert
+
+		# Map the meronym types into their own constants (eg., MemberMeronym)
+		MERONYM_TYPES.each do |sym,val|
+			cname = sym.to_s.capitalize + "Meronym"
+			const_set( cname, val )
+		end
+
+		# Holonym synset pointer types
+		HOLONYM_TYPES = {
+			:member			=> '#m',
+			:stuff			=> '#s',
+			:portion		=> '#o',
+			:component		=> '#p',
+			:feature		=> '#f',
+			:phase			=> '#a',
+			:place			=> '#l',
+		}
+
+		# Holonym indicator -> type map
+		HOLONYM_SYMBOLS = HOLONYM_TYPES.invert
+
+		# Map the holonym types into their own constants (eg., MemberHolonym)
+		HOLONYM_TYPES.each do |sym,val|
+			cname = sym.to_s.capitalize + "Holonym"
+			const_set( cname, val )
+		end
+
+		# Domain synset pointer types
+		DOMAIN_TYPES = {
+			:category		=> ';c',
+			:region			=> ';r',
+			:usage			=> ';u',
+		}
+
+		# Domain indicator -> type map
+		DomainSymbols = DOMAIN_TYPES.invert
+
+		# Map the domain types into their own constants (eg., CategoryDomain)
+		DOMAIN_TYPES.each do |sym,val|
+			cname = sym.to_s.capitalize + "Domain"
+			const_set( cname, val )
+		end
+
+		# Member synset pointer types
+		MEMBER_TYPES = {
+			:category		=> '-c',
+			:region			=> '-r',
+			:usage			=> '-u',
+		}
+
+		# Member indicator -> type map
+		MEMBER_SYMBOLS = MEMBER_TYPES.invert
+
+		# Map the member types into their own constants (eg., CategoryMember)
+		MEMBER_TYPES.each do |sym,val|
+			cname = sym.to_s.capitalize + "Member"
+			const_set( cname, val )
+		end
+
+		# Map of primary types to maps of their subtypes 
+		POINTER_SUBTYPES = {
+			:hyponym    => HYPONYM_TYPES,
+			:hypernym   => HYPERNYM_TYPES,
+			:meronym	=> MERONYM_TYPES,
+			:holonym	=> HOLONYM_TYPES,
+			:member		=> MEMBER_TYPES,
+			:domain		=> DOMAIN_TYPES,
+		}
+
+
+		# Record-part delimiter
+		DELIM = '||'
+		DELIM_RE = Regexp::new( Regexp::quote(DELIM) )
+
+		# Record-subpart delimiter
+		SUB_DELIM = '|'
+		SUB_DELIM_RE = Regexp::new( Regexp::quote(SUB_DELIM) )
+
+		# Lexicographer file index -- from lexnames(5WN)
+		LEXFILES = [
+			"adj.all",
+			"adj.pert",         
+			"adv.all",          
+			"noun.Tops",        
+			"noun.act",         
+			"noun.animal",      
+			"noun.artifact",        
+			"noun.attribute",       
+			"noun.body",        
+			"noun.cognition",       
+			"noun.communication",   
+			"noun.event",       
+			"noun.feeling",     
+			"noun.food",        
+			"noun.group",       
+			"noun.location",        
+			"noun.motive",      
+			"noun.object",      
+			"noun.person",      
+			"noun.phenomenon",      
+			"noun.plant",       
+			"noun.possession",      
+			"noun.process",     
+			"noun.quantity",        
+			"noun.relation",        
+			"noun.shape",       
+			"noun.state",       
+			"noun.substance",       
+			"noun.time",        
+			"verb.body",        
+			"verb.change",      
+			"verb.cognition",       
+			"verb.communication",   
+			"verb.competition",     
+			"verb.consumption",     
+			"verb.contact",     
+			"verb.creation",        
+			"verb.emotion",     
+			"verb.motion",      
+			"verb.perception",
+			"verb.possession",      
+			"verb.social",      
+			"verb.stative",     
+			"verb.weather",     
+			"adj.ppl"
+		]
+
+		# Verb sentences (?) -- used in building verb frames.
+		VERB_SENTS = [
+			"",
+			"Something ----s",
+			"Somebody ----s",
+			"It is ----ing",
+			"Something is ----ing PP",
+			"Something ----s something Adjective/Noun",
+			"Something ----s Adjective/Noun",
+			"Somebody ----s Adjective",
+			"Somebody ----s something",
+			"Somebody ----s somebody",
+			"Something ----s somebody",
+			"Something ----s something",
+			"Something ----s to somebody",
+			"Somebody ----s on something",
+			"Somebody ----s somebody something",
+			"Somebody ----s something to somebody",
+			"Somebody ----s something from somebody",
+			"Somebody ----s somebody with something",
+			"Somebody ----s somebody of something",
+			"Somebody ----s something on somebody",
+			"Somebody ----s somebody PP",
+			"Somebody ----s something PP",
+			"Somebody ----s PP",
+			"Somebody's (body part) ----s",
+			"Somebody ----s somebody to INFINITIVE",
+			"Somebody ----s somebody INFINITIVE",
+			"Somebody ----s that CLAUSE",
+			"Somebody ----s to somebody",
+			"Somebody ----s to INFINITIVE",
+			"Somebody ----s whether INFINITIVE",
+			"Somebody ----s somebody into V-ing something",
+			"Somebody ----s something with something",
+			"Somebody ----s INFINITIVE",
+			"Somebody ----s VERB-ing",
+			"It ----s that CLAUSE",
+			"Something ----s INFINITIVE"
+		]
+
+
+	end # module Constants
+
+	# Make the constants available under the WordNet namespace, too.
+	include Constants
+
+end # module WordNet