wordnet 0.0.5 → 1.0.0.pre.126

data/lib/wordnet/model.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/ruby
+
+require 'sequel'
+
+# Use a mock database until the real one is provided by the user
+Sequel::Model.db = Sequel.mock if Sequel::DATABASES.empty?
+
+require 'wordnet' unless defined?( WordNet )
+require 'wordnet/mixins'
+
+module WordNet
+
+	# The base WordNet database-backed domain class. It's a subclass of Sequel::Model, so
+	# you'll first need to be familiar with Sequel (http://sequel.rubyforge.org/) and
+	# especially its Sequel::Model ORM.
+	#
+	# See the Sequel::Plugins::InlineMigrations module and the documentation for the
+	# 'validation_helpers', 'schema', and 'subclasses' Sequel plugins.
+	#
+	class Model < Sequel::Model
+		include WordNet::Loggable
+
+		plugin :validation_helpers
+		plugin :schema
+		plugin :subclasses
+
+
+		### Execute a block after removing all loggers from the current database handle, then
+		### restore them before returning.
+		def self::without_sql_logging( logged_db=nil )
+			logged_db ||= self.db
+
+			loggers_to_restore = logged_db.loggers.dup
+			logged_db.loggers.clear
+			yield
+		ensure
+			logged_db.loggers.replace( loggers_to_restore )
+		end
+
+
+		### Reset the database connection that all model objects will use.
+		### @param [Sequel::Database] newdb  the new database object.
+		def self::db=( newdb )
+			self.without_sql_logging( newdb ) do
+				super
+			end
+
+			self.descendents.each do |subclass|
+				WordNet.log.info "Resetting database connection for: %p to: %p" % [ subclass, newdb ]
+				subclass.db = newdb
+			end
+		end
+
+	end # class Model
+
+
+	### Overridden version of Sequel.Model() that creates subclasses of WordNet::Model instead
+	### of Sequel::Model.
+	### @see Sequel.Model()
+	def self::Model( source )
+		unless Sequel::Model::ANONYMOUS_MODEL_CLASSES.key?( source )
+			anonclass = nil
+			WordNet::Model.without_sql_logging do
+				if source.is_a?( Sequel::Database )
+					anonclass = Class.new( WordNet::Model )
+					anonclass.db = source
+				else
+					anonclass = Class.new( WordNet::Model ).set_dataset( source )
+				end
+			end
+
+			Sequel::Model::ANONYMOUS_MODEL_CLASSES[ source ] = anonclass
+		end
+
+		return Sequel::Model::ANONYMOUS_MODEL_CLASSES[ source ]
+	end
+
+end # module WordNet

data/lib/wordnet/morph.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby
+
+require 'wordnet' unless defined?( WordNet )
+require 'wordnet/mixins'
+require 'wordnet/model'
+
+# WordNet morph model class
+class WordNet::Morph < WordNet::Model( :morphs )
+	include WordNet::Constants
+
+	set_primary_key :morphid
+
+	many_to_one :word,
+		:join_table => :morphmaps,
+		:left_key => :wordid,
+		:right_key => :morphid
+
+
+	### Return the stringified word; alias for #lemma.
+	def to_s
+		return "%s (%s)" % [ self.morph, self.pos ]
+	end
+
+end # class WordNet::Morph
+

data/lib/wordnet/semanticlink.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby
+
+require 'wordnet' unless defined?( WordNet )
+require 'wordnet/constants'
+require 'wordnet/model'
+
+# WordNet semantic link (pointer) model class
+class WordNet::SemanticLink < WordNet::Model( :semlinks )
+	include WordNet::Constants
+
+
+	set_primary_key [:synset1id, :synset2id, :linkid]
+
+	many_to_one :origin,
+		:class       => :"WordNet::Synset",
+		:key         => :synset1id,
+		:primary_key => :synsetid
+
+	one_to_one :target,
+		:class       => :"WordNet::Synset",
+		:key         => :synsetid,
+		:primary_key => :synset2id,
+		:eager       => :words
+
+
+	######
+	public
+	######
+
+	### Return a stringified version of the SemanticLink.
+	def to_s
+		return "%s: %s (%s)" % [
+			self.type,
+			self.target.words.map( &:to_s ).join( ', ' ),
+			self.target.pos,
+		]
+	end
+
+
+	### Return the type of link as a Symbol.
+	def type
+		return WordNet::Synset.linktype_table[ self.linkid ][ :type ]
+	end
+
+
+	### Return the name of the link type as a String.
+	def typename
+		return WordNet::Synset.linktype_table[ self.linkid ][ :typename ]
+	end
+
+end # class WordNet::SemanticLink
+

data/lib/wordnet/sense.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+
+require 'wordnet' unless defined?( WordNet )
+require 'wordnet/model'
+
+# WordNet sense model class
+class WordNet::Sense < WordNet::Model( :senses )
+	include WordNet::Constants
+
+	set_primary_key :senseid
+
+	many_to_one :synset, :key => :synsetid
+	many_to_one :word, :key => :wordid
+
+	# Sense -> [ LexicalLinks ] -> [ Synsets ]
+	one_to_many :lexlinks,
+		:class       => :"WordNet::LexicalLink",
+		:key         => [ :synset1id, :word1id ],
+		:primary_key => [ :synsetid, :wordid ]
+
+
+	### Generate a method that will return Synsets related by the given lexical pointer
+	### +type+.
+	def self::lexical_link( type, typekey=nil )
+		typekey ||= type.to_s.chomp( 's' ).to_sym
+
+		WordNet.log.debug "Generating a %p method for %p links" % [ type, typekey ]
+
+		method_body = Proc.new do
+			linkinfo = WordNet::Synset.linktype_names[ typekey ] or
+				raise ScriptError, "no such link type %p" % [ typekey ]
+			ssids = self.lexlinks_dataset.filter( :linkid => linkinfo[:id] ).select( :synset2id )
+			self.class.filter( :synsetid => ssids )
+		end
+		WordNet.log.debug "  method body is: %p" % [ method_body ]
+
+		define_method( type, &method_body )
+	end
+
+
+	lexical_link :also_see, :also
+	lexical_link :antonym
+	lexical_link :derivation
+	lexical_link :domain_categories, :domain_category
+	lexical_link :domain_member_categories, :domain_member_category
+	lexical_link :domain_member_region
+	lexical_link :domain_member_usage
+	lexical_link :domain_region
+	lexical_link :domain_usage
+	lexical_link :participle
+	lexical_link :pertainym
+	lexical_link :verb_group
+
+end # class WordNet::Sense
+

data/lib/wordnet/sumoterm.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby
+
+require 'wordnet' unless defined?( WordNet )
+require 'wordnet/model'
+require 'wordnet/constants'
+
+
+# SUMO terms
+class WordNet::SumoTerm < WordNet::Model( :sumoterms )
+	include WordNet::Constants
+
+	set_primary_key :sumoid
+
+	# SUMO Term -> [ SUMO Map ] -> [ Synset ]
+	many_to_many :synsets,
+		:join_table => :sumomaps,
+		:left_key => :sumoid,
+		:right_key => :synsetid
+
+end # class WordNet::SumoTerm
+