treat 0.1.4 → 0.2.0

data/lib/treat/inflectors/declensions/linguistics.rb

@@ -7,31 +7,32 @@ module Treat
       # 
       # Project website: http://deveiate.org/projects/Linguistics/
       class Linguistics
-        # Require Ruby Linguistics
-        silence_warnings { require 'linguistics' }
+        require 'treat/helpers/linguistics_loader'
         # Retrieve a declension of a word using the 'linguistics' gem.
         # 
         # Options:
         #
         # - (Identifier) :count => :singular, :plural
         def self.declensions(entity, options = {})
-          begin
-            l = entity.language.to_s.upcase
-            delegate = nil
-            silence_warnings { delegate = ::Linguistics.const_get(l) }
-          rescue RuntimeError
-            raise "Ruby Linguistics does not have a module " +
-            " installed for the #{entity.language} language."
+          unless options[:count]
+            raise Treat::Exception, 
+            "Must supply option count (:singular or :plural)."
           end
+          klass = Treat::Helpers::LinguisticsLoader.load(entity.language)
           string = entity.to_s
+          if entity.category == :verb
+            raise Treat::Exception,
+            "Cannot retrieve the declensions of a verb. " +
+            "Use #singular_verb and #plural_verb instead."
+          end
           if options[:count] == :plural
             if entity.has?(:category) &&
               [:noun, :adjective, :verb].include?(entity.category)
               silence_warnings do
-                delegate.send(:"plural_#{entity.category}", string)
+                klass.send(:"plural_#{entity.category}", string)
               end
             else
-              silence_warnings { delegate.plural(string) }
+              silence_warnings { klass.plural(string) }
             end
           end
         end

data/lib/treat/inflectors/ordinal_words/linguistics.rb

@@ -7,12 +7,12 @@ module Treat
       #
       # Project website: http://deveiate.org/projects/Linguistics/
       class Linguistics
-        # Require Ruby Linguistics.
-        silence_warnings { require 'linguistics' }
+        require 'treat/helpers/linguistics_loader'
         # Desribe a number in words in ordinal form, using the
         # 'linguistics' gem.
         def self.ordinal_words(number, options = {})
-          silence_warnings { ::Linguistics::EN.ordinate(number.to_s) }
+          klass = Treat::Helpers::LinguisticsLoader.load(number.language)
+          klass.ordinate(number.to_s)
         end
       end
     end

data/lib/treat/install.rb

@@ -0,0 +1,59 @@
+module Treat
+  class Installer
+    require 'rubygems/dependency_installer'
+    # Install required dependencies and optional dependencies
+    # for a specific language.
+    def self.install(language = :english)
+
+      lang = Treat::Languages.get(language)
+      required = lang::RequiredDependencies
+      optional = lang::OptionalDependencies
+
+      puts "Treat Installer\n\n"
+      puts "Installing dependencies for the #{language.to_s.capitalize} language.\n\n"
+      
+      flag = false
+      
+      inst = Gem::DependencyInstaller.new
+
+      required.each do |dependency|
+        puts "Installing required dependency '#{dependency}'..."
+        begin
+          silence_warnings { inst.install(dependency) }
+        rescue
+          flag = true
+          puts "Couldn't install '#{dependency}'. " +
+          "You need install this dependency manually by running: " +
+          "'gem install #{dependency}' or use 'sudo' to run this script."
+        end
+      end
+
+      optional.each do |dependency|
+        begin
+          puts "Install optional dependency '#{dependency}' (yes/no, <enter> = skip) ?"
+          answer = gets.strip
+          raise Treat::Exception unless ['yes', 'no', ''].include?(answer)
+          if answer == 'yes'
+            silence_warnings { inst.install(dependency) }
+          else
+            puts "Skipped installing '#{dependency}'."
+            next
+          end
+        rescue Treat::Exception
+          puts "Invalid input - valid options are 'yes' or 'no'."
+          retry
+        rescue
+          flag = true
+          puts "Couldn't install '#{dependency}'. " +
+          "You can install this dependency manually by running: " +
+          "'gem install #{dependency}' or use 'sudo' to run this script."
+        end
+      end
+
+      w = flag ? 'incompletely' : 'normally'
+      puts "\nInstall proceeded #{w}."
+      puts
+
+    end
+  end
+end

data/lib/treat/kernel.rb

@@ -7,7 +7,7 @@ module Kernel
   # A list of acronyms used in class names within
   # the program. These do not CamelCase; they
   # CAMELCase.
-  Acronyms = ['XML', 'HTML', 'YAML', 'UEA', 'LDA', 'PDF', 'GOCR'].join('|')
+  Acronyms = ['XML', 'HTML', 'YAML', 'UEA', 'LDA', 'PDF'].join('|')
   # A cache to optimize camel casing.
   @@cc_cache = {}
   # A cache to optimize un camel casing.
@@ -24,15 +24,17 @@ module Kernel
     $VERBOSE = warn_level
     result
   end
-  # Runs a block of code while blocking
-  # stdout. Currently not implemented.
-  def silence_streams(*streams)
+  # Runs a block of code while blocking stdout.
+  def silence_stdout(log = '/dev/null')
+    old = $stdout.dup
+    $stdout.reopen(File.new(log, 'w'))
     yield
+    $stdout = old
   end
   # Create a temporary file which is deleted
   # after execution of the block.
   def create_temp_file(ext, value = nil, &block)
-    fname = "../tmp/#{Random.rand(10000000).to_s}.#{ext}"
+    fname = "#{Treat.lib}/../tmp/#{Random.rand(10000000).to_s}.#{ext}"
     File.open(fname, 'w') do |f| 
       f.write(value) if value 
       block.call(f.path)
@@ -40,11 +42,19 @@ module Kernel
   ensure
     File.delete(fname)
   end
+  # Create a temporary directory.
+  def create_temp_dir(&block)
+    dname = "#{Treat.lib}/../tmp/#{Random.rand(10000000).to_s}"
+    Dir.mkdir(dname)
+    block.call(dname)
+  ensure
+    FileUtils.rm_rf(dname)
+  end
   # Convert un_camel_case to CamelCase.
   def camel_case(o_phrase)
     phrase = o_phrase.to_s.dup
     return @@cc_cache[o_phrase] if @@cc_cache[o_phrase]
-    phrase.gsub!(/#{Acronyms.downcase}[^a-z]+/) { |a| a.upcase }
+    phrase.gsub!(/#{Acronyms.downcase}[^a-z]*/) { |a| a.upcase }
     phrase.gsub!(/^[a-z]|_[a-z]/) { |a| a.upcase }
     phrase.gsub!('_', '')
     @@cc_cache[o_phrase] = phrase
@@ -77,7 +87,7 @@ module Kernel
         sugg << element
       end
     end
-    unless sugg.empty?
+    unless sugg.size == 0
       if sugg.size == 1
         msg += " Perhaps you meant '#{sugg[0]}' ?"
       else
@@ -94,7 +104,7 @@ module Kernel
   def caller_method(n = 3)
     at = caller(n).first
     /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
-    :"#{Regexp.last_match[3]}"
+    Regexp.last_match[3].intern
   end
   alias :cm :caller_method
   # Return the levensthein distance between two stringsm

data/lib/treat/languages.rb

@@ -12,7 +12,7 @@ module Treat
     # or its full text description in full French or English.
     def self.describe(lang, desc_lang = :en)
       raise "Must provide a non-nil language identifier to describe." if lang.nil?
-      lang = find(lang).to_s
+      lang = code(lang).to_s
       if [:en, :eng, :english, :anglais].include?(desc_lang)
         l = @@english_full.key(lang)
       elsif [:fr, :fra, :french, :french].include?(desc_lang)
@@ -42,22 +42,22 @@ module Treat
     # or full name (in English or French) and return
     # the ISO-639-1 or ISO-639-2 language code as a
     # lowercase identifier.
-    def self.find(lang, rc = ISO639_2)
+    def self.code(lang, rc = ISO639_2)
       raise "Must provide a non-nil language identifier to describe." if lang.nil?
       get_languages
       lang = lang.to_s.downcase
       if @@iso639_1.has_key?(lang)
-        return :"#{lang}" if rc == ISO639_1
-        return :"#{@@iso639_1[lang]}" if rc == ISO639_2
+        return lang.intern if rc == ISO639_1
+        return @@iso639_1[lang].intern if rc == ISO639_2
       elsif @@iso639_2.has_key?(lang)
-        return :"#{lang}" if rc == ISO639_2
-        return :"#{@@iso639_2[lang]}" if rc == ISO639_1
+        return lang.intern if rc == ISO639_2
+        return @@iso639_2[lang].intern if rc == ISO639_1
       elsif @@english_full.has_key?(lang)
-        return :"#{@@english_full[lang]}" if rc == ISO639_2
-        return :"#{@@iso639_2[@@english_full[lang]]}" if rc == ISO639_1
+        return @@english_full[lang].intern if rc == ISO639_2
+        return @@iso639_2[@@english_full[lang]].intern if rc == ISO639_1
       elsif @@french_full.has_key?(lang)
-        return :"#{@@french_full[lang]}" if rc == ISO639_2
-        return :"#{@@iso639_1[@@french_full[lang]]}" if rc == ISO639_2
+        return @@french_full[lang].intern if rc == ISO639_2
+        return @@iso639_1[@@french_full[lang]].intern if rc == ISO639_2
       else
         not_found(lang)
       end
@@ -87,5 +87,12 @@ module Treat
       end
       @@loaded = true
     end
+    # A list of all possible word categories.
+    WordCategories = [
+      :adjective, :adverb, :noun, :verb, :interjection,
+      :clitic, :coverb, :conjunction, :determiner, :particle,
+      :preposition, :pronoun, :number, :symbol, :punctuation,
+      :complementizer
+    ]
   end
-end
+end

data/lib/treat/languages/arabic.rb

@@ -1,13 +1,15 @@
 module Treat
   module Languages
     class Arabic
+      RequiredDependencies = []
+      OptionalDependencies = []
       Extractors = {}
       Inflectors = {}
       Lexicalizers = {
-        tag: [:stanford]
+        :tag => [:stanford]
       }
       Processors = {
-        parsers: [:stanford]
+        :parsers => [:stanford]
       }
     end
   end

data/lib/treat/languages/chinese.rb

@@ -1,12 +1,16 @@
 module Treat
   module Languages
     class Chinese
+      RequiredDependencies = []
+      OptionalDependencies = []
       Extractors = {}
       Inflectors = {}
       Lexicalizers = {
-        tag: [:stanford]
+        :tag => [:stanford]
+      }
+      Processors = {
+        :parsers => [:stanford]
       }
-      Processors = {}
     end
   end
 end

data/lib/treat/languages/dutch.rb

@@ -0,0 +1,16 @@
+module Treat
+  module Languages
+    class Dutch
+      RequiredDependencies = []
+      OptionalDependencies = []
+      Processors = {
+        :chunkers => [:txt],
+        :segmenters => [:punkt],
+        :tokenizers => [:tactful]
+      }
+      Extractors = {}
+      Inflectors = {}
+      Lexicalizers = {}
+    end
+  end
+end

data/lib/treat/languages/english.rb

@@ -2,34 +2,62 @@ module Treat
   module Languages
     class English
       
-      require 'treat/languages/english/tags'
-      require 'treat/languages/english/categories'
+      RequiredDependencies = ['rbtagger', 'ruby-stemmer', 'tactful_tokenizer', 'nickel', 'wordnet']
+      OptionalDependencies = ['uea-stemmer', 'tokenizer', 'engtagger']
       
       Extractors = {
-        time: [:chronic],
-        topics: [:reuters],
-        topic_words: [:lda],
-        key_sentences: [:topics_frequency]
+        :time => [:nickel],
+        :date => [:chronic, :ruby],
+        :topics => [:reuters],
+        :topic_words => [:lda],
+        :keywords => [:tf_idf, :topics_tf_idf],
+        :named_entity_tag => [:stanford],
+        :coreferences => [:stanford],
+        :roles => [:naive]
       }
+      
       Processors = {
-        chunkers: [:txt],
-        parsers: [:stanford, :enju],
-        segmenters: [:tactful, :punkt, :stanford],
-        tokenizers: [:multilingual, :macintyre, :perl, :punkt, :tactful, :stanford]
+        :chunkers => [:txt],
+        :parsers => [:stanford, :enju],
+        :segmenters => [:tactful, :punkt, :stanford],
+        :tokenizers => [:macintyre, :multilingual, :perl, :punkt, :stanford, :tactful]
       }
+      
       Lexicalizers = {
-        category: [:from_tag],
-        linkages: [:naive],
-        synsets: [:wordnet, :rita_wn],
-        tag: [:brill, :lingua, :stanford]
+        :category => [:from_tag],
+        :linkages => [:naive],
+        :synsets => [:wordnet],
+        :tag => [:brill, :lingua, :stanford]
       }
+      
       Inflectors = {
-        conjugations: [:linguistics],
-        declensions: [:linguistics, :english],
-        stem: [:porter_c, :porter, :uea],
-        ordinal_words: [:linguistics],
-        cardinal_words: [:linguistics]
+        :conjugations => [:linguistics],
+        :declensions => [:english, :linguistics],
+        :stem => [:porter, :porter_c, :uea],
+        :ordinal_words => [:linguistics],
+        :cardinal_words => [:linguistics]
       }
+
+      CommonWords = [
+        'the', 'of', 'and', 'a', 'to', 'in', 'is', 
+        'you', 'that', 'it', 'he', 'was', 'for', 'on', 
+        'are', 'as', 'with', 'his', 'they', 'I', 'at', 
+        'be', 'this', 'have', 'from', 'or', 'one', 'had', 
+        'by', 'word', 'but', 'not', 'what', 'all', 'were', 
+        'we', 'when', 'your', 'can', 'said', 'there', 'use', 
+        'an', 'each', 'which', 'she', 'do', 'how', 'their', 
+        'if', 'will', 'up', 'other', 'about', 'out', 'many', 
+        'then', 'them', 'these', 'so', 'some', 'her', 'would', 
+        'make', 'like', 'him', 'into', 'time', 'has', 'look', 
+        'two', 'more', 'write', 'go', 'see', 'number', 'no', 
+        'way', 'could', 'people', 'my', 'than', 'first', 'been',
+        'call', 'who', 'its', 'now', 'find', 'long', 'down',
+        'day', 'did', 'get', 'come', 'made', 'may', 'part', 
+        'say', 'also', 'new', 'much', 'should', 'still',
+        'such', 'before', 'after', 'other', 'then', 'over',
+        'under', 'therefore', 'nonetheless', 'thereafter',
+        'afterwards', 'here', 'huh', 'hah', "'nt", "'t", 'here'
+      ]
       
     end
   end

data/lib/treat/languages/french.rb

@@ -1,16 +1,19 @@
 module Treat
   module Languages
     class French
+      RequiredDependencies = []
+      OptionalDependencies = []
       Extractors = {}
       Inflectors = {}
       Lexicalizers = {
-        tag: [:stanford]
+        :tag => [:stanford],
+        :category => [:from_tag]
       }
       Processors = {
-        chunkers: [:txt],
-        parsers: [:stanford],
-        segmenters: [:tactful, :punkt, :stanford],
-        tokenizers: [:multilingual, :macintyre, :perl, :punkt, :tactful, :stanford]
+        :chunkers => [:txt],
+        :parsers => [:stanford],
+        :segmenters => [:punkt],
+        :tokenizers => [:tactful]
       }
     end
   end

data/lib/treat/languages/german.rb

@@ -1,17 +1,20 @@
 module Treat
   module Languages
     class German
+      RequiredDependencies = []
+      OptionalDependencies = []
       Extractors = {}
       Inflectors = {}
       Lexicalizers = {
-        tag: [:stanford]
+        :tag => [:stanford],
+        :category => [:from_tag]
       }
       Processors = {
-        chunkers: [:txt],
-        parsers: [:stanford],
-        segmenters: [:tactful, :punkt, :stanford],
-        tokenizers: [:multilingual, :macintyre, :perl, :punkt, :tactful, :stanford]
+        :chunkers => [:txt],
+        :parsers => [:stanford],
+        :segmenters => [:punkt],
+        :tokenizers => [:tactful]
       }
     end
   end
-end
+end

data/lib/treat/languages/greek.rb

@@ -0,0 +1,16 @@
+module Treat
+  module Languages
+    class Greek
+      RequiredDependencies = []
+      OptionalDependencies = []
+      Processors = {
+        :chunkers => [:txt],
+        :segmenters => [:punkt],
+        :tokenizers => [:tactful]
+      }
+      Extractors = {}
+      Inflectors = {}
+      Lexicalizers = {}
+    end
+  end
+end