moby 1.0.1beta

data/.gitignore

@@ -0,0 +1,3 @@
+*.swp
+*.swo
+pkg/*

data/.rvmrc

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.2" > .rvmrc
+environment_id="ruby-1.9.2-p290@moby"
+
+#
+# Uncomment the following lines if you want to verify rvm version per project
+#
+# rvmrc_rvm_version="1.10.2" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+#
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+#
+# The variable PROJECT_JRUBY_OPTS requires the following to be run in shell:
+#
+#    chmod +x ${rvm_path}/hooks/after_use_jruby_opts
+#
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && ! command -v bundle >/dev/null
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && command -v bundle
+# then
+#   bundle install
+# fi
+
+if [[ $- == *i* ]] # check for interactive shells
+then
+    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+else 
+	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+fi
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gem "rspec", :group => :test

data/Gemfile.lock

@@ -0,0 +1,18 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec

data/README.md

@@ -0,0 +1,83 @@
+Moby
+====
+
+**WIP**
+
+Ruby interface for [Moby Project](http://en.wikipedia.org/wiki/Moby_Project)
+[wordlists](http://www.gutenberg.org/catalog/world/results?title=moby+list)
+
+### Usage
+
+```ruby
+pos = Moby::PartsOfSpeech.new
+```
+
+### List
+
+Get word lists by part of speech 
+
+```ruby
+pos.nouns 
+pos.plurals
+pos.noun_phrases
+pos.adjectives
+pos.adverbs
+pos.conjunctions
+pos.prepositions
+pos.interjections
+pos.pronouns
+pos.definite_articles
+pos.indefinite_articles
+pos.nominatives
+```
+
+`#verbs` takes an optional `:type` parameter since there's three types 
+
+```ruby
+pos.verbs
+pos.verbs(:type => :all) # default
+pos.verbs(:type => :usu)
+pos.verbs(:type => :transitive)
+pos.verbs(:type => :intransitive)  
+```
+
+### Find
+
+Find parts of speech info for a word
+
+```ruby
+pos.find("word") 
+#=> {
+#=>   :word => "word", 
+#=>   :code => "Nt", 
+#=>   :pos => [:noun, :vert_transitive]
+#=> }
+  
+pos.find("walk") 
+#=> {
+#=>   :word => "walk", 
+#=>   :code => "iNt", 
+#=>   :pos => [:noun, :verb_transitive, :verb_intransitive]
+#=> }
+```
+
+### Query
+
+Check a word by part of speech
+
+```ruby
+pos.noun?("animal")             #=> true
+pos.verb?("run")                #=> true
+pos.intransitive_verb?("walk")  #=> true
+pos.adjective?("sky")           #=> false
+```
+
+`#verb?` takes an optional `:type` parameter (like `#verbs`)
+
+```ruby
+pos.verb?("abandon", :type => :transitive)          #=> true
+pos.verb?("overurbanized", :type => :intransitive)  #=> false
+pos.verb?("overurbanized")                          #=> true
+```
+
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/moby/parts_of_speech.rb

@@ -0,0 +1,133 @@
+module Moby
+  class PartsOfSpeech
+    def find(word)
+      { :word  => word,
+        :found => pos.has_key?(word),
+        :code  => pos_code(word),
+        :pos   => pos_breakdown(word)
+      }
+    end
+
+    # Word list methods
+
+    def nouns; words(:noun); end
+    def plurals; words(:plural) end
+    def noun_phrases; words(:noun_phrase); end
+    def adjectives; words(:adjective); end
+    def adverbs; words(:adverb); end
+    def conjunctions; words(:conjunction); end
+    def prepositions; words(:preposition); end
+    def interjections; words(:interjection); end
+    def pronouns; words(:pronoun); end
+    def definite_articles; words(:definite_article); end
+    def indefinite_articles; words(:indefinite_article); end
+    def nominatives; words(:nominatives); end
+
+    def verbs(options = {:type => :all})
+      case options[:type]
+      when :all
+        words(:verb_usu_participle) +
+        words(:verb_transitive) +
+        words(:verb_intransitive)
+      when :usu
+        words(:verb_usu_participle)
+      when :transitive
+        words(:verb_transitive)
+      when :intransitive
+        words(:verb_intransitive)
+      end
+    end
+
+    # Query methods
+
+    def noun?(word); pos?(word, :noun); end
+    def plural?(word); pos?(word, :plural); end
+    def noun_phrase?(word); pos?(word, :noun_phrase); end
+    def adjective?(word); pos?(word, :adjective); end
+    def adverb?(word); pos?(word, :adverb); end
+    def conjunction?(word); pos?(word, :conjunction); end
+    def preposition?(word); pos?(word, :preposition); end
+    def interjection?(word); pos?(word, :interjection); end
+    def pronoun?(word); pos?(word, :pronoun); end
+    def definite_article?(word); pos?(word, :definite_article); end
+    def indefinite_article?(word); pos?(word, :indefinite_article); end
+    def nominative?(word); pos?(word, :nominative); end
+
+    def verb?(word, options = {:type => :all})
+      case options[:type]
+      when :all
+        pos?(word, :verb_usu_participle) ||
+        pos?(word, :verb_transitive) ||
+        pos?(word, :verb_intransitive)
+      when :usu
+        pos?(word, :verb_usu_participle)
+      when :transitive
+        pos?(word, :verb_transitive)
+      when :intransitive
+        pos?(word, :verb_intransitive)
+      end
+    end
+
+    private
+      def pos
+        path = %w{share moby parts-of-speech mobypos.UTF-8.txt}
+        pos = File.open(File.join(Moby::base_path, *path))
+
+        @pos ||= Hash[
+          pos.readlines.map {|ln|
+            ln.split('\\').map {|p| p.strip }
+          }
+        ]
+
+        @pos.default = ""
+        @pos
+      end
+
+      def pos?(word, pos_name)
+        find(word)[:pos].include?(pos_name.to_sym)
+      end
+
+      # Get words by pos name
+      def words(pos_name)
+        pos.select {|w, c| c.include?(pos_code_map.key(pos_name)) }.keys
+      end
+
+      # Get part of speech code for word
+      def pos_code(word)
+        pos[word]
+      end
+
+      def pos_code_map
+        @pos_code_map ||= {
+          "N" => :noun,
+          "p" => :plural,
+          "h" => :noun_phrase,
+          "V" => :verb_usu_participle,
+          "t" => :verb_transitive,
+          "i" => :verb_intransitive,
+          "A" => :adjective,
+          "v" => :adverb,
+          "C" => :conjunction,
+          "P" => :preposition,
+          "!" => :interjection,
+          "r" => :pronoun,
+          "D" => :definite_article,
+          "I" => :indefinite_article,
+          "o" => :nominative
+        }
+      end
+
+      def pos_codes
+        pos_code_map.keys
+      end
+
+      def pos_names
+        pos_code_map.values
+      end
+
+      # Convert POS code to array of descriptive symbols from #pos_code_map
+      def pos_breakdown(word)
+        pos_code(word).chars.to_a.map {|c| pos_code_map[c] }
+      end
+  end
+end

data/lib/moby/version.rb

@@ -0,0 +1,3 @@
+module Moby
+  VERSION = "1.0.1beta"
+end

data/lib/moby.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'moby/version'
+require "moby/parts_of_speech"
+
+module Moby
+  def self.base_path
+    File.expand_path("../..", __FILE__)
+  end
+end

data/moby.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "moby/version"
+
+Gem::Specification.new do |s|
+  s.name        = "moby"
+  s.version     = Moby::VERSION
+  s.authors     = ["Dan Richert"]
+  s.email       = ["dan.richert@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Ruby interface for Moby wordlists}
+  s.description = %q{Ruby interface for the world's largest free phonetic database}
+
+  s.rubyforge_project = "moby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end