wordnet 0.0.5

data/rake/testing.rb

@@ -0,0 +1,192 @@
+# 
+# Rake tasklib for testing tasks
+# $Id: testing.rb 39 2008-08-22 01:27:56Z deveiant $
+# 
+# Authors:
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+
+COVERAGE_MINIMUM = 85.0 unless defined?( COVERAGE_MINIMUM )
+SPEC_FILES       = [] unless defined?( SPEC_FILES )
+TEST_FILES       = [] unless defined?( TEST_FILES )
+
+COMMON_SPEC_OPTS = ['-c', '-f', 's'] unless defined?( COMMON_SPEC_OPTS )
+
+COVERAGE_TARGETDIR = BASEDIR + 'coverage' unless defined?( COVERAGE_TARGETDIR )
+RCOV_EXCLUDES      = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib' unless
+	defined?( RCOV_EXCLUDES )
+
+
+desc "Run all defined tests"
+task :test do
+	unless SPEC_FILES.empty?
+		log "Running specs"
+		Rake::Task['spec:quiet'].invoke
+	end
+	
+	unless TEST_FILES.empty?
+		log "Running unit tests"
+		Rake::Task[:unittests].invoke 
+	end
+end
+
+
+### RSpec specifications
+begin
+	gem 'rspec', '>= 1.1.3'
+	require 'spec/rake/spectask'
+
+	### Task: spec
+	Spec::Rake::SpecTask.new( :spec ) do |task|
+		task.spec_files = SPEC_FILES
+		task.libs += [LIBDIR]
+		task.spec_opts = COMMON_SPEC_OPTS
+	end
+
+
+	namespace :spec do
+		desc "Run rspec every time there's a change to one of the files"
+		task :autotest do
+			require 'autotest/rspec'
+
+			autotester = Autotest::Rspec.new
+			autotester.exceptions = %r{\.svn|\.skel}
+			autotester.run
+		end
+
+
+		desc "Generate quiet output"
+		Spec::Rake::SpecTask.new( :quiet ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f', 'p', '-D']
+		end
+
+		desc "Generate HTML output for a spec run"
+		Spec::Rake::SpecTask.new( :html ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f','h', '-D']
+		end
+
+		desc "Generate plain-text output for a CruiseControl.rb build"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f','p']
+		end
+	end
+rescue LoadError => err
+	task :no_rspec do
+		$stderr.puts "Specification tasks not defined: %s" % [ err.message ]
+	end
+
+	task :spec => :no_rspec
+	namespace :spec do
+		task :autotest => :no_rspec
+		task :quiet => :no_rspec
+		task :html => :no_rspec
+		task :text => :no_rspec
+	end
+end
+
+
+### Test::Unit tests
+begin
+	require 'rake/testtask'
+	
+	Rake::TestTask.new( :unittests ) do |task|
+		task.libs += [LIBDIR]
+		task.test_files = TEST_FILES
+		task.verbose = true
+	end
+
+rescue LoadError => err
+	task :no_test do
+		$stderr.puts "Test tasks not defined: %s" % [ err.message ]
+	end
+
+	task :unittests => :no_rspec
+end
+
+	
+### RCov (via RSpec) tasks
+begin
+	gem 'rcov'
+	gem 'rspec', '>= 1.1.3'
+
+	### Task: coverage (via RCov)
+	### Task: rcov
+	desc "Build test coverage reports"
+	unless SPEC_FILES.empty?
+		Spec::Rake::SpecTask.new( :coverage ) do |task|
+			task.spec_files = SPEC_FILES
+			task.libs += [LIBDIR]
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS
+			task.rcov = true
+		end
+	end
+	unless TEST_FILES.empty?
+		require 'rcov/rcovtask'
+
+		Rcov::RcovTask.new do |task|
+			task.libs += [LIBDIR]
+			task.test_files = TEST_FILES
+			task.verbose = true
+			task.rcov_opts = RCOV_OPTS
+		end
+	end
+
+
+	task :rcov => [:coverage] do; end
+
+	### Other coverage tasks
+	namespace :coverage do
+		desc "Generate a detailed text coverage report"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = RCOV_OPTS + ['--text-report']
+			task.rcov = true
+		end
+
+		desc "Show differences in coverage from last run"
+		Spec::Rake::SpecTask.new( :diff ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS - ['--save'] + ['--text-coverage-diff']
+			task.rcov = true
+		end
+
+		### Task: verify coverage
+		desc "Build coverage statistics"
+		VerifyTask.new( :verify => :rcov ) do |task|
+			task.threshold = COVERAGE_MINIMUM
+		end
+
+		desc "Run RCov in 'spec-only' mode to check coverage from specs"
+		Spec::Rake::SpecTask.new( :speconly ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = ['--exclude', RCOV_EXCLUDES, '--text-report', '--save']
+			task.rcov = true
+		end
+	end
+
+	task :clobber_coverage do
+		rmtree( COVERAGE_TARGETDIR )
+	end
+
+rescue LoadError => err
+	task :no_rcov do
+		$stderr.puts "Coverage tasks not defined: RSpec+RCov tasklib not available: %s" %
+		[ err.message ]
+	end
+
+	task :coverage => :no_rcov
+	task :clobber_coverage
+	task :rcov => :no_rcov
+	namespace :coverage do
+		task :text => :no_rcov
+		task :diff => :no_rcov
+	end
+	task :verify => :no_rcov
+end
+
+

data/rake/verifytask.rb

@@ -0,0 +1,64 @@
+#####################################################################
+###	S U B V E R S I O N   T A S K S   A N D   H E L P E R S
+#####################################################################
+
+require 'rake/tasklib'
+
+#
+# Work around the inexplicable behaviour of the original RDoc::VerifyTask, which 
+# errors if your coverage isn't *exactly* the threshold.
+# 
+
+# A task that can verify that the RCov coverage doesn't
+# drop below a certain threshold. It should be run after
+# running Spec::Rake::SpecTask.
+class VerifyTask < Rake::TaskLib
+	
+	COVERAGE_PERCENTAGE_PATTERN = 
+		%r{<tt class='coverage_code'>(\d+\.\d+)%</tt>}
+	
+	# Name of the task. Defaults to :verify_rcov
+	attr_accessor :name
+
+	# Path to the index.html file generated by RCov, which
+	# is the file containing the total coverage.
+	# Defaults to 'coverage/index.html'
+	attr_accessor :index_html
+
+	# Whether or not to output details. Defaults to true.
+	attr_accessor :verbose
+
+	# The threshold value (in percent) for coverage. If the 
+	# actual coverage is not equal to this value, the task will raise an 
+	# exception. 
+	attr_accessor :threshold
+
+	def initialize( name=:verify )
+		@name = name
+		@index_html = 'coverage/index.html'
+		@verbose = true
+		yield self if block_given?
+		raise "Threshold must be set" if @threshold.nil?
+		define
+	end
+
+	def define
+		desc "Verify that rcov coverage is at least #{threshold}%"
+
+		task @name do
+			total_coverage = nil
+			if match = File.read( index_html ).match( COVERAGE_PERCENTAGE_PATTERN )
+				total_coverage = Float( match[1] )
+			else
+				raise "Couldn't find the coverage percentage in #{index_html}"
+			end
+
+			puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+			if total_coverage < threshold
+				raise "Coverage must be at least #{threshold}% but was #{total_coverage}%"
+			end
+		end
+	end
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/lib/helpers.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/ruby
+
+begin
+	require 'wordnet'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+module WordNet::SpecHelpers
+
+	###############
+	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
+	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>"
+		end
+
+		if extra = extra_failure_content( failure )
+			@output.puts( extra )
+		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
+	end
+end
+
+

data/spec/wordnet/lexicon_spec.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + 'lib'
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+begin
+	require 'fileutils'
+	require 'tmpdir'
+	require 'bdb'
+	require 'spec/runner'
+	require 'spec/lib/helpers'
+
+	require 'wordnet/lexicon'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe WordNet::Lexicon do
+	include WordNet::SpecHelpers
+
+	TEST_WORDS = {
+		'activity'		=> WordNet::Noun,
+		'sword'			=> WordNet::Noun,
+		'density'		=> WordNet::Noun,
+		'burly'			=> WordNet::Adjective,
+		'wispy'			=> WordNet::Adjective,
+		'traditional'	=> WordNet::Adjective,
+		'sit'			=> WordNet::Verb,
+		'take'			=> WordNet::Verb,
+		'joust'			=> WordNet::Verb,
+	}
+
+
+	before( :each ) do
+		@path = make_tempdir()
+	end
+
+
+	after( :each ) do
+		FileUtils.rm_rf @path, :verbose => $DEBUG
+	end
+
+	
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+	it "defaults to being in :readonly mode" do
+		env = stub( "bdb environment handle", :open_db => nil )
+		BDB::Env.should_receive( :new ).
+			with( @path.to_s, WordNet::Lexicon::ENV_FLAGS_RO, WordNet::Lexicon::ENV_OPTIONS ).
+			and_return( env )
+
+		lex = WordNet::Lexicon.new( @path.to_s )
+
+		lex.should be_readonly()
+		lex.should_not be_readwrite()
+	end
+	
+	it "can be created in :writable mode" do
+		env = stub( "bdb environment handle", :open_db => nil )
+		BDB::Env.should_receive( :new ).
+			with( @path.to_s, WordNet::Lexicon::ENV_FLAGS_RW, WordNet::Lexicon::ENV_OPTIONS ).
+			and_return( env )
+
+		lex = WordNet::Lexicon.new( @path.to_s, :writable )
+
+		lex.should_not be_readonly()
+		lex.should be_readwrite()
+	end
+	
+	it "passes a read/write flagset to BDB when created in :readwrite mode" do
+		env = stub( "bdb environment handle", :open_db => nil )
+		BDB::Env.should_receive( :new ).
+			with( @path.to_s, WordNet::Lexicon::ENV_FLAGS_RW, WordNet::Lexicon::ENV_OPTIONS ).
+			and_return( env )
+
+		lex = WordNet::Lexicon.new( @path.to_s, :readwrite )
+
+		lex.should_not be_readonly()
+		lex.should be_readwrite()
+	end
+	
+
+	describe "created in readonly mode" do
+
+		before( :each ) do
+			@env = mock( "bdb environment handle" )
+			BDB::Env.stub!( :new ).and_return( @env )
+			@env.stub!( :open_db )
+
+			@lexicon = WordNet::Lexicon.new( @path.to_s, :readonly )
+		end
+
+
+		it "doesn't try to remove logs" do
+			@env.should_not_receive( :log_archive )
+			@lexicon.clean_logs
+		end
+		
+		
+	end
+
+
+	describe "created in readwrite mode" do
+
+		before( :each ) do
+			@env = mock( "bdb environment handle" )
+			BDB::Env.stub!( :new ).and_return( @env )
+			@env.stub!( :open_db )
+
+			@lexicon = WordNet::Lexicon.new( @path.to_s, :readwrite )
+		end
+		
+
+		it "can be closed" do
+			@env.should_receive( :close )
+			@lexicon.close
+		end
+
+		it "provides a delegator for the checkpoint method of the underlying database" do
+			@env.should_receive( :checkpoint )
+			@lexicon.checkpoint
+		end
+	
+		it "provides an interface to clean up database transaction logs" do
+			@env.should_receive( :log_archive ).with( BDB::ARCH_ABS ).
+				and_return([ :log1, :log2 ])
+			File.should_receive( :chmod ).with( 0777, :log1 )
+			File.should_receive( :delete ).with( :log1 )
+			File.should_receive( :chmod ).with( 0777, :log2 )
+			File.should_receive( :delete ).with( :log2 )
+			
+			@lexicon.clean_logs
+		end
+		
+	
+	end
+	
+
+	describe "with a converted WordNet database" do
+
+		before( :all ) do
+			@basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+			@datadir = @basedir + 'ruby-wordnet'
+		end
+
+		before( :each ) do
+			pending "you haven't converted the WordNet datafiles yet -- try 'rake convert'" unless
+			 	@datadir.directory?
+
+			@lexicon = WordNet::Lexicon.new( @datadir.to_s )
+		end
+
+
+		TEST_WORDS.each do |word, pos|
+			it "returns a Fixnum value for the familiarity of #{word}(#{pos})" do
+				@lexicon.familiarity( word, pos ).should be_an_instance_of( Fixnum )
+			end
+		end
+		
+		
+		it "returns the root word as the morphological conversion of a dictionary word it knows about" do
+			@lexicon.morph( "angriest", WordNet::Adjective ).should == 'angry'
+		end
+
+
+		it "returns nil as the morphological conversion of a dictionary word it doesn't know about" do
+			@lexicon.morph( "Passomoquoddy", WordNet::Noun ).should be_nil()
+		end
+
+
+		it "returns the 'reverse morph' of dictionary words it knows about" do
+			@lexicon.reverse_morph( "angry" ).should == 'angriest%a'
+		end
+
+
+		it "tries looking up a failing via its morphological conversion if the original fails" do
+			synsets = @lexicon.lookup_synsets( 'angriest', WordNet::Adjective )
+			
+			synsets.should_not be_nil()
+			synsets.first.should be_an_instance_of( WordNet::Synset )
+			synsets.first.words.should include( 'angry' )
+		end
+
+
+		it "returns only the requested sense if a sense is specified" do
+			synset = @lexicon.lookup_synsets( 'run', WordNet::Verb, 4 )
+			synset.should be_an_instance_of( WordNet::Synset )
+			synset.words.first.should =~ /operate/i
+		end
+		
+		
+		it "can find every compound sense of a word in its dictionary" do
+			words = @lexicon.grep( 'thing' )
+
+			words.should have(10).members
+			words.should include( 'thing%n' )
+			words.should include( 'thing-in-itself%n' )
+			words.should include( 'thingamabob%n' )
+			words.should include( 'thingamajig%n' )
+			words.should include( 'thingmabob%n' )
+			words.should include( 'thingmajig%n' )
+			words.should include( 'things%n' )
+			words.should include( 'thingumabob%n' )
+			words.should include( 'thingumajig%n' )
+			words.should include( 'thingummy%n' )
+		end
+		
+		
+		TEST_WORDS.each do |word, pos|
+			it "can look up the synset #{word}(#{pos}) by word and part-of-speech" do
+				synsets = @lexicon.lookup_synsets( word, pos )
+
+				synsets.should have_at_least(1).members
+				synsets.each do |ss|
+					ss.should be_an_instance_of( WordNet::Synset )
+				end
+			end
+		end
+
+
+		it "can act as a factory for new synsets" do
+			@lexicon.create_synset( "Ruby", WordNet::Noun ).
+				should be_an_instance_of( WordNet::Synset )
+		end
+
+	end
+
+end
+