words 0.1.0

data/.gitignore

@@ -0,0 +1,26 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## ECLIPSE
+.loadpath
+.project
+.document
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Roja Buck
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,85 @@
+# Words - A fast, easy to use interface to WordNet® with cross ruby distribution compatability. #
+
+## About ##
+
+Words implements a fast interface to [Wordnet®](http://wordnet.princeton.edu) which makes use of [Tokyo Cabinet](http://1978th.net/tokyocabinet/) and a FFI interface, [rufus-tokyo](http://github.com/jmettraux/rufus-tokyo), to provide cross ruby distribution compatability and blistering speed. I have attempted to provide ease of use in the form of a simple yet powerful api and installation is a sintch, we even include the data in it's tokyo data format (subject to the original wordnet licencing.)
+
+## Installation ##
+
+First ensure you have [Tokyo Cabinet](http://1978th.net/tokyocabinet/) installed. It should be nice and easy...
+
+After this it should be just a gem to install. For those of you with old rubygems versions first:
+
+    gem install gemcutter  # These two steps are only necessary if you haven't
+    gem tumble             # yet installed the gemcutter tools
+    
+Otherwise and after it's simply:
+
+	gem install words
+	
+Then your ready to rock and roll. :)
+
+## Build Data (Optional) ##
+
+If you want to build the wordnet dataset file yourself, from the original wordnet files, you can use the bundled "build_dataset.rb"
+
+	./build_dataset.rb -h #this will give you the usage
+	sudo ./build_dataset.rb #this will attempt to build the data locating the original wordnet files through a search...
+
+## Usage ##
+
+Heres a few little examples of using words within your programs.
+
+
+    require 'rubygems'
+    require 'words'
+    
+    data = Words::Words.new
+    
+    # locate a word
+    lemma = data.find("bat")
+    
+    lemma.to_s # => bat, noun/verb
+    lemma.available_pos.inspect # => [:noun, :verb]
+    
+    lemma.synsets(:noun) # => array of synsets which represent nouns of the lemma bat
+    # or
+    lemma.nouns # => array of synsets which represent nouns of the lemma bat
+    lemma.verbs? #=> true
+    
+    # specify a sense
+    sense = lemma.nouns.last
+    sense2 = lemma.nouns[2]
+    
+    sense.gloss # => a club used for hitting a ball in various games
+    sense2.words # => ["cricket bat", "bat"]
+    sense.relations.first # => "Semantic hypernym relation between n02806379 and n03053474"
+
+    sense.relations(:hyponym) # => Array of hyponyms associated with the sense
+    # or
+    sense.hyponyms # => Array of hyponyms associated with the sense
+    sense.hyponyms? # => true
+    
+    sense.relations.first.is_semantic? # => true
+    sense.relations.first.source_word # => nil
+    sense.relations.first.destination # => the synset of n03053474
+    
+    sense.derivationally_related_forms.first.is_semantic? # => false
+    sense.derivationally_related_forms.first.source_word # => "bat"
+    sense.derivationally_related_forms.first.destination_word # => "bat"
+    sense.derivationally_related_forms.first.destination # => the synset of v01413191
+        
+
+## Note on Patches/Pull Requests ##
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright ##
+
+Copyright (c) 2010 Roja Buck. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "words"
+    gem.summary = %Q{A fast, easy to use interface to WordNet® with cross ruby distribution compatability.}
+    gem.description = %Q{A fast, easy to use interface to WordNet® with cross ruby distribution compatability. We use TokyoCabinet to store the dataset and the excellent rufus-tokyo to interface with it. This allows us to have full compatability across ruby distributions while still remaining both fast and simple to use.}
+    gem.email = "roja@arbia.co.uk"
+    gem.homepage = "http://github.com/roja/words"
+    gem.authors = ["Roja Buck"]
+    gem.add_development_dependency "trollop", ">= 1.15"
+    gem.add_dependency 'rufus-tokyo', '>= 1.0.5'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "words #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/build_dataset.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+# std includes
+require 'pathname'
+
+# gem includes
+require 'rubygems'
+require 'trollop'
+require 'pstore'
+require 'rufus-tokyo'
+
+POS_FILE_TYPES = %w{ adj adv noun verb }
+POS_FILE_TYPE_TO_SHORT = { 'adj' => 'a', 'adv' => 'r', 'noun' => 'n', 'verb' => 'v' }
+
+def locate_wordnet(base_dir)
+  puts "Checking #{base_dir} & spcific children for wordnet files..." if VERBOSE
+  path = Pathname.new base_dir
+  return nil unless path.exist?
+  return path if (path + "data.noun").exist?
+  return path + "dict" if (path + "dict/data.noun").exist?
+end
+
+if __FILE__ == $0
+  
+  puts "Words Dataset Constructor 2010 (c) Roja Buck"
+  
+  opts = Trollop::options do
+    opt :verbose, "Output verbose program detail.", :default => false
+    opt :wordnet, "Location of the wordnet dictionary directory", :default => "Search..."
+  end
+  puts "Verbose mode enabled" if (VERBOSE = opts[:verbose])
+  
+  wordnet_dir = nil
+  if opts[:wordnet] == "Search..."
+    ['/usr/share/wordnet', '/usr/local/share/wordnet', '/usr/local/WordNet-3.0'].each do |potential_dir|
+      break unless (wordnet_dir = locate_wordnet potential_dir).nil?
+    end
+    abort( "Unable to locate wordnet dictionary. To specify check --help." ) if wordnet_dir.nil?
+  else
+    wordnet_dir = locate_wordnet opts[:wordnet]
+    abort( "Unable to locate wordnet dictionary in directory #{opts[:wordnet]}. Please check and try again." ) if wordnet_dir.nil?
+  end
+  
+  # At this point we know we should have a wordnet directory within wordnet_dir
+  puts "Found wordnet files in #{wordnet_dir}..." if VERBOSE
+  
+  index_files = POS_FILE_TYPES.map { |pos| wordnet_dir + "index.#{pos}" }
+  data_files = POS_FILE_TYPES.map { |pos| wordnet_dir + "data.#{pos}" }
+  
+   (index_files + data_files).each do |required_file|
+    abort( "Unable to locate #{required_file} within the wordnet dictionary. Please check your wordnet copy is valid and try again." ) unless required_file.exist?
+    abort( "Cannot get readable permissions to #{required_file} within the wordnet dictionary. Please check the file permissions and try again." ) unless required_file.readable?
+  end
+  
+  # At this point we know we have the correct files, though we don't know there validity
+  puts "Validated existance of wordnet files in #{wordnet_dir}..." if VERBOSE
+  
+  # Build data
+  
+  hash = Rufus::Tokyo::Table.new("data/wordnet.tct")
+  POS_FILE_TYPES.each do |file_pos|
+    
+    puts "Building #{file_pos} indexes..." if VERBOSE
+    
+    # add indexes
+     (wordnet_dir + "index.#{file_pos}").each_line do |index_line|
+      next if index_line[0, 2] == "  "
+      index_parts = index_line.split(" ")
+      
+      lemma, pos, synset_count, pointer_count = index_parts.shift, index_parts.shift, index_parts.shift.to_i, index_parts.shift.to_i
+      pointer_symbols = Array.new(pointer_count).map { POS_FILE_TYPE_TO_SHORT[file_pos] + index_parts.shift }
+      sense_count = index_parts.shift
+      tagsense_count = pos + index_parts.shift
+      synset_ids = Array.new(synset_count).map { POS_FILE_TYPE_TO_SHORT[file_pos] + index_parts.shift }
+      
+      hash[lemma] = { "synset_ids" => '', "tagsense_counts" => '' } if hash[lemma].nil?
+      
+      hash[lemma] = { "lemma" => lemma, "synset_ids" => (hash[lemma]["synset_ids"].split('|') + synset_ids).join('|'), # append synsets 
+                      "tagsense_counts" => (hash[lemma]["tagsense_counts"].split('|') << tagsense_count).join('|') } # append pointer symbols
+    end
+    
+    puts "Adding #{file_pos} data..." if VERBOSE
+    
+    # add data
+     (wordnet_dir + "data.#{file_pos}").each_line do |data_line|
+      next if data_line[0, 2] == "  "
+      data_line, gloss = data_line.split(" | ")
+      data_parts = data_line.split(" ")
+      
+      synset_id, lexical_filenum, synset_type, word_count = POS_FILE_TYPE_TO_SHORT[file_pos] + data_parts.shift, data_parts.shift, data_parts.shift, data_parts.shift.to_i(16)
+      words = Array.new(word_count).map { "#{data_parts.shift}.#{data_parts.shift}" }
+      relations = Array.new(data_parts.shift.to_i).map { "#{data_parts.shift}.#{data_parts.shift}.#{data_parts.shift}.#{data_parts.shift}" }
+      
+      hash[synset_id] = { "synset_id" => synset_id, "lexical_filenum" => lexical_filenum, "synset_type" => synset_type, 
+                          "words" => words.join('|'), "relations" => relations.join('|'), "gloss" => gloss }
+    end
+    
+    
+  end
+  hash.close
+  
+end

data/examples.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'lib/words'
+
+if __FILE__ == $0
+  
+  wordnet = Words::Words.new
+  
+  puts wordnet.find('bat')
+  puts wordnet.find('bat').available_pos.inspect
+  puts wordnet.find('bat').lemma
+  puts wordnet.find('bat').synsets('noun')
+  puts wordnet.find('bat').synsets('noun').last.words.inspect
+  puts wordnet.find('bat').synsets('noun').last.relations
+  wordnet.find('bat').synsets('noun').last.relations.each { |relation| puts relation.inspect }
+  puts wordnet.find('bat').synsets('noun').last.methods
+  puts wordnet.find('bat').synsets('noun').last.hyponyms?
+  puts wordnet.find('bat').synsets('noun').last.participle_of_verbs?
+  
+  puts wordnet.find('bat').synsets('noun').last.relations(:hyponym)
+  puts wordnet.find('bat').synsets('noun').last.relations("~")
+  puts wordnet.find('bat').synsets('verb').last.inspect
+  puts wordnet.find('bat').synsets('verb').last.words
+  puts wordnet.find('bat').synsets('verb').last.words_with_num.inspect
+  
+  wordnet.close
+  
+end

data/lib/words.rb

@@ -0,0 +1,229 @@
+# std includes
+require 'pathname'
+require 'set'
+
+# gem includes
+require 'rubygems'
+require 'rufus-tokyo'
+
+module Words
+  
+  class WordnetConnection
+    
+    def self.wordnet_connection
+      @@wordnet_connection
+    end
+    
+    def self.wordnet_connection=(x)
+      @@wordnet_connection = x
+    end
+    
+  end
+  
+  class Relation
+    
+    RELATION_TO_SYMBOL = { "-c" => :member_of_this_domain_topic, "+" => :derivationally_related_form, "%p" => :part_meronym, "~i" => :instance_hyponym, "@" => :hypernym, 
+                    ";r" => :domain_of_synset_region, "!" => :antonym, "#p" => :part_holonym, "%s" => :substance_meronym, ";u" => :domain_of_synset_usage, 
+                    "-r" => :member_of_this_domain_region, "#s" => :substance_holonym, "=" => :attribute, "-u" => :member_of_this_domain_usage, ";c" => :domain_of_synset_topic,
+                    "%m"=> :member_meronym, "~" => :hyponym, "@i" => :instance_hypernym, "#m" => :member_holonym, "$" => :verb_group, ">" => :cause, "*" => :entailment,
+                    "\\" => :pertainym, "<" => :participle_of_verb, "&" => :similar_to, "^" => :see_also }
+    SYMBOL_TO_RELATION = RELATION_TO_SYMBOL.invert
+    
+    def initialize(relation_construct, source_synset)
+      @symbol, @dest_synset_id, @pos, @source_dest = relation_construct.split('.')
+      @dest_synset_id = @pos + @dest_synset_id
+      @symbol = RELATION_TO_SYMBOL[@symbol]
+      @source_synset = source_synset
+    end
+    
+    def is_semantic?
+      @source_dest == "0000"
+    end
+    
+    def source_word
+      is_semantic? ? @source_word = nil : @source_word = @source_synset.words[@source_dest[0..1].to_i(16)-1] unless defined? @source_word
+      @source_word
+    end
+    
+    def destination_word
+      is_semantic? ? @destination_word = nil : @destination_word = destination.words[@source_dest[2..3].to_i(16)-1] unless defined? @destination_word
+      @destination_word
+    end
+    
+    def relation_type?(type)
+      case 
+        when SYMBOL_TO_RELATION.include?(type.to_sym)
+        type.to_sym == @symbol
+        when RELATION_TO_SYMBOL.include?(pos.to_s)
+        POINTER_TO_SYMBOL[type.to_sym] == @symbol
+      else
+        false
+      end
+    end
+    
+    def relation_type
+      @symbol
+    end
+    
+    def destination
+      @destination = Synset.new(@dest_synset_id) unless defined? @destination
+      @destination
+    end
+    
+    def to_s      
+      @to_s = "#{relation_type.to_s.gsub('_', ' ').capitalize} relation between #{@source_synset.synset_id}'s word \"#{source_word}\" and #{@dest_synset_id}'s word \"#{destination_word}\"" if !is_semantic? && !defined?(@to_s) 
+      @to_s = "Semantic #{relation_type.to_s.gsub('_', ' ')} relation between #{@source_synset.synset_id} and #{@dest_synset_id}" if  is_semantic? && !defined?(@to_s) 
+      @to_s
+    end
+    
+    def inspect
+      { :symbol => @symbol, :dest_synset_id => @dest_synset_id, :pos => @pos, :source_dest => @source_dest }.inspect
+    end
+    
+  end
+  
+  class Synset
+    
+    SYNSET_TYPE_TO_SYMBOL = {"n" => :noun, "v" => :verb, "a" => :adjective, "r" => :adverb, "s" => :adjective_satallite }
+    
+    def initialize(synset_id)
+      @synset_hash = WordnetConnection::wordnet_connection[synset_id]
+      # construct some conveniance menthods for relation type access
+      Relation::SYMBOL_TO_RELATION.keys.each do |relation_type|
+        self.class.send(:define_method, "#{relation_type}s?") do 
+          relations(relation_type).size > 0
+        end
+        self.class.send(:define_method, "#{relation_type}s") do 
+          relations(relation_type)
+        end
+      end
+    end
+    
+    def synset_type
+      SYNSET_TYPE_TO_SYMBOL[@synset_hash["synset_type"]]
+    end
+    
+    def words
+      @words = words_with_num.map { |word_with_num| word_with_num[:word] } unless defined? @words
+      @words
+    end
+    
+    def size
+      words.size
+    end
+    
+    def words_with_num
+      @words_with_num = @synset_hash["words"].split('|').map { |word| word_parts = word.split('.'); { :word => word_parts[0].gsub('_', ' '), :num => word_parts[1] } } unless defined? @words_with_num
+      @words_with_num
+    end
+    
+    def synset_id
+      @synset_hash["synset_id"]
+    end
+    
+    def gloss
+      @synset_hash["gloss"]
+    end
+    
+    def inspect
+      @synset_hash.inspect
+    end
+    
+    def relations(type = :all)
+      @relations = @synset_hash["relations"].split('|').map { |relation| Relation.new(relation, self) } unless defined? @relations
+      case 
+        when Relation::SYMBOL_TO_RELATION.include?(type.to_sym)
+        @relations.select { |relation| relation.relation_type == type.to_sym }
+        when Relation::RELATION_TO_SYMBOL.include?(type.to_s)
+        @relations.select { |relation| relation.relation_type == Relation::RELATION_TO_SYMBOL[type.to_s] }
+      else
+        @relations
+      end
+    end
+    
+    def to_s
+      @to_s = "#{synset_type.to_s.capitalize} including word(s): #{words.map { |word| '"' + word + '"' }.join(', ')} meaning: #{gloss}" unless defined? @to_s
+      @to_s
+    end
+    
+  end
+  
+  class Lemma
+    
+    POS_TO_SYMBOL = {"n" => :noun, "v" => :verb, "a" => :adjective, "r" => :adverb}
+    SYMBOL_TO_POS = POS_TO_SYMBOL.invert
+    
+    def initialize(lemma_hash)
+      @lemma_hash = lemma_hash
+      # construct some conveniance menthods for relation type access
+      SYMBOL_TO_POS.keys.each do |pos|
+        self.class.send(:define_method, "#{pos}s?") do 
+          synsets(pos).size > 0
+        end
+        self.class.send(:define_method, "#{pos}s") do 
+          synsets(pos)
+        end
+      end
+    end
+    
+    def lemma
+      @lemma = @lemma_hash["lemma"].gsub('_', ' ') unless defined? @lemma
+      @lemma
+    end
+    
+    def available_pos
+      @available_pos = synset_ids.map { |synset_id| POS_TO_SYMBOL[synset_id[0,1]] }.uniq unless defined? @available_pos
+      @available_pos
+    end
+    
+    def to_s
+      @to_s = [lemma, " " + available_pos.join("/")].join(",") unless defined? @to_s
+      @to_s
+    end
+    
+    def synsets(pos = :all)
+      relevent_synsets = case 
+        when SYMBOL_TO_POS.include?(pos.to_sym)
+        synset_ids.select { |synset_id| synset_id[0,1] == SYMBOL_TO_POS[pos.to_sym] }
+        when POS_TO_SYMBOL.include?(pos.to_s)
+        synset_ids.select { |synset_id| synset_id[0,1] == pos.to_s }
+      else
+        synset_ids
+      end
+      relevent_synsets.map { |synset_id| Synset.new synset_id }
+    end
+    
+    def synset_ids
+      @synset_ids = @lemma_hash["synset_ids"].split('|') unless defined? @synset_ids
+      @synset_ids
+    end
+    
+    def inspect
+      @lemma_hash.inspect
+    end
+    
+    alias word lemma
+    
+  end
+  
+  class Words
+    
+    def initialize(path = 'data/wordnet.tct')
+      if (Pathname.new path).exist?
+        WordnetConnection::wordnet_connection = Rufus::Tokyo::Table.new(path)
+      else
+        abort("Failed to locate the words database at #{(Pathname.new path).realpath}")
+      end
+    end
+    
+    def find(word)
+      Lemma.new WordnetConnection::wordnet_connection[word]
+    end
+    
+    def close
+      WordnetConnection::wordnet_connection.close
+    end
+    
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'words'
+
+class Test::Unit::TestCase
+end

data/test/test_words.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestWords < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: words
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Roja Buck
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-14 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.15"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rufus-tokyo
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.5
+    version: 
+description: "A fast, easy to use interface to WordNet\xC2\xAE with cross ruby distribution compatability. We use TokyoCabinet to store the dataset and the excellent rufus-tokyo to interface with it. This allows us to have full compatability across ruby distributions while still remaining both fast and simple to use."
+email: roja@arbia.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- build_dataset.rb
+- data/wordnet.tct
+- examples.rb
+- lib/words.rb
+- test/helper.rb
+- test/test_words.rb
+has_rdoc: true
+homepage: http://github.com/roja/words
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: "A fast, easy to use interface to WordNet\xC2\xAE with cross ruby distribution compatability."
+test_files: 
+- test/test_words.rb
+- test/helper.rb