wordnet 0.0.5 → 1.0.0.pre.126

data/lib/wordnet/utils.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/ruby
+
+require 'logger'
+require 'erb'
+
+require 'wordnet' unless defined?( WordNet )
+
+
+module WordNet
+
+	# A alternate formatter for Logger instances.
+	# @private
+	class LogFormatter < Logger::Formatter
+
+		# The format to output unless debugging is turned on
+		DEFAULT_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s -- %7$s\n"
+
+		# The format to output if debugging is turned on
+		DEFAULT_DEBUG_FORMAT = "[%1$s.%2$06d %3$d/%4$s] %5$5s {%6$s} -- %7$s\n"
+
+
+		### Initialize the formatter with a reference to the logger so it can check for log level.
+		def initialize( logger, format=DEFAULT_FORMAT, debug=DEFAULT_DEBUG_FORMAT ) # :notnew:
+			@logger       = logger
+			@format       = format
+			@debug_format = debug
+
+			super()
+		end
+
+		######
+		public
+		######
+
+		# The Logger object associated with the formatter
+		attr_accessor :logger
+
+		# The logging format string
+		attr_accessor :format
+
+		# The logging format string that's used when outputting in debug mode
+		attr_accessor :debug_format
+
+
+		### Log using either the DEBUG_FORMAT if the associated logger is at ::DEBUG level or
+		### using FORMAT if it's anything less verbose.
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity,                                                     # %5$s
+				progname,                                                     # %6$s
+				msg                                                           # %7$s
+			]
+
+			if @logger.level == Logger::DEBUG
+				return self.debug_format % args
+			else
+				return self.format % args
+			end
+		end
+	end # class LogFormatter
+
+
+	# An alternate formatter for Logger instances that outputs +div+ HTML
+	# fragments.
+	# @private
+	class HtmlLogFormatter < Logger::Formatter
+		include ERB::Util  # for html_escape()
+
+		# The default HTML fragment that'll be used as the template for each log message.
+		HTML_LOG_FORMAT = %q{
+		<div class="log-message %5$s">
+			<span class="log-time">%1$s.%2$06d</span>
+			[
+				<span class="log-pid">%3$d</span>
+				/
+				<span class="log-tid">%4$s</span>
+			]
+			<span class="log-level">%5$s</span>
+			:
+			<span class="log-name">%6$s</span>
+			<span class="log-message-text">%7$s</span>
+		</div>
+		}
+
+		### Override the logging formats with ones that generate HTML fragments
+		def initialize( logger, format=HTML_LOG_FORMAT ) # :notnew:
+			@logger = logger
+			@format = format
+			super()
+		end
+
+
+		######
+		public
+		######
+
+		# The HTML fragment that will be used as a format() string for the log
+		attr_accessor :format
+
+
+		### Return a log message composed out of the arguments formatted using the
+		### formatter's format string
+		def call( severity, time, progname, msg )
+			args = [
+				time.strftime( '%Y-%m-%d %H:%M:%S' ),                         # %1$s
+				time.usec,                                                    # %2$d
+				Process.pid,                                                  # %3$d
+				Thread.current == Thread.main ? 'main' : Thread.object_id,    # %4$s
+				severity.downcase,                                                     # %5$s
+				progname,                                                     # %6$s
+				html_escape( msg ).gsub(/\n/, '<br />')                       # %7$s
+			]
+
+			return self.format % args
+		end
+
+	end # class HtmlLogFormatter
+
+end # module WordNet
+
+# vim: set nosta noet ts=4 sw=4:
+

data/lib/wordnet/word.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/ruby
+
+require 'wordnet' unless defined?( WordNet )
+require 'wordnet/mixins'
+require 'wordnet/model'
+
+# WordNet word model class
+class WordNet::Word < WordNet::Model( :words )
+	include WordNet::Constants
+
+	#                 Table "public.words"
+	#  Column |         Type          |     Modifiers
+	# --------+-----------------------+--------------------
+	#  wordid | integer               | not null default 0
+	#  lemma  | character varying(80) | not null
+	# Indexes:
+	#     "pk_words" PRIMARY KEY, btree (wordid)
+	#     "unq_words_lemma" UNIQUE, btree (lemma)
+	# Referenced by:
+	#     TABLE "adjpositions" CONSTRAINT "fk_adjpositions_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "bncconvtasks" CONSTRAINT "fk_bncconvtasks_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "bncimaginfs" CONSTRAINT "fk_bncimaginfs_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "bncs" CONSTRAINT "fk_bncs_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "bncspwrs" CONSTRAINT "fk_bncspwrs_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "casedwords" CONSTRAINT "fk_casedwords_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "lexlinks" CONSTRAINT "fk_lexlinks_word1id"
+	# 		FOREIGN KEY (word1id) REFERENCES words(wordid)
+	#     TABLE "lexlinks" CONSTRAINT "fk_lexlinks_word2id"
+	# 		FOREIGN KEY (word2id) REFERENCES words(wordid)
+	#     TABLE "morphmaps" CONSTRAINT "fk_morphmaps_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "sensemaps2021" CONSTRAINT "fk_sensemaps2021_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "sensemaps2130" CONSTRAINT "fk_sensemaps2130_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "senses20" CONSTRAINT "fk_senses20_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "senses21" CONSTRAINT "fk_senses21_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "senses" CONSTRAINT "fk_senses_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "vframemaps" CONSTRAINT "fk_vframemaps_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "vframesentencemaps" CONSTRAINT "fk_vframesentencemaps_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "vnclassmembers" CONSTRAINT "fk_vnclassmembers_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "vnframemaps" CONSTRAINT "fk_vnframemaps_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+	#     TABLE "vnrolemaps" CONSTRAINT "fk_vnrolemaps_wordid"
+	# 		FOREIGN KEY (wordid) REFERENCES words(wordid)
+
+
+	set_primary_key :wordid
+
+	##
+	# The WordNet::Sense objects that relate the word with its Synsets
+	one_to_many :senses,
+		:key => :wordid,
+		:primary_key => :wordid
+
+	##
+	# The WordNet::Synsets related to the word via its senses
+	many_to_many :synsets,
+		:join_table => :senses,
+		:left_key => :wordid,
+		:right_key => :synsetid
+
+	##
+	# The WordNet::Morphs related to the word
+	many_to_many :morphs,
+		:join_table => :morphmaps,
+		:left_key => :wordid,
+		:right_key => :morphid
+
+
+	### Return the stringified word; alias for #lemma.
+	def to_s
+		return self.lemma
+	end
+
+
+	### Return a dataset for all of the Word's Synsets that are nouns.
+	def nouns
+		return synsets_dataset.nouns
+	end
+
+
+	### Return a dataset for all of the Word's Synsets that are verbs.
+	def verbs
+		return synsets_dataset.verbs
+	end
+
+
+	### Return a dataset for all of the Word's Synsets that are adjectives.
+	def adjectives
+		return synsets_dataset.adjectives
+	end
+
+
+	### Return a dataset for all of the Word's Synsets that are adverbs.
+	def adverbs
+		return synsets_dataset.adverbs
+	end
+
+
+	### Return a dataset for all of the Word's Synsets that are adjective satellites.
+	def adjective_satellites
+		return synsets_dataset.adjective_satellites
+	end
+
+end # class WordNet::Word
+

data/lib/wordnet.rb

@@ -1,87 +1,124 @@
-#
-# 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
+#!/usr/bin/env ruby
+#encoding: utf-8
 
-	# Revision tag
-	SvnRev = %q$Rev: 90 $
+require 'logger'
+require 'sequel'
 
-	# Id tag
-	SvnId = %q$Id: wordnet.rb 90 2008-07-09 23:02:53Z deveiant $
+# This is a Ruby interface to the WordNet® lexical database. It uses the WordNet-SQL
+# project's databases instead of reading from the canonical flatfiles for speed and
+# easy modification.
+module WordNet
 
 	# Release version
-	VERSION = '0.0.5'
+	VERSION = '1.0.0'
+
+	# VCS revision
+	REVISION = %q$Revision: $
+
+	# Abort if not >=1.9.2
+	vvec = lambda {|version| version.split('.').collect {|v| v.to_i }.pack('N*') }
+	abort "This version of WordNet requires Ruby 1.9.2 or greater." unless
+		vvec[RUBY_VERSION] >= vvec['1.9.2']
+
+
+	### Lexicon exception - something has gone wrong in the internals of the
+	### lexicon.
+	class LexiconError < StandardError ; end
+
+	### Lookup error - the object being looked up either doesn't exist or is
+	### malformed
+	class LookupError < StandardError ; end
+
 
 	require 'wordnet/constants'
+	include WordNet::Constants
+	require 'wordnet/utils'
+
+	#
+	# Logging
+	#
+
+	@default_logger = Logger.new( $stderr )
+	@default_logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
+
+	@default_log_formatter = WordNet::LogFormatter.new( @default_logger )
+	@default_logger.formatter = @default_log_formatter
+
+	@logger = @default_logger
+
+	class << self
+		# @return [Logger::Formatter] the log formatter that will be used when the logging
+		#    subsystem is reset
+		attr_accessor :default_log_formatter
+
+		# @return [Logger] the logger that will be used when the logging subsystem is reset
+		attr_accessor :default_logger
+
+		# @return [Logger] the logger that's currently in effect
+		attr_accessor :logger
+		alias_method :log, :logger
+		alias_method :log=, :logger=
+	end
+
+
+	### Reset the global logger object to the default
+	### @return [void]
+	def self::reset_logger
+		self.logger = self.default_logger
+		self.logger.level = Logger::WARN
+		self.logger.formatter = self.default_log_formatter
+	end
+
+
+	### Returns +true+ if the global logger has not been set to something other than
+	### the default one.
+	def self::using_default_logger?
+		return self.logger == self.default_logger
+	end
+
+
+	### Get the WordNet version.
+	### @return [String] the library's version
+	def self::version_string( include_buildnum=false )
+		vstring = "%s %s" % [ self.name, VERSION ]
+		vstring << " (build %s)" % [ REVISION[/: ([[:xdigit:]]+)/, 1] || '0' ] if include_buildnum
+		return vstring
+	end
+
+
 	require 'wordnet/lexicon'
+
+	require 'wordnet/model'
+	require 'wordnet/sense'
 	require 'wordnet/synset'
+	require 'wordnet/semanticlink'
+	require 'wordnet/lexicallink'
+	require 'wordnet/word'
+	require 'wordnet/morph'
+	require 'wordnet/sumoterm'
+
+	#
+	# Backward-compatibility stuff
+	#
+
+	# :section: Backward-compatibility
+
+	# Backward-compatibility constant
+	Noun      = :n
+
+	# Backward-compatibility constant
+	Verb      = :v
+
+	# Backward-compatibility constant
+	Adjective = :a
+
+	# Backward-compatibility constant
+	Adverb    = :r
+
+	# Backward-compatibility constant
+	Other     = :s
+
+
 
 end # module WordNet
 

data/spec/lib/helpers.rb

@@ -1,155 +1,124 @@
 #!/usr/bin/ruby
+# coding: utf-8
 
-begin
-	require 'wordnet'
-rescue LoadError
-	unless Object.const_defined?( :Gem )
-		require 'rubygems'
-		retry
-	end
-	raise
-end
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+}
+
+require 'rspec'
+require 'wordnet'
 
+
+### RSpec helper functions.
 module WordNet::SpecHelpers
 
+	# A logger that logs to an array.
+	class ArrayLogger
+		### Create a new ArrayLogger that will append content to +array+.
+		def initialize( array )
+			@array = array
+		end
+
+		### Write the specified +message+ to the array.
+		def write( message )
+			@array << message
+		end
+
+		### No-op -- this is here just so Logger doesn't complain
+		def close; end
+
+	end # class ArrayLogger
+
+
+	unless defined?( LEVEL )
+		LEVEL = {
+			:debug => Logger::DEBUG,
+			:info  => Logger::INFO,
+			:warn  => Logger::WARN,
+			:error => Logger::ERROR,
+			:fatal => Logger::FATAL,
+		  }
+	end
+
+
 	###############
 	module_function
 	###############
 
-	### Create a temporary working directory and return
-	### a Pathname object for it.
-	def make_tempdir
-		dirname = "%s.%d.%0.4f" % [
-			'wordnet_spec',
-			Process.pid,
-			(Time.now.to_f % 3600),
-		  ]
-		tempdir = Pathname.new( Dir.tmpdir ) + dirname
-		tempdir.mkpath
-		
-		return tempdir
+	### Make an easily-comparable version vector out of +ver+ and return it.
+	def vvec( ver )
+		return ver.split('.').collect {|char| char.to_i }.pack('N*')
 	end
-	
-end
 
-# Override the badly-formatted output of the RSpec HTML formatter
-require 'spec/runner/formatter/html_formatter'
 
-class Spec::Runner::Formatter::HtmlFormatter
-	def example_failed( example, counter, failure )
-		failure_style = failure.pending_fixed? ? 'pending_fixed' : 'failed'
-		
-		unless @header_red
-			@output.puts "    <script type=\"text/javascript\">makeRed('rspec-header');</script>"
-			@header_red = true
-		end
-		
-		unless @example_group_red
-			css_class = 'example_group_%d' % [current_example_group_number]
-			@output.puts "    <script type=\"text/javascript\">makeRed('#{css_class}');</script>"
-			@example_group_red = true
-		end
-		
-		move_progress()
-		
-		@output.puts "    <dd class=\"spec #{failure_style}\">",
-		             "      <span class=\"failed_spec_name\">#{h(example.description)}</span>",
-		             "      <div class=\"failure\" id=\"failure_#{counter}\">"
-		if failure.exception
-			backtrace = format_backtrace( failure.exception.backtrace )
-			message = failure.exception.message
-			
-			@output.puts "        <div class=\"message\"><code>#{h message}</code></div>",
-			             "        <div class=\"backtrace\"><pre>#{backtrace}</pre></div>"
+	### Reset the logging subsystem to its default state.
+	def reset_logging
+		WordNet.reset_logger
+	end
+
+
+	### Alter the output of the default log formatter to be pretty in SpecMate output
+	def setup_logging( level=Logger::FATAL )
+
+		# Turn symbol-style level config into Logger's expected Fixnum level
+		if LEVEL.key?( level )
+			level = LEVEL[ level ]
 		end
 
-		if extra = extra_failure_content( failure )
-			@output.puts( extra )
+		logger = Logger.new( $stderr )
+		WordNet.logger = logger
+		WordNet.logger.level = level
+
+		# Only do this when executing from a spec in TextMate
+		if ENV['HTML_LOGGING'] || (ENV['TM_FILENAME'] && ENV['TM_FILENAME'] =~ /_spec\.rb/)
+			Thread.current['logger-output'] = []
+			logdevice = ArrayLogger.new( Thread.current['logger-output'] )
+			WordNet.logger = Logger.new( logdevice )
+			# WordNet.logger.level = level
+			WordNet.logger.formatter = WordNet::HtmlLogFormatter.new( logger )
 		end
-		
-		@output.puts "      </div>",
-		             "    </dd>"
-		@output.flush
 	end
 
 
-	alias_method :default_global_styles, :global_styles
-	
-	def global_styles
-		css = default_global_styles()
-		css << %Q{
-			/* Stuff added by #{__FILE__} */
-
-			/* Overrides */
-			#rspec-header {
-				-webkit-box-shadow: #333 0 2px 5px;
-				margin-bottom: 1em;
-			}
-
-			.example_group dt {
-				-webkit-box-shadow: #333 0 2px 3px;
-			}
-
-			/* Style for log output */
-			dd.log-message {
-				background: #eee;
-				padding: 0 2em;
-				margin: 0.2em 1em;
-				border-bottom: 1px dotted #999;
-				border-top: 1px dotted #999;
-				text-indent: -1em;
-			}
-
-			/* Parts of the message */
-			dd.log-message .log-time {
-				font-weight: bold;
-			}
-			dd.log-message .log-time:after {
-				content: ": ";
-			}
-			dd.log-message .log-level {
-				font-variant: small-caps;
-				border: 1px solid #ccc;
-				padding: 1px 2px;
-			}
-			dd.log-message .log-name {
-				font-size: 1.2em;
-				color: #1e51b2;
-			}
-			dd.log-message .log-name:before { content: "«"; }
-			dd.log-message .log-name:after { content:  "»"; }
-
-			dd.log-message .log-message-text {
-				padding-left: 4px;
-				font-family: Monaco, "Andale Mono", "Vera Sans Mono", mono;
-			}
-
-
-			/* Distinguish levels */
-			dd.log-message.debug { color: #666; }
-			dd.log-message.info {}
-
-			dd.log-message.warn,
-			dd.log-message.error {
-				background: #ff9;
-			}
-			dd.log-message.error .log-level,
-			dd.log-message.error .log-message-text {
-				color: #900;
-			}
-			dd.log-message.fatal {
-				background: #900;
-				color: white;
-				font-weight: bold;
-				border: 0;
-			}
-			dd.log-message.fatal .log-name {
-				color:  white;
-			}
-		}
-		
-		return css
+	### Make a WordNet::Directory that will use the given +conn+ object as its
+	### LDAP connection. Also pre-loads the schema object and fixtures some other
+	### external data.
+	def get_fixtured_directory( conn )
+		LDAP::SSLConn.stub( :new ).and_return( @conn )
+		conn.stub( :root_dse ).and_return( nil )
+		directory = WordNet.directory( TEST_LDAPURI )
+		directory.stub( :schema ).and_return( SCHEMA )
+
+		return directory
+	end
+
+end
+
+
+### Mock with Rspec
+RSpec.configure do |c|
+	c.mock_with :rspec
+	c.include( WordNet::SpecHelpers )
+
+	c.treat_symbols_as_metadata_keys_with_true_values = true
+
+	if Gem::Specification.find_all_by_name( 'pg' ).empty?
+		c.filter_run_excluding( :requires_pg )
+	end
+
+	begin
+		uri = WordNet::Lexicon.default_db_uri
+		WordNet.log.info "Database tests will use: #{uri}"
+	rescue WordNet::LexiconError
+		c.filter_run_excluding( :requires_database )
 	end
 end
 
+# vim: set nosta noet ts=4 sw=4: