wordnet 1.0.1 → 1.1.0

data/lib/wordnet/model.rb

@@ -4,17 +4,21 @@
 require 'loggability'
 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 )
 
+
 module WordNet
 
+	Model = Class.new( Sequel::Model )
+	Model.def_Model( WordNet )
+
+	Model.require_valid_table = false
+
+
 	# 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
+	# you'll first need to be familiar with Sequel (http://sequel.jeremyevans.net/) and
 	# especially its Sequel::Model ORM.
-	class Model < Sequel::Model
+	class Model
 		extend Loggability
 
 		# Loggability API -- log to the WordNet module's logger
@@ -22,58 +26,46 @@ module WordNet
 
 		# Sequel plugins
 		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 )
+		# Allow registration of subclasses to load once the db is connected
+		class << self
+			attr_reader :registered_models
 		end
+		@registered_models = []
 
 
 		### 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
+			Loggability.with_level( :fatal ) do
 				super
 			end
 
-			self.descendents.each do |subclass|
-				self.log.debug "Resetting database connection for: %p to: %p" % [ subclass, newdb ]
-				subclass.db = newdb
-			end
+			self.load_registered_models if self == WordNet::Model
 		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
+		### Register a model subclass path to load when the database is connected. If
+		### there's already a database connection, just `require` it immediately.
+		def self::register_model( name )
+			if @db
+				require( name )
+			else
+				self.registered_models << name
 			end
+		end
+
 
-			Sequel::Model::ANONYMOUS_MODEL_CLASSES[ source ] = anonclass
+		### Load any models which have been registered.
+		def self::load_registered_models
+			self.registered_models.each do |path|
+				require( path )
+			end
 		end
 
-		return Sequel::Model::ANONYMOUS_MODEL_CLASSES[ source ]
-	end
+	end # class Model
+
 
 end # module WordNet

data/lib/wordnet/morph.rb

@@ -36,9 +36,9 @@ class WordNet::Morph < WordNet::Model( :morphs )
 	#     "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,
-		:right_key  => :wordid,
-		:left_key   => :morphid
+		join_table: :morphmaps,
+		right_key: :wordid,
+		left_key: :morphid
 
 
 	### Return the stringified word; alias for #lemma.

data/lib/wordnet/semanticlink.rb

@@ -13,15 +13,15 @@ class WordNet::SemanticLink < WordNet::Model( :semlinks )
 	set_primary_key [:synset1id, :synset2id, :linkid]
 
 	many_to_one :origin,
-		:class       => :"WordNet::Synset",
-		:key         => :synset1id,
-		:primary_key => :synsetid
+		class: 'WordNet::Synset',
+		key: :synset1id,
+		primary_key: :synsetid
 
 	one_to_one :target,
-		:class       => :"WordNet::Synset",
-		:key         => :synsetid,
-		:primary_key => :synset2id,
-		:eager       => :words
+		class: 'WordNet::Synset',
+		key: :synsetid,
+		primary_key: :synset2id,
+		eager: :words
 
 
 	######

data/lib/wordnet/sense.rb

@@ -12,19 +12,19 @@ class WordNet::Sense < WordNet::Model( :senses )
 
 	##
 	# The Synset this is a Sense for
-	many_to_one :synset, :key => :synsetid
+	many_to_one :synset, key: :synsetid
 
 	##
 	# The Word this is a Sense for
-	many_to_one :word, :key => :wordid
+	many_to_one :word, key: :wordid
 
 	##
 	# The lexical links between this sense and its related Synsets.
 	# Sense -> [ LexicalLinks ] -> [ Synsets ]
 	one_to_many :lexlinks,
-		:class       => :"WordNet::LexicalLink",
-		:key         => [ :synset1id, :word1id ],
-		:primary_key => [ :synsetid, :wordid ]
+		class: 'WordNet::LexicalLink',
+		key: [ :synset1id, :word1id ],
+		primary_key: [ :synsetid, :wordid ]
 
 
 	### Generate a method that will return Synsets related by the given lexical pointer
@@ -37,8 +37,8 @@ class WordNet::Sense < WordNet::Model( :senses )
 		method_body = Proc.new do
 			linkinfo = WordNet::Synset.linktypes[ 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 )
+			ssids = self.lexlinks_dataset.filter( linkid: linkinfo[:id] ).select( :synset2id )
+			self.class.filter( synsetid: ssids )
 		end
 
 		define_method( type, &method_body )

data/lib/wordnet/sumoterm.rb

@@ -8,11 +8,11 @@ require 'wordnet/constants'
 
 # 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.
+# It's still a work in progress.
 class WordNet::SumoTerm < WordNet::Model( :sumoterms )
 	include WordNet::Constants
 
+
 	#                       Table "public.sumoterms"
 	#         Column         |          Type          |     Modifiers
 	# -----------------------+------------------------+--------------------
@@ -69,9 +69,9 @@ class WordNet::SumoTerm < WordNet::Model( :sumoterms )
 	##
 	# WordNet::Synsets that are related to this term
 	many_to_many :synsets,
-		:join_table => :sumomaps,
-		:left_key   => :sumoid,
-		:right_key  => :synsetid
+		join_table: :sumomaps,
+		left_key: :sumoid,
+		right_key: :synsetid
 
 end # class WordNet::SumoTerm
 

data/lib/wordnet/synset.rb

@@ -14,7 +14,7 @@ require 'wordnet/model'
 #
 # We can either fetch the synset from a connected Lexicon:
 #
-#    lexicon = WordNet::Lexicon.new( 'postgres://localhost/wordnet30' )
+#    lexicon = WordNet::Lexicon.new( 'postgres://localhost/wordnet31' )
 #    ss = lexicon[ :first, 'time' ]
 #    # => #<WordNet::Synset:0x7ffbf2643bb0 {115265518} 'commencement, first,
 #    #       get-go, offset, outset, start, starting time, beginning, kickoff,
@@ -101,9 +101,9 @@ require 'wordnet/model'
 # API if you need to do something not provided by a high-level method.
 #
 # In order to make use of this API, you'll need to be familiar with
-# {Sequel}[http://sequel.rubyforge.org/], especially
-# {Datasets}[http://sequel.rubyforge.org/rdoc/files/doc/dataset_basics_rdoc.html] and
-# {Model Associations}[http://sequel.rubyforge.org/rdoc/files/doc/association_basics_rdoc.html].
+# {Sequel}[http://sequel.jeremyevans.net/], especially
+# {Datasets}[http://sequel.jeremyevans.net/rdoc/files/doc/dataset_basics_rdoc.html] and
+# {Model Associations}[http://sequel.jeremyevans.net/rdoc/files/doc/association_basics_rdoc.html].
 # Most of Ruby-WordNet's functionality is implemented in terms of one or both
 # of these.
 #
@@ -179,42 +179,42 @@ class WordNet::Synset < WordNet::Model( :synsets )
 	##
 	# The WordNet::Words associated with the receiver
 	many_to_many :words,
-		:join_table  => :senses,
-		:left_key    => :synsetid,
-		:right_key   => :wordid
+		join_table: :senses,
+		left_key: :synsetid,
+		right_key: :wordid
 
 
 	##
 	# The WordNet::Senses associated with the receiver
 	one_to_many :senses,
-		:key         => :synsetid,
-		:primary_key => :synsetid
+		key: :synsetid,
+		primary_key: :synsetid
 
 
 	##
 	# The WordNet::SemanticLinks indicating a relationship with other
 	# WordNet::Synsets
 	one_to_many :semlinks,
-		:class       => :"WordNet::SemanticLink",
-		:key         => :synset1id,
-		:primary_key => :synsetid,
-		:eager       => :target
+		class: 'WordNet::SemanticLink',
+		key: :synset1id,
+		primary_key: :synsetid,
+		eager: :target
 
 
 	##
 	# The WordNet::SemanticLinks pointing *to* this Synset
 	many_to_one :semlinks_to,
-		:class       => :"WordNet::SemanticLink",
-		:key         => :synsetid,
-		:primary_key => :synset2id
+		class: 'WordNet::SemanticLink',
+		key: :synsetid,
+		primary_key: :synset2id
 
 
 	##
 	# Terms from the Suggested Upper Merged Ontology
 	many_to_many :sumo_terms,
-		:join_table  => :sumomaps,
-		:left_key    => :synsetid,
-		:right_key   => :sumoid
+		join_table: :sumomaps,
+		left_key: :synsetid,
+		right_key: :sumoid
 
 
 	#################################################################
@@ -252,30 +252,43 @@ class WordNet::Synset < WordNet::Model( :synsets )
 	#   #        organ of a bird>]
 	#
 
-	##
-	# :singleton-method: nouns
-	# Dataset method: filtered by part of speech: nouns.
-	def_dataset_method( :nouns ) { filter(pos: 'n') }
+	dataset_module do
 
-	##
-	# :singleton-method: verbs
-	# Dataset method: filtered by part of speech: verbs.
-	def_dataset_method( :verbs ) { filter(pos: 'v') }
+		### :singleton-method: nouns
+		### Limit results to nouns.
+		def nouns
+			return self.where( pos: 'n' )
+		end
 
-	##
-	# :singleton-method: adjectives
-	# Dataset method: filtered by part of speech: adjectives.
-	def_dataset_method( :adjectives ) { filter(pos: 'a') }
 
-	##
-	# :singleton-method: adverbs
-	# Dataset method: filtered by part of speech: adverbs.
-	def_dataset_method( :adverbs ) { filter(pos: 'r') }
+		### :singleton-method: verbs
+		### Limit results to verbs.
+		def verbs
+			return self.where( pos: 'v' )
+		end
 
-	##
-	# :singleton-method: adjective_satellites
-	# Dataset method: filtered by part of speech: adjective satellites.
-	def_dataset_method( :adjective_satellites ) { filter(pos: 's') }
+
+		### :singleton-method: adjectives
+		### Limit results to adjectives.
+		def adjectives
+			return self.where( pos: 'a' )
+		end
+
+
+		### :singleton-method: adverbs
+		### Limit results to adverbs.
+		def adverbs
+			return self.where( pos: 'r' )
+		end
+
+
+		### :singleton-method: adjective_satellites
+		### Limit results to adjective satellites.
+		def adjective_satellites
+			return self.where( pos: 's' )
+		end
+
+	end
 
 
 	# :section:
@@ -318,10 +331,10 @@ class WordNet::Synset < WordNet::Model( :synsets )
 	def self::linktype_table
 		@linktype_table ||= self.db[:linktypes].inject({}) do |hash,row|
 			hash[ row[:linkid] ] = {
-				:id       => row[:linkid],
-				:typename => row[:link],
-				:type     => row[:link].gsub( /\s+/, '_' ).to_sym,
-				:recurses => row[:recurses] && row[:recurses] != 0,
+				id: row[:linkid],
+				typename: row[:link],
+				type: row[:link].gsub( /\s+/, '_' ).to_sym,
+				recurses: row[:recurses] && row[:recurses] != 0,
 			}
 			hash
 		end
@@ -388,9 +401,9 @@ class WordNet::Synset < WordNet::Model( :synsets )
 		typekey  = SEMANTIC_TYPEKEYS[ type ]
 		linkinfo = self.class.linktypes[ typekey ] or
 			raise ArgumentError, "no such link type %p" % [ typekey ]
-		ssids    = self.semlinks_dataset.filter( :linkid => linkinfo[:id] ).select( :synset2id )
+		ssids    = self.semlinks_dataset.filter( linkid: linkinfo[:id] ).select( :synset2id )
 
-		return self.class.filter( :synsetid => ssids )
+		return self.class.filter( synsetid: ssids )
 	end
 
 

data/lib/wordnet/word.rb

@@ -66,31 +66,36 @@ class WordNet::Word < WordNet::Model( :words )
 	##
 	# The WordNet::Sense objects that relate the word with its Synsets
 	one_to_many :senses,
-		:key => :wordid,
-		:primary_key => :wordid
+		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
+		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
+		join_table: :morphmaps,
+		left_key: :wordid,
+		right_key: :morphid
 
 
 	#
 	# Dataset methods
 	#
 
-	##
-	# Return a dataset for words matching the given +lemma+.
-	def_dataset_method( :by_lemma ) {|lemma| filter( lemma: lemma ) }
+	dataset_module do
+
+		### Limit the dataset to words matching the given +lemma+.
+		def by_lemma( lemma )
+			return where( lemma: lemma )
+		end
+
+	end
 
 
 	#

data/spec/helpers.rb

@@ -5,9 +5,12 @@
 # SimpleCov test coverage reporting; enable this using the :coverage rake task
 require 'simplecov' if ENV['COVERAGE']
 
+$LOAD_PATH.unshift( 'wordnet-defaultdb/lib' )
+
 require 'rspec'
 require 'loggability/spechelpers'
 require 'wordnet'
+require 'wordnet/defaultdb'
 
 
 ### RSpec helper functions.
@@ -23,17 +26,18 @@ RSpec.configure do |config|
 	config.mock_with( :rspec ) do |mock|
 		mock.syntax = :expect
 	end
+	config.example_status_persistence_file_path = "spec/.state"
 
-	if Gem::Specification.find_all_by_name( 'pg' ).empty?
+	if Gem::Specification.find_all_by_name( 'pg' ).any?
+		$dburi = 'postgres:/wordnet31'
+	else
 		config.filter_run_excluding( :requires_pg )
+		unless (( $dburi = WordNet::Lexicon.default_db_uri ))
+			config.filter_run_excluding( :requires_database )
+		end
 	end
 
-	begin
-		uri = WordNet::Lexicon.default_db_uri
-		WordNet.log.info "Database tests will use: #{uri}"
-	rescue WordNet::LexiconError
-		config.filter_run_excluding( :requires_database )
-	end
+	$stderr.puts "Using database: %p" % [ $dburi ]
 
 	config.include( WordNet::SpecHelpers )
 	config.include( Loggability::SpecHelpers )