wordnet 0.0.5 → 1.0.0.pre.126

data/lib/wordnet/lexicon.rb

@@ -1,430 +1,202 @@
 #!/usr/bin/ruby
-#
-# WordNet Lexicon object class
-# 
-# == Synopsis
-# 
-#	lexicon = WordNet::Lexicon.new( dictpath )
-# 
-# == Description
-# 
-# Instances of this class abstract access to the various databases of the
-# WordNet lexicon. It can be used to look up and search for WordNet::Synsets.
-# 
-# == Author
-# 
-# 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)
-# 
-# Much of this code was inspired by/ported from the Lingua::Wordnet Perl module
-# by Dan Brian.
-# 
-# == Version
-#
-# $Id: lexicon.rb 93 2008-07-12 00:56:49Z deveiant $
-# 
-
-require 'rbconfig'
+
 require 'pathname'
-require 'bdb'
-require 'sync'
+require 'rubygems'
 
+require 'wordnet' unless defined?( WordNet )
 require 'wordnet/constants'
+require 'wordnet/mixins'
 require 'wordnet/synset'
+require 'wordnet/word'
 
-### Lexicon exception - something has gone wrong in the internals of the
-### lexicon.
-class WordNet::LexiconError < StandardError ; end
-
-### Lookup error - the object being looked up either doesn't exist or is
-### malformed
-class WordNet::LookupError < StandardError ; end
 
-### WordNet lexicon class - abstracts access to the WordNet lexical
-### databases, and provides factory methods for looking up and creating new
-### WordNet::Synset objects.
+# WordNet lexicon class - abstracts access to the WordNet lexical
+# database, and provides factory methods for looking up words and synsets.
 class WordNet::Lexicon
-	include WordNet::Constants
-	include CrossCase if defined?( CrossCase )
-
-	# Subversion Id
-	SvnId = %q$Id: lexicon.rb 93 2008-07-12 00:56:49Z deveiant $
+	include WordNet::Constants,
+	        WordNet::Loggable
 
-	# Subversion revision
-	SvnRev = %q$Rev: 93 $
+	# 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
 
 
-	#############################################################
-	### B E R K E L E Y D B	  C O N F I G U R A T I O N
-	#############################################################
-
-	# The path to the WordNet BerkeleyDB Env. It lives in the directory that
-	# this module is in.
-	DEFAULT_DB_ENV = File::join( Config::CONFIG['datadir'], "ruby-wordnet" )
+	# Add the logger device to the default options after it's been loaded
+	WordNet::DEFAULT_DB_OPTIONS.merge!( :logger => [WordNet.logger] )
+	# WordNet::DEFAULT_DB_OPTIONS.merge!( :logger => [LogTracer.new] )
 
-	# Options for the creation of the Env object
-	ENV_OPTIONS = {
-		:set_timeout	=> 50,
-		:set_lk_detect	=> 1,
-		:set_verbose	=> false,
-		:set_lk_max     => 3000,
-	}
 
-	# Flags for the creation of the Env object (read-write and read-only)
-	ENV_FLAGS_RW = BDB::CREATE|BDB::INIT_TRANSACTION|BDB::RECOVER|BDB::INIT_MPOOL
-	ENV_FLAGS_RO = BDB::INIT_MPOOL
-
-
-	#############################################################
-	### I N S T A N C E	  M E T H O D S
-	#############################################################
+	### Get the Sequel URI of the default database, if it's installed.
+	def self::default_db_uri
+		WordNet.log.debug "Fetching the default db URI"
 
-	### Create a new WordNet::Lexicon object that will read its data from
-	### the given +dbenv+ (a BerkeleyDB env directory). The database will be
-	### opened with the specified +mode+, which can either be a numeric 
-	### octal mode (e.g., 0444) or one of (:readonly, :readwrite).
-	def initialize( dbenv=DEFAULT_DB_ENV, mode=:readonly )
-		@mode = normalize_mode( mode )
-		debug_msg "Mode is: %04o" % [ mode ]
-
-		envflags = 0
-		dbflags  = 0
-
-		unless self.readonly?
-			debug_msg "Using read/write flags"
-			envflags = ENV_FLAGS_RW
-			dbflags = BDB::CREATE
+		datadir = nil
+		if Gem.datadir( 'wordnet-defaultdb' )
+			datadir = Pathname( Gem.datadir('wordnet-defaultdb') )
 		else
-			debug_msg "Using readonly flags"
-			envflags = ENV_FLAGS_RO
-			dbflags = 0
-		end
-
-		debug_msg "Env flags are: %0s, dbflags are %0s" %
-			[ envflags.to_s(2), dbflags.to_s(2) ]
-
-		begin
-			@env = BDB::Env.new( dbenv, envflags, ENV_OPTIONS )
-			@index_db = @env.open_db( BDB::BTREE, "index", nil, dbflags, @mode )
-			@data_db = @env.open_db( BDB::BTREE, "data", nil, dbflags, @mode )
-			@morph_db = @env.open_db( BDB::BTREE, "morph", nil, dbflags, @mode )
-		rescue StandardError => err
-			msg = "Error while opening Ruby-WordNet data files: #{dbenv}: %s" % 
-				[ err.message ]
-			raise err, msg, err.backtrace
-		end
-	end
-
-
-
-	######
-	public
-	######
-
-	# The BDB::Env object which contains the wordnet lexicon's databases.
-	attr_reader :env
-
-	# The handle to the index table
-	attr_reader :index_db
-
-	# The handle to the synset data table
-	attr_reader :data_db
-
-	# The handle to the morph table
-	attr_reader :morph_db
-
-
-	### Returns +true+ if the lexicon was opened in read-only mode.
-	def readonly?
-		( @mode & 0200 ).nonzero? ? false : true
-	end
-	
-	
-	### Returns +true+ if the lexicon was opened in read-write mode.
-	def readwrite?
-		! self.readonly?
-	end
-	
-
-	### Close the lexicon's database environment
-	def close
-		@env.close if @env
-	end
-
-
-	### Checkpoint the database. (BerkeleyDB-specific)
-	def checkpoint( bytes=0, minutes=0 )
-		@env.checkpoint
-	end
-
-
-	### Remove any archival logfiles for the lexicon's database
-	### environment. (BerkeleyDB-specific).
-	def clean_logs
-		return unless self.readwrite?
-		self.archlogs.each do |logfile|
-			File::chmod( 0777, logfile )
-			File::delete( logfile )
+			WordNet.log.warn "  no defaultdb gem; looking for the development database"
+			datadir = Pathname( __FILE__ ).dirname.parent.parent +
+				'wordnet-defaultdb/data/wordnet-defaultdb'
 		end
-	end
 
+		dbfile = datadir + 'wordnet30.sqlite'
+		WordNet.log.debug "  dbfile is: %s" % [ dbfile ]
 
-	### Returns an integer of the familiarity/polysemy count for +word+ as a
-	### +part_of_speech+. Note that polysemy can be identified for a given
-	### word by counting the synsets returned by #lookup_synsets.
-	def familiarity( word, part_of_speech, polyCount=nil )
-		wordkey = self.make_word_key( word, part_of_speech )
-		return nil unless @index_db.key?( wordkey )
-		@index_db[ wordkey ].split( WordNet::SUB_DELIM_RE ).length
-	end
-
-
-	### Look up sysets (Wordnet::Synset objects) matching +text+ as a
-	### +part_of_speech+, where +part_of_speech+ is one of +WordNet::Noun+,
-	### +WordNet::Verb+, +WordNet::Adjective+, or +WordNet::Adverb+. Without
-	### +sense+, #lookup_synsets will return all matches that are a
-	### +part_of_speech+. If +sense+ is specified, only the synset object that
-	### matches that particular +part_of_speech+ and +sense+ is returned.
-	def lookup_synsets( word, part_of_speech, sense=nil )
-		wordkey = self.make_word_key( word, part_of_speech )
-		pos = self.make_pos( part_of_speech )
-		synsets = []
-
-		# Look up the index entry, trying first the word as given, and if
-		# that fails, trying morphological conversion.
-		entry = @index_db[ wordkey ]
-
-		if entry.nil? && (word = self.morph( word, part_of_speech ))
-			wordkey = self.make_word_key( word, part_of_speech )
-			entry = @index_db[ wordkey ]
-		end
-
-		# If the lookup failed both ways, just abort
-		return nil unless entry
-
-		# Make synset keys from the entry, narrowing it to just the sense
-		# requested if one was specified.
-		synkeys = entry.split( SUB_DELIM_RE ).collect {|off| "#{off}%#{pos}" }
-		if sense
-			return lookup_synsets_by_key( synkeys[sense - 1] )
+		if dbfile.exist?
+			return "sqlite:#{dbfile}"
 		else
-			return [ lookup_synsets_by_key(*synkeys) ].flatten
+			return nil
 		end
 	end
 
 
-	### Returns the WordNet::Synset objects corresponding to the +keys+
-	### specified. The +keys+ are made up of the target synset's "offset"
-	### and syntactic category catenated together with a '%' character.
-	def lookup_synsets_by_key( *keys )
-		synsets = []
-
-		keys.each {|key|
-			raise WordNet::LookupError, "Failed lookup of synset '#{key}':"\
-				"No such synset" unless @data_db.key?( key )
-
-			data = @data_db[ key ]
-			offset, part_of_speech = key.split( /%/, 2 )
-			synsets << WordNet::Synset::new( self, offset, part_of_speech, nil, data )
-		}
-
-		return *synsets
-	end
-	alias_method :lookup_synsetsByOffset, :lookup_synsets_by_key
-
-
-	### Returns a form of +word+ as a part of speech +part_of_speech+, as
-	### found in the WordNet morph files. The #lookup_synsets method perfoms
-	### morphological conversion automatically, so a call to #morph is not
-	### required.
-	def morph( word, part_of_speech )
-		return @morph_db[ self.make_word_key(word, part_of_speech) ]
-	end
-
+	#############################################################
+	### I N S T A N C E	  M E T H O D S
+	#############################################################
 
-	### Returns the result of looking up +word+ in the inverse of the WordNet
-	### morph files. _(This is undocumented in Lingua::Wordnet)_
-	def reverse_morph( word )
-		@morph_db.invert[ word ]
-	end
+	### 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
 
+		options = WordNet::DEFAULT_DB_OPTIONS.merge( args.shift || {} )
 
-	### Returns an array of compound words matching +text+.
-	def grep( text )
-		return [] if text.empty?
-		
-		words = []
-		
-		# Grab a cursor into the database and fetch while the key matches
-		# the target text
-		cursor = @index_db.cursor
-		rec = cursor.set_range( text )
-		while /^#{text}/ =~ rec[0]
-			words.push rec[0]
-			rec = cursor.next
+		if uri
+			self.log.debug "Connecting using uri + options style: uri = %s, options = %p" %
+				[ uri, options ]
+			@db = Sequel.connect( uri, options )
+		else
+			self.log.debug "Connecting using hash style connect: options = %p" % [ options ]
+			@db = Sequel.connect( options )
 		end
-		cursor.close
-
-		return *words
-	end
 
+		@uri = @db.uri
+		self.log.debug "  setting model db to: %s" % [ @uri ]
 
-	### Factory method: Creates and returns a new WordNet::Synset object in
-	### this lexicon for the specified +word+ and +part_of_speech+.
-	def create_synset( word, part_of_speech )
-		return WordNet::Synset::new( self, '', part_of_speech, word )
+		@db.sql_log_level = :debug
+		WordNet::Model.db = @db
 	end
-	alias_method :new_synset, :create_synset
-
-
-	### Store the specified +synset+ (a WordNet::Synset object) in the
-	### lexicon. Returns the key of the stored synset.
-	def store_synset( synset )
-		strippedOffset = nil
-		pos = nil
 
-		# Start a transaction
-		@env.begin( BDB::TXN_COMMIT, @data_db ) do |txn,datadb|
-
-			# If this is a new synset, generate an offset for it
-			if synset.offset == 1
-				synset.offset =
-					(datadb['offsetcount'] = datadb['offsetcount'].to_i + 1)
-			end
-			
-			# Write the data entry
-			datadb[ synset.key ] = synset.serialize
-				
-			# Write the index entries
-			txn.begin( BDB::TXN_COMMIT, @index_db ) do |txn,indexdb|
-
-				# Make word/part-of-speech pairs from the words in the synset
-				synset.words.collect {|word| word + "%" + pos }.each {|word|
-
-					# If the index already has this word, but not this
-					# synset, add it
-					if indexdb.key?( word )
-						indexdb[ word ] << SUB_DELIM << synset.offset unless
-							indexdb[ word ].include?( synset.offset )
-					else
-						indexdb[ word ] = synset.offset
-					end
-				}
-			end # transaction on @index_db
-		end # transaction on @dataDB
-
-		return synset.offset
-	end
 
+	######
+	public
+	######
 
-	### Remove the specified +synset+ (a WordNet::Synset object) in the
-	### lexicon. Returns the offset of the stored synset.
-	def remove_synset( synset )
-		# If it's not in the database (ie., doesn't have a real offset),
-		# just return.
-		return nil if synset.offset == 1
-
-		# Start a transaction on the data table
-		@env.begin( BDB::TXN_COMMIT, @data_db ) do |txn,datadb|
-
-			# First remove the index entries for this synset by iterating
-			# over each of its words
-			txn.begin( BDB::TXN_COMMIT, @index_db ) do |txn,indexdb|
-				synset.words.collect {|word| word + "%" + pos }.each {|word|
-
-					# If the index contains an entry for this word, either
-					# splice out the offset for the synset being deleted if
-					# there are more than one, or just delete the whole
-					# entry if it's the only one.
-					if indexdb.key?( word )
-						offsets = indexdb[ word ].
-							split( SUB_DELIM_RE ).
-							reject {|offset| offset == synset.offset}
-
-						unless offsets.empty?
-							index_db[ word ] = newoffsets.join( SUB_DELIM )
-						else
-							index_db.delete( word )
-						end
-					end
-				}
+	# The database URI the lexicon will use to look up WordNet data
+	attr_reader :uri
+
+	# The Sequel::Database object that model tables read from
+	attr_reader :db
+
+
+	### Find a Word or Synset in the WordNet database and return it. In the case of multiple
+	### matching Synsets, only the first will be returned. If you want them all, you can use
+	### #lookup_synsets instead.
+	###
+	### The +word+ can be one of:
+	### [Integer]
+	###   Looks up the corresponding Word or Synset by ID. This assumes that all Synset IDs are
+	###   all 9 digits or greater, which is true as of WordNet 3.1. Any additional +args+ are
+	###   ignored.
+	### [Symbol, String]
+	###   Look up a Word by its gloss using #lookup_synsets, passing any additional +args+,
+	###   and return the first one that is found.
+	def []( word, *args )
+		if word.is_a?( Integer )
+			# :TODO: Assumes Synset IDs are all >= 100_000_000
+			if word.to_s.length > 8
+				return WordNet::Synset[ word ]
+			else
+				return WordNet::Word[ word ]
 			end
-
-			# :TODO: Delete synset from pointers of related synsets
-
-			# Delete the synset from the main db
-			datadb.delete( synset.offset )
+		else
+			return self.lookup_synsets( word, 1, *args ).first
 		end
-
-		return true
-	end
-
-
-	#########
-	protected
-	#########
-
-	### Normalize various ways of specifying a part of speech into the
-	### WordNet part of speech indicator from the +original+ representation,
-	### which may be the name (e.g., "noun"); +nil+, in which case it
-	### defaults to the indicator for a noun; or the indicator character
-	### itself, in which case it is returned unmodified.
-	def make_pos( original )
-		return WordNet::Noun if original.nil?
-		osym = original.to_s.intern
-		return WordNet::SYNTACTIC_CATEGORIES[ osym ] if
-			WordNet::SYNTACTIC_CATEGORIES.key?( osym )
-		return original if SYNTACTIC_SYMBOLS.key?( original )
-		return nil
-	end
-
-
-	### Make a lexicon key out of the given +word+ and part of speech
-	### (+pos+).
-	def make_word_key( word, pos )
-		pos = self.make_pos( pos )
-		word = word.gsub( /\s+/, '_' )
-		return "#{word}%#{pos}"
-	end
-
-
-	### Return a list of archival logfiles that can be removed
-	### safely. (BerkeleyDB-specific).
-	def archlogs
-		return @env.log_archive( BDB::ARCH_ABS )
 	end
 
 
-	#######
-	private
-	#######
-	
-	### Turn the given +origmode+ into an octal file mode such as that 
-	### given to File.open.
-	def normalize_mode( origmode )
-		case origmode
-		when :readonly
-			0444 & ~File.umask
-		when :readwrite, :writable
-			0666 & ~File.umask
-		when Fixnum
-			origmode
-		else
-			raise ArgumentError, "unrecognized mode %p" % [origmode]
+	### Look up synsets (Wordnet::Synset objects) associated with +word+, optionally filtered
+	### by additional +args+.
+	###
+	### The *args* can contain:
+	###
+	### [Integer, Range]
+	###   The sense/s of the Word (1-indexed) to use when searching for Synsets. If not specified,
+	###   all senses of the +word+ are used.
+	### [Regexp]
+	###   The Word's Synsets are filtered by definition using an RLIKE filter. Note that not all
+	###   databases (including the default one, sqlite3) support RLIKE.
+	### [Symbol, String]
+	###   If it matches one of either a lexical domain (e.g., "verb.motion") or a part of
+	###   speech (e.g., "adjective", :noun, :v), the resulting Synsets are filtered by that
+	###   criteria.
+	###   If the doesn't match a lexical domain or part of speech, it's used to filter by
+	###   definition using a LIKE query.
+	###
+	def lookup_synsets( word, *args )
+		dataset = WordNet::Synset.filter( :words => WordNet::Word.filter(lemma: word.to_s) )
+		self.log.debug "Looking up synsets for %p" % [ word.to_s ]
+
+		# Add filters to the dataset for each argument
+		args.each do |arg|
+			self.log.debug "  constraint arg: %p" % [ arg ]
+			case arg
+
+			when Integer
+				self.log.debug "  limiting to sense %d" % [ arg ]
+				dataset = dataset.limit( 1, arg-1 )
+
+			when Range
+				self.log.debug "  limiting to range of senses: %p" % [ arg ]
+				dataset = dataset.limit( arg.end - arg.begin, arg.begin - 1 )
+
+			when Regexp
+				self.log.debug "  filter: definition =~ %p" % [ arg ]
+				dataset = dataset.filter( definition: arg )
+
+			when Symbol, String
+				# Lexical domain, e.g., "verb.motion"
+				if domain = WordNet::Synset.lexdomains[ arg.to_s ]
+					self.log.debug "  filter: lex domain: %s (%d)" % [ arg, domain[:lexdomainid] ]
+					dataset = dataset.filter( lexdomainid: domain[:lexdomainid] )
+
+				# Part of speech symbol, e.g., "v"
+				elsif WordNet::Synset.postype_table.key?( arg.to_sym )
+					self.log.debug "  filter: part of speech: %s" % [ arg ]
+					dataset = dataset.filter( pos: arg.to_s )
+
+				# Part of speech name, e.g., "verb"
+				elsif pos = WordNet::Synset.postypes[ arg.to_s ]
+					self.log.debug "  filter: part of speech: %s" % [ pos.to_s ]
+					dataset = dataset.filter( pos: pos.to_s )
+
+				# Assume it's a definition match
+				else
+					pattern = "%%%s%%" % [ arg ]
+					self.log.debug "  filter: definition LIKE %p" % [ pattern ]
+					dataset = dataset.filter { :definition.like(pattern) }
+				end
+			end
 		end
-	end
 
-	### Output the given +msg+ to STDERR if $DEBUG is turned on.
-	def debug_msg( *msg )
-		return unless $DEBUG
-		$deferr.puts msg
+		return dataset.all
 	end
-	
 
 end # class WordNet::Lexicon
 

data/lib/wordnet/mixins.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'wordnet' unless defined?( WordNet )
+
+module WordNet
+
+	# Add logging to a WordNet class. Including classes get #log and #log_debug methods.
+	module Loggable
+
+		# Level names to levels
+		LEVEL = {
+			:debug => Logger::DEBUG,
+			:info  => Logger::INFO,
+			:warn  => Logger::WARN,
+			:error => Logger::ERROR,
+			:fatal => Logger::FATAL,
+		  }
+
+		### A logging proxy class that wraps calls to the logger into calls that include
+		### the name of the calling class.
+		### @private
+		class ClassNameProxy
+
+			### Create a new proxy for the given +klass+.
+			def initialize( klass, force_debug=false )
+				@classname   = klass.name
+				@force_debug = force_debug
+			end
+
+			### Delegate calls the global logger with the class name as the 'progname'
+			### argument.
+			def method_missing( sym, msg=nil, &block )
+				return super unless LEVEL.key?( sym )
+				sym = :debug if @force_debug
+				WordNet.logger.add( LEVEL[sym], msg, @classname, &block )
+			end
+		end # ClassNameProxy
+
+		#########
+		protected
+		#########
+
+		### Copy constructor -- clear the original's log proxy.
+		def initialize_copy( original )
+			@log_proxy = @log_debug_proxy = nil
+			super
+		end
+
+		### Return the proxied logger.
+		def log
+			@log_proxy ||= ClassNameProxy.new( self.class )
+		end
+
+		### Return a proxied "debug" logger that ignores other level specification.
+		def log_debug
+			@log_debug_proxy ||= ClassNameProxy.new( self.class, true )
+		end
+	end # module Loggable
+
+
+end # module WordNet
+