treat 0.1.4 → 0.2.0

data/lib/treat/formatters/visualizers/short_value.rb

@@ -3,7 +3,7 @@ module Treat
     module Visualizers
       class ShortValue
         # Default options for the visualizer.
-        DefaultOptions = { max_words: 6, max_length: 30 }
+        DefaultOptions = { :max_words => 6, :max_length => 30 }
         # Returns the text value of an entity, shortend
         # with [..] if the value is longer than :max_words
         # or longer than :max_length.
@@ -18,7 +18,7 @@ module Treat
           words = entity.to_s.split(' ')
           if words.size < options[:max_words] || 
             entity.to_s.length < options[:max_length]
-            entity.to_s 
+            entity.to_s
           else
             words[0..2].join(' ') + ' [...] ' + words[-3..-1].join(' ')
           end

data/lib/treat/formatters/visualizers/standoff.rb

@@ -6,7 +6,7 @@ module Treat
       # (S (NP John) (VP has (VP come))).
       class Standoff
         # Default options for the visualizer.
-        DefaultOptions = { indent: 0 }
+        DefaultOptions = { :indent => 0 }
         # A lambda to recursively visualize the children
         # of an entity.
         Recurse = lambda do |entity, options|
@@ -25,7 +25,7 @@ module Treat
           options[:indent] += 1
           if entity.is_a?(Treat::Entities::Token)
             value += "#{spaces}(#{entity.tag} #{entity.value})"
-          elsif entity.is_a?(Treat::Entities::Constituent)
+          elsif entity.is_a?(Treat::Entities::Phrase)
             tag = entity.has?(:tag) ? entity.tag : ''
             value += ("#{spaces}(#{tag}\n" +
             "#{Recurse.call(entity, options)})\n")

data/lib/treat/formatters/visualizers/tree.rb

@@ -5,7 +5,7 @@ module Treat
       # of a tree of entities.
       class Tree
         # Default options for the visualizer.
-        DefaultOptions = { indent: 0 }
+        DefaultOptions = { :indent => 0 }
         # Obtain a plain text tree representation 
         # of the entity.
         def self.visualize(entity, options = {})

data/lib/treat/formatters/visualizers/txt.rb

@@ -4,30 +4,39 @@ module Treat
       # Creates a plain text visualization of an entity.
       class Txt
         # The default options for the visualizer.
-        DefaultOptions = { sep: ' ' }
+        DefaultOptions = { :sep => ' ' }
         # Obtain a plain text visualization of the entity,
         # with no additional information.
         # 
         # Options:
         # (String) :sep => the separator to use between words.
         def self.visualize(entity, options = {})
+          options[:first] = true unless options[:first] == false
+          first = options[:first]
           options = DefaultOptions.merge(options)
-          return entity.value if !entity.has_children?
+          return entity.value.dup if !entity.has_children?
           value = ''
+          options[:first] = false
           entity.each do |child|
+            value += "\n\n" if child.is_a?(Treat::Entities::Section)
             if child.is_a?(Treat::Entities::Token) || child.value != ''
               # Remove the trailing space for tokens that
               # 'stick' to the previous one, such
               # as punctuation symbols and clitics.
               if child.is_a?(Treat::Entities::Punctuation) ||
-                child.is_a?(Treat::Entities::Clitic)
-                value.strip!
+                 child.is_a?(Treat::Entities::Clitic)
+                  value.strip!
               end
               value += child.value + options[:sep]
             else
               value += visualize(child, options)
             end
+            if child.is_a?(Treat::Entities::Title) ||
+               child.is_a?(Treat::Entities::Paragraph)
+              value += "\n\n"
+            end
           end
+          value = value.strip if first
           value
         end
       end

data/lib/treat/group.rb

@@ -5,7 +5,11 @@ module Treat
       group.module_eval do
         class << self
           attr_accessor :type, :default, :targets
+          attr_accessor :presets, :preprocessors, :postprocessors
         end
+        self.presets = {}
+        self.preprocessors = {}
+        self.postprocessors = {}
         # Return the method corresponding to the group.
         # This method resolves the name of the method
         # that a group should provide based on the name
@@ -31,21 +35,20 @@ module Treat
           else
             n = m
           end
-          @method = :"#{n}"
+          @method = n.intern
         end
       end
+      group.list
     end
     # Create a new algorithm within the group. Once
     # the algorithm is added, it will be automatically
     # installed on all the targets of the group.
     def add(class_name, &block)
-      class_name = :"#{cc(class_name)}"
-      klass = self.const_set(class_name, Class.new)
+      klass = self.const_set(cc(class_name).intern, Class.new)
       method = self.method
-      klass.class_eval do
-        @@block = block
-        eval "def #{method}(entity);" +
-        "@@block.call(entity); end"
+      @@list[ucc(cl(self))] << class_name
+      klass.send(:define_singleton_method, method) do |entity, options={}|
+        block.call(entity, options)
       end
     end
     # Boolean - does the group have the supplied class
@@ -55,7 +58,6 @@ module Treat
       self.targets.each do |entity_type|
         entity_type = Entities.const_get(cc(entity_type))
         if target < entity_type || entity_type == target
-
           is_target = true; break
         end
       end
@@ -72,7 +74,7 @@ module Treat
         dirs = Dir.glob("#{Treat.lib}/treat/*/#{mod}/*.rb")
         dirs.each do |file|
           @@list[mod] <<
-          :"#{file.split('/')[-1][0..-4]}"
+          file.split('/')[-1][0..-4].intern
         end
       end
       @@list[mod]
@@ -87,10 +89,14 @@ module Treat
       file = bits.join('/') + "/#{ucc(const)}"
       if not File.readable?("#{Treat.lib}/#{file}.rb")
         raise Treat::Exception,
-        "File '#{file}.rb' corresponding to requested delegate "+
+        "File '#{file}.rb' corresponding to requested worker "+
         "#{self}::#{const} does not exist."
       else
         require file
+        if not const_defined?(const)
+          raise Treat::Exception,
+          "File #{file} does not define #{self}::#{const}."
+        end
         const_get(const)
       end
     end

data/lib/treat/helpers/linguistics_loader.rb

@@ -0,0 +1,18 @@
+module Treat
+  module Helpers
+    class LinguisticsLoader
+      silence_warnings { require 'linguistics' }
+      def self.load(language)
+        begin
+          l = language.to_s.upcase
+          klass = nil
+          silence_warnings { klass = ::Linguistics.const_get(l) }
+          klass
+        rescue RuntimeError
+          raise "Ruby Linguistics does not have a module " +
+          " installed for the #{language} language."
+        end
+      end
+    end
+  end
+end

data/lib/treat/inflectors.rb

@@ -12,12 +12,22 @@ module Treat
       extend Group
       self.type = :annotator
       self.targets = [:word]
+      self.presets = {
+        :plural => {:count => :plural},
+        :singular => {:count => :singular}
+      }
     end
     # Retrieve the different conjugations of a word.
     module Conjugations
       extend Group
       self.type = :annotator
       self.targets = [:word]
+      self.presets = {
+        :infinitive => {:mode => :infinitive},
+        :present_participle => {:tense => :present, :mode => :participle},
+        :plural_verb => {:count => :plural},
+        :singular_verb => {:count => :singular}
+      }
     end
     # Retrieve the full text description of a cardinal number.
     module CardinalWords

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

@@ -7,8 +7,7 @@ module Treat
       #
       # Project website: http://deveiate.org/projects/Linguistics/
       class Linguistics
-        # Require the 'linguistics' gem.
-        silence_warnings { require 'linguistics' }
+        require 'treat/helpers/linguistics_loader'
         # Return the description of a cardinal number in words.
         # 
         # Options:
@@ -34,7 +33,8 @@ module Treat
         # 
         # More specific options when using :type => :ordinal:
         def self.cardinal_words(entity, options = {})
-          silence_warnings { ::Linguistics::EN.numwords(entity.to_s, options) }
+          klass = Treat::Helpers::LinguisticsLoader.load(entity.language)
+          klass.numwords(entity.to_s, options)
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Treat
       #
       # Project website: http://deveiate.org/projects/Linguistics/
       class Linguistics
-        silence_warnings { require 'linguistics' }
+        require 'treat/helpers/linguistics_loader'
         # Conjugate a verb using ruby linguistics with the specified
         # mode, tense, count and person.
         #
@@ -17,20 +17,13 @@ module Treat
         # - (Symbol) :count => :singular, :plural
         # - (Symbol) :person => :first, :second, :third
         def self.conjugations(entity, parameters)
-          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."
-          end
+          klass = Treat::Helpers::LinguisticsLoader.load(entity.language)
           if parameters[:mode] == :infinitive
-            silence_warnings { delegate.infinitive(entity.to_s) }
+            silence_warnings { klass.infinitive(entity.to_s) }
           elsif parameters[:mode] == :participle && parameters[:tense] == :present
-            silence_warnings { delegate.present_participle(entity.to_s) }
+            silence_warnings { klass.present_participle(entity.to_s) }
           elsif parameters[:count] == :plural && parameters.size == 1
-            silence_warnings { delegate.plural_verb(entity.to_s) }
+            silence_warnings { klass.plural_verb(entity.to_s) }
           else
             raise Treat::Exception,
             'This combination of modes, tenses, persons ' +

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

@@ -0,0 +1,319 @@
+module Treat
+  module Inflectors
+    module Declensions
+      # This class is a wrapper for the Inflect module,
+      # copied from the unmaintained 'english' ruby gem,
+      # created by Thomas Sawyer.
+      # 
+      # Released under the MIT License.
+      #
+      #  http://english.rubyforge.org
+      class English
+        # Retrieve the declensions (singular, plural)
+        # of an english word using a class lifted from
+        # the 'english' ruby gem.
+        def self.declensions(entity, options)
+          unless options[:count]
+            raise Treat::Exception, 
+            "Must supply option count (:singular or :plural)."
+          end
+          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."
+          elsif options[:count] == :plural
+            Inflect.plural(string)
+          elsif options[:count] == :singular
+            Inflect.singular(string)
+          else
+            {:singular => Inflect.singular(string),
+             :plural => Inflect.plural(string)}
+          end
+        end
+
+        module Inflect
+
+          @singular_of = {}
+          @plural_of = {}
+
+          @singular_rules = []
+          @plural_rules = []
+
+          # This class provides the DSL for creating inflections, you can add additional rules.
+          # Examples:
+          #
+          #   word "ox", "oxen"
+          #   word "octopus", "octopi"
+          #   word "man", "men"
+          #
+          #   rule "lf", "lves"
+          #
+          #   word "equipment"
+          #
+          # Rules are evaluated by size, so rules you add to override specific cases should be longer than the rule
+          # it overrides. For instance, if you want "pta" to pluralize to "ptas", even though a general purpose rule
+          # for "ta" => "tum" already exists, simply add a new rule for "pta" => "ptas", and it will automatically win
+          # since it is longer than the old rule.
+          #
+          # Also, single-word exceptions win over general words ("ox" pluralizes to "oxen", because it's a single word
+          # exception, even though "fox" pluralizes to "foxes")
+          class << self
+            # Define a general two-way exception.
+            #
+            # This also defines a general rule, so foo_child will correctly become
+            # foo_children.
+            #
+            # Whole words also work if they are capitalized (Goose => Geese).
+            def word(singular, plural=nil)
+              plural = singular unless plural
+              singular_word(singular, plural)
+              plural_word(singular, plural)
+              rule(singular, plural)
+            end
+
+            # Define a singularization exception.
+            def singular_word(singular, plural)
+              @singular_of[plural] = singular
+              @singular_of[plural.capitalize] = singular.capitalize
+            end
+
+            # Define a pluralization exception.
+            def plural_word(singular, plural)
+              @plural_of[singular] = plural
+              @plural_of[singular.capitalize] = plural.capitalize
+            end
+
+            # Define a general rule.
+            def rule(singular, plural)
+              singular_rule(singular, plural)
+              plural_rule(singular, plural)
+            end
+
+            # Define a singularization rule.
+            def singular_rule(singular, plural)
+              @singular_rules << [singular, plural]
+            end
+
+            # Define a plurualization rule.
+            def plural_rule(singular, plural)
+              @plural_rules << [singular, plural]
+            end
+
+            # Read prepared singularization rules.
+            def singularization_rules
+              if defined?(@singularization_regex) && @singularization_regex
+                return [@singularization_regex, @singularization_hash]
+              end
+              # No sorting needed: Regexen match on longest string
+              @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i")
+              @singularization_hash  = Hash[*@singular_rules.flatten].invert
+              [@singularization_regex, @singularization_hash]
+            end
+
+            # Read prepared singularization rules.
+            #def singularization_rules
+            #  return @singularization_rules if @singularization_rules
+            #  sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
+            #  @singularization_rules = sorted.collect do |s, p|
+            #    [ /#{p}$/, "#{s}" ]
+            #  end
+            #end
+
+            # Read prepared pluralization rules.
+            def pluralization_rules
+              if defined?(@pluralization_regex) && @pluralization_regex
+                return [@pluralization_regex, @pluralization_hash]
+              end
+              @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i")
+              @pluralization_hash = Hash[*@plural_rules.flatten]
+              [@pluralization_regex, @pluralization_hash]
+            end
+
+            # Read prepared pluralization rules.
+            #def pluralization_rules
+            #  return @pluralization_rules if @pluralization_rules
+            #  sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
+            #  @pluralization_rules = sorted.collect do |s, p|
+            #    [ /#{s}$/, "#{p}" ]
+            #  end
+            #end
+
+            #
+            def singular_of ; @singular_of ; end
+
+            #
+            def plural_of   ; @plural_of   ; end
+
+            # Convert an English word from plurel to singular.
+            #
+            #   "boys".singular      #=> boy
+            #   "tomatoes".singular  #=> tomato
+            #
+            def singular(word)
+              return "" if word == ""
+              if result = singular_of[word]
+                return result.dup
+              end
+              result = word.dup
+
+              regex, hash = singularization_rules
+              result.sub!(regex) {|m| hash[m]}
+              singular_of[word] = result
+              return result
+              #singularization_rules.each do |(match, replacement)|
+              #  break if result.gsub!(match, replacement)
+              #end
+              #return result
+            end
+
+            # Alias for #singular (a Railism).
+            #
+            alias_method(:singularize, :singular)
+
+            # Convert an English word from singular to plurel.
+            #
+            #   "boy".plural     #=> boys
+            #   "tomato".plural  #=> tomatoes
+            #
+            def plural(word)
+              return "" if word == ""
+              if result = plural_of[word]
+                return result.dup
+              end
+              #return self.dup if /s$/ =~ self # ???
+              result = word.dup
+
+              regex, hash = pluralization_rules
+              result.sub!(regex) {|m| hash[m]}
+              plural_of[word] = result
+              return result
+              #pluralization_rules.each do |(match, replacement)|
+              #  break if result.gsub!(match, replacement)
+              #end
+              #return result
+            end
+
+            # Alias for #plural (a Railism).
+            alias_method(:pluralize, :plural)
+
+            # Clear all rules.
+            def clear(type = :all)
+              if type == :singular || type == :all
+                @singular_of = {}
+                @singular_rules = []
+                @singularization_rules, @singularization_regex = nil, nil
+              end
+              if type == :plural || type == :all
+                @singular_of = {}
+                @singular_rules = []
+                @singularization_rules, @singularization_regex = nil, nil
+              end
+            end
+          end
+
+          # One argument means singular and plural are the same.
+
+          word 'equipment'
+          word 'information'
+          word 'money'
+          word 'species'
+          word 'series'
+          word 'fish'
+          word 'sheep'
+          word 'moose'
+          word 'hovercraft'
+          word 'news'
+          word 'rice'
+          word 'plurals'
+
+          # Two arguments defines a singular and plural exception.
+
+          word 'Swiss'     , 'Swiss'
+          word 'alias'     , 'aliases'
+          word 'analysis'  , 'analyses'
+          #word 'axis'      , 'axes'
+          word 'basis'     , 'bases'
+          word 'buffalo'   , 'buffaloes'
+          word 'child'     , 'children'
+          #word 'cow'       , 'kine'
+          word 'crisis'    , 'crises'
+          word 'criterion' , 'criteria'
+          word 'datum'     , 'data'
+          word 'goose'     , 'geese'
+          word 'hive'      , 'hives'
+          word 'index'     , 'indices'
+          word 'life'      , 'lives'
+          word 'louse'     , 'lice'
+          word 'man'       , 'men'
+          word 'matrix'    , 'matrices'
+          word 'medium'    , 'media'
+          word 'mouse'     , 'mice'
+          word 'movie'     , 'movies'
+          word 'octopus'   , 'octopi'
+          word 'ox'        , 'oxen'
+          word 'person'    , 'people'
+          word 'potato'    , 'potatoes'
+          word 'quiz'      , 'quizzes'
+          word 'shoe'      , 'shoes'
+          word 'status'    , 'statuses'
+          word 'testis'    , 'testes'
+          word 'thesis'    , 'theses'
+          word 'thief'     , 'thieves'
+          word 'tomato'    , 'tomatoes'
+          word 'torpedo'   , 'torpedoes'
+          word 'vertex'    , 'vertices'
+          word 'virus'     , 'viri'
+          word 'wife'      , 'wives'
+
+          # One-way singularization exception (convert plural to singular).
+
+          singular_word 'cactus', 'cacti'
+
+          # One-way pluralizaton exception (convert singular to plural).
+
+          plural_word 'axis', 'axes'
+
+          # General rules.
+
+          rule 'rf'     , 'rves'
+          rule 'ero'    , 'eroes'
+          rule 'ch'     , 'ches'
+          rule 'sh'     , 'shes'
+          rule 'ss'     , 'sses'
+          #rule 'ess'  , 'esses'
+          rule 'ta'     , 'tum'
+          rule 'ia'     , 'ium'
+          rule 'ra'     , 'rum'
+          rule 'ay'     , 'ays'
+          rule 'ey'     , 'eys'
+          rule 'oy'     , 'oys'
+          rule 'uy'     , 'uys'
+          rule 'y'      , 'ies'
+          rule 'x'      , 'xes'
+          rule 'lf'     , 'lves'
+          rule 'ffe'    , 'ffes'
+          rule 'af'     , 'aves'
+          rule 'us'     , 'uses'
+          rule 'ouse'   , 'ouses'
+          rule 'osis'   , 'oses'
+          rule 'ox'     , 'oxes'
+          rule ''       , 's'
+
+          # One-way singular rules.
+
+          singular_rule 'of' , 'ofs' # proof
+          singular_rule 'o'  , 'oes' # hero, heroes
+          #singular_rule 'f'  , 'ves'
+
+          # One-way plural rules.
+
+          plural_rule 's'   , 'ses'
+          plural_rule 'ive' , 'ives' # don't want to snag wife
+          plural_rule 'fe'  , 'ves'  # don't want to snag perspectives
+          
+        end
+      end
+    end
+  end
+end