treat 0.2.5 → 1.0.0

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

@@ -1,46 +1,54 @@
-module Treat
-  module Formatters
-    module Visualizers
-      # This class allows the visualization of 
-      # an entity in standoff format; for example:
-      # (S (NP John) (VP has (VP come))).
-      class Standoff
-        # Default options for the visualizer.
-        DefaultOptions = { :indent => 0 }
-        # A lambda to recursively visualize the children
-        # of an entity.
-        Recurse = lambda do |entity, options|
-          v = ''
-          entity.each { |child| v += visualize(child, options) }
-          v
-        end
-        # Visualize the entity using standoff notation.
-        # This can only be called on sentences and smaller
-        # entities, as it is not a suitable format to 
-        # represent larger entities.
-        def self.visualize(entity, options = {})
-          options = DefaultOptions.merge(options)
-          value = '';  spaces = ''
-          options[:indent].times { spaces << '   '}
-          options[:indent] += 1
-          if entity.is_a?(Treat::Entities::Token)
-            value += "#{spaces}(#{entity.tag} #{entity.value})"
-          elsif entity.is_a?(Treat::Entities::Phrase)
-            tag = entity.has?(:tag) ? entity.tag : ''
-            value += ("#{spaces}(#{tag}\n" +
-            "#{Recurse.call(entity, options)})\n")
-          elsif entity.is_a?(Treat::Entities::Sentence)
-            value += ("#{spaces}(S\n" +
-            "#{Recurse.call(entity, options)})\n")
-          else
-            raise 'Standoff format is unsuitable to represent' +
-            ' entities larger than sentences.'
-          end
-          options[:indent] -= 1
-          value.gsub!(")\n)", "))")
-          value
-        end
-      end
+# This class allows the visualization of
+# an entity in standoff format; for example:
+# (S (NP John) (VP has (VP come))).
+class Treat::Formatters::Visualizers::Standoff
+
+  # Start out with an indent of 0.
+  DefaultOptions = { :indent => 0 }
+  
+  # A lambda to recursively visualize the children
+  # of an entity.
+  Recurse = lambda do |entity, options|
+    v = ''
+    entity.each { |child| v += visualize(child, options) }
+    v
+  end
+  
+  # Fix - brackets
+  # Visualize the entity using standoff notation.
+  # This can only be called on sentences and smaller
+  # entities, as it is not a suitable format to
+  # represent larger entities.
+  def self.visualize(entity, options = {})
+    options = DefaultOptions.merge(options)
+    value = '';  spaces = ''
+    options[:indent].times { spaces << '   '}
+    options[:indent] += 1
+    if entity.is_a?(Treat::Entities::Token)
+      val = ptb_escape(entity.value)
+      value += "#{spaces}(#{entity.tag} #{val})"
+    elsif entity.is_a?(Treat::Entities::Phrase)
+      tag = entity.has?(:tag) ? entity.tag : ''
+      value += ("#{spaces}(#{tag}\n" +
+      "#{Recurse.call(entity, options)})\n")
+    elsif entity.is_a?(Treat::Entities::Sentence)
+      value += ("#{spaces}(S\n" +
+      "#{Recurse.call(entity, options)})\n")
+    else
+      raise 'Standoff format is unsuitable to represent' +
+      ' entities larger than sentences.'
+    end
+    options[:indent] -= 1
+    value.gsub!(")\n)", "))")
+    value
+  end
+  
+  def self.ptb_escape(val)
+    Treat::Linguistics::Tags::
+    PTBEscapeCharacters.each do |char, esc|
+      val.gsub!(char, val)
     end
+    
+    val
   end
-end
+end

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

@@ -1,32 +1,29 @@
-module Treat
-  module Formatters
-    module Visualizers
-      # This class generates an ASCII representation
-      # of a tree of entities.
-      class Tree
-        # Default options for the visualizer.
-        DefaultOptions = { :indent => 0 }
-        # Obtain a plain text tree representation 
-        # of the entity.
-        def self.visualize(entity, options = {})
-          options = DefaultOptions.merge(options)
-          string = ''
-          if entity.has_children?
-            spacer = '--'
-            spaces = ''
-            options[:indent].times { spaces << '   '}
-            string << "+ #{entity.inspect}\n#{spaces}|"
-            options[:indent] += 1
-            entity.children.each do |child|
-              string = string + "\n" + spaces + '+' + 
-              spacer + self.visualize(child, options)
-            end
-            options[:indent] -= 1
-            return string
-          end
-          '> ' + entity.inspect
-        end
+# This class generates an ASCII representation
+# of a tree of entities.
+class Treat::Formatters::Visualizers::Tree
+
+  # Start out with an indent at 0.
+  DefaultOptions = { :indent => 0 }
+  
+  # Obtain a plain text tree representation
+  # of the entity.
+  def self.visualize(entity, options = {})
+    options = DefaultOptions.merge(options)
+    string = ''
+    if entity.has_children?
+      spacer = '--'
+      spaces = ''
+      options[:indent].times { spaces << '   '}
+      string << "+ #{entity.inspect}\n#{spaces}|"
+      options[:indent] += 1
+      entity.children.each do |child|
+        string = string + "\n" + spaces + '+' +
+        spacer + self.visualize(child, options)
       end
+      options[:indent] -= 1
+      return string
     end
+    '> ' + entity.inspect
   end
-end
+  
+end

data/lib/treat/groupable.rb

@@ -0,0 +1,153 @@
+module Treat::Groupable
+
+  # Lazily load the worker classes in the group.
+  def const_missing(const)
+    bits = self.ancestors[0].to_s.split('::')
+    bits.collect! { |bit| ucc(bit) }
+    file = bits.join('/') + "/#{ucc(const)}"
+    if not File.readable?(Treat.lib + "#{file}.rb")
+      raise Treat::Exception,
+      "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
+
+  # Cache the list of workers to improve performance.
+  @@list = {}
+  # Populates once the list of the workers in the group
+  # by crawling the filesystem.
+  def list
+    mod = ucc(cl(self))
+    if @@list[mod].nil?
+      @@list[mod] = []
+      dirs = Dir[Treat.lib + "treat/*/#{mod}/*.rb"]
+      dirs.each do |file|
+        @@list[mod] <<
+        file.split('/')[-1][0..-4].intern
+      end
+    end
+    @@list[mod]
+  end
+
+  # Boolean - does the group have the supplied class
+  # included in its targets?
+  def has_target?(target, strict = false)
+    is_target = false
+    self.targets.each do |entity_type|
+      t = cc(entity_type)
+      entity_type = Treat::Entities.const_get(t)
+      if target < entity_type ||
+        entity_type == target
+        is_target = true; break
+      end
+    end
+    is_target
+  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)
+    c = cc(class_name).intern
+    klass = self.const_set(c, Class.new)
+    method = self.method
+    @@list[ucc(cl(self))] << class_name
+    klass.send(:define_singleton_method,
+    method) do |entity, options={}|
+      block.call(entity, options)
+    end
+  end
+
+  # Get constants in this module, excluding by
+  # default those defined by parent modules.
+  def const_get(const)
+    super(const, false)
+  end
+
+  # Modify the extended class.
+  def self.extended(group)
+    
+    group.module_eval do
+      
+      class << self
+        
+        # The type of the group. There are three types:
+        #
+        # - Transformers transform the tree of an entity.
+        # - Annotators compute a value and store it in the entity.
+        # - Computers compute a value and do not store it.
+        attr_accessor :type
+        # The default worker in the group, for language-
+        # independent tasks.
+        attr_accessor :default
+        # The entity types which the group's workers work on.
+        attr_accessor :targets
+        # Presets to automatically generate functions.
+        attr_accessor :presets
+        # The preset option to use with preset functions.
+        attr_accessor :preset_option
+      end
+      
+      # Return the method corresponding to the group.
+      # This method resolves the name of the method
+      # that a group should provide based on the name
+      # of the group. Basically, if the group ends in
+      # -ers, the verb corresponding to the group is
+      # returned (tokenizers -> tokenize, inflectors ->
+      # inflect). Otherwise, the name of the method
+      # is the same as that of the group (encoding ->
+      # encoding, tag -> tag).
+      @method = nil
+      def self.method
+        return @method if @method
+        m = ucc(cl(self)).dup
+        if  m[-4..-1] == 'zers'
+          if type == :annotator
+            if m[-6] == 'l'
+              m[-5..-1] = ''
+            else
+              m[-5..-1] = 'y'
+            end
+          else
+            m = m[0..-3]
+          end
+          n = m         
+        elsif m[-4..-1] == 'iers'
+          m[-4..-1] = 'y'
+          n = m
+        elsif m[-3..-1] == 'ers'
+          if ['k', 't', 'm', 'd', 
+              'g', 'n', 'x', 'h'].
+              include? m[-4]
+            n = m[0..-4]
+            if n[-1] == n[-2]
+              n = n[0..-2] 
+            end
+          else
+            n = m[0..-3]
+          end
+        elsif m[-3..-1] == 'ors'
+          n = m[0..-4] + 'e'
+        else
+          n = m
+        end
+        @method = n.intern
+      end
+      
+      # Populate the group's list.
+      group.list
+      
+    end
+    
+  end
+  
+end

data/lib/treat/helpers/decimal_point_escaper.rb

@@ -0,0 +1,22 @@
+module Treat::Helpers
+  
+  class DecimalPointEscaper
+
+    EscapeChar = '^^'
+    EscapedEscapeChar = '\^\^'
+    
+    def self.escape!(s)
+      s.gsub!(/([0-9]+)\.([0-9]+)/) do
+        $1 + EscapeChar + $2
+      end
+    end
+
+    def self.unescape!(s)
+      s.gsub!(/([0-9]+)#{EscapedEscapeChar}([0-9]+)/) do
+        $1 + '.' + $2
+      end
+    end
+
+  end
+  
+end

data/lib/treat/inflectors.rb

@@ -1,47 +1,52 @@
-module Treat
-  # Algorithms to retrieve the inflections of a word. 
-  module Inflectors
-    # Return the stem (*not root form*) of a word.
-    module Stem
-      extend Group
-      self.type = :annotator
-      self.targets = [:word]
-    end
-    # Retrieve the different declensions of a noun (singular, plural).
-    module Declensions
-      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
-      extend Group
-      self.type = :annotator
-      self.targets = [:number]
-    end
-    # Retrieve the full text description of an ordinal number.
-    module OrdinalWords
-      extend Group
-      self.type = :annotator
-      self.targets = [:number]
-    end
-    extend Treat::Category
+# Category of worker groups that retrieve
+# the inflections of a word.
+module Treat::Inflectors
+
+  # Return the stem (*not root form*) of a word.
+  module Stemmers
+    extend Treat::Groupable
+    self.type = :annotator
+    self.targets = [:word]
+  end
+
+  # Retrieve the different declensions of a
+  # noun (singular, plural).
+  module Declensors
+    extend Treat::Groupable
+    self.type = :annotator
+    self.targets = [:word]
+    self.preset_option = :count
+    self.presets = [:plural, :singular]
+  end
+
+  # Retrieve the different conjugations of a word
+  # given a mode, tense, person, and/or number.
+  module Conjugators
+    extend Treat::Groupable
+    self.type = :annotator
+    self.targets = [:word]
+    self.preset_option = :form
+    self.presets = [:infinitive, :present_participle, 
+                    :plural_verb, :singular_verb]
   end
-end
 
+  # Retrieve the full text description of a
+  # cardinal number.
+  module Cardinalizers
+    extend Treat::Groupable
+    self.type = :annotator
+    self.targets = [:number]
+  end
+
+  # Retrieve the full text description of an
+  # ordinal number.
+  module Ordinalizers
+    extend Treat::Groupable
+    self.type = :annotator
+    self.targets = [:number]
+  end
+
+  # Make Inflectors categorizable.
+  extend Treat::Categorizable
+
+end

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

@@ -0,0 +1,40 @@
+# This class is a wrapper for the functions included
+# in the 'linguistics' gem that allow to describe a
+# number in words in cardinal form.
+#
+# Project website: http://deveiate.org/projects/Linguistics/
+module Treat::Inflectors::Cardinalizers::Linguistics
+  
+  require 'treat/loaders/linguistics'
+  
+  # Return the description of a cardinal number in words.
+  #
+  # Options:
+  #
+  # - :group => Controls how many numbers at a time are
+  # grouped together. Valid values are 0 (normal grouping),
+  # 1 (single-digit grouping, e.g., “one, two, three, four”),
+  # 2 (double-digit grouping, e.g., “twelve, thirty-four”, or
+  # 3 (triple-digit grouping, e.g., “one twenty-three, four”).
+  # - :comma => Set the character/s used to separate word groups.
+  # Defaults to ", ".
+  # - :and => Set the word and/or characters used where ' and '
+  # (the default) is normally used. Setting :and to ' ', for
+  # example, will cause 2556 to be returned as “two-thousand,
+  # five hundred fifty-six” instead of “two-thousand, five
+  # hundred and fifty-six”.
+  # - :zero => Set the word used to represent the numeral 0 in
+  # the result. 'zero' is the default.
+  # - :decimal => Set the translation of any decimal points in
+  # the number; the default is 'point'.
+  # - :asArray If set to a true value, the number will be returned
+  # as an array of word groups instead of a String.
+  #
+  # More specific options when using :type => :ordinal:
+  def self.cardinal(entity, options = {})
+    Treat::Loaders::Linguistics.
+    load(entity.language).
+    numwords(entity.to_s, options)
+  end
+  
+end