treat 0.1.4 → 0.2.0

data/lib/treat/buildable.rb

@@ -4,6 +4,15 @@ module Treat
   # a string or a numeric object. This class
   # is pretty much self-explanatory.
   module Buildable
+    # Initialize the document with its filename.
+    # Optionally specify a reader to read the file.
+    # If +read+ is set to false, the document will
+    # not be read automatically; in that case, the
+    # method #read must be called on the document
+    # object to load it in.
+    def build(file_or_value = '', id = nil)
+      from_anything(file_or_value, id)
+    end
     def from_anything(file_or_value, id)
       if File.readable?(file_or_value.to_s)
         from_file(file_or_value)
@@ -17,27 +26,52 @@ module Treat
         "Use filename, folder, text or a number."
       end
     end
-    def from_string(string)
+    def from_string(string, enforce_type = false)
+      enforce_type = true if caller_method == :build
       if self == Treat::Entities::Document ||
         self == Treat::Entities::Collection
         raise Treat::Exception,
         "Cannot create a document or collection from " +
         "a string (need a readable file/folder)."
       end
-      dot = string.count('.') + string.count('!') + string.count('?')
-      return Treat::Entities::Section.new(string) if dot > 1 ||
-      (string.count("\n") > 0 && dot == 1)
-      return Treat::Entities::Sentence.new(string) if dot == 1 && string.size > 5
-      if string.count(' ') == 0
-        return Treat::Entities::Clitic.new(string) if string == "'s"
-        return Treat::Entities::Word.new(string) if string =~ /^[[:alpha:]\-']+$/
-        return Treat::Entities::Number.new(string) if string =~ /^[[:digit:]]+$/
-        return Treat::Entities::Punctuation.new(string) if string =~ /^[[:punct:]]+$/
-        return Treat::Entities::Symbol.new(string)
+      unless self == Treat::Entities::Entity
+        return self.new(string) if enforce_type 
+      end
+      dot = string.count('.!?')
+      if self == Treat::Entities::Phrase
+        if dot >= 1
+          c = Treat::Entities::Sentence.new(string)
+        else
+          c = Treat::Entities::Phrase.new(string)
+        end
+      elsif (self == Treat::Entities::Token) || 
+        string.count(' ') == 0
+        if string == "'s"
+          c = Treat::Entities::Clitic.new(string) 
+        elsif string =~ /^[[:alpha:]\-']+$/ && 
+              string.count(' ') == 0
+          c = Treat::Entities::Word.new(string) 
+        elsif string =~ /^[[:digit:]]+$/
+          c = Treat::Entities::Number.new(string) 
+        elsif string =~ /^[[:punct:]]+$/
+          c = Treat::Entities::Punctuation.new(string)
+        else
+          c = Treat::Entities::Symbol.new(string)
+        end
+      elsif dot > 1 || string.count("\n") > 0
+        c = Treat::Entities::Section.new(string) 
+      elsif dot >= 1 && dot < 5 && string.size > 5
+        c = Treat::Entities::Sentence.new(string) 
+      elsif string.strip.count(' ') > 0
+        c = Treat::Entities::Phrase.new(string)
       else
-        return Treat::Entities::Phrase.new(string)
+        c = Treat::Entities::Unknown.new(string) unless c
       end
-      return Treat::Entities::Unknown.new(string)
+      unless self == c.class || self == Treat::Entities::Entity || c.is_a?(self)
+        raise "You said that \"#{string}\" was a #{cl(self).downcase}, " +
+             "but Treat thinks it is a #{cl(c.class).downcase}."
+      end
+      c
     end
     def from_numeric(numeric)
       unless self == Treat::Entities::Number
@@ -80,9 +114,19 @@ module Treat
         ext = file.split('.')[-1]
         # Humanize the yaml extension.
         ext = 'yaml' if ext == 'yml'
-        if Treat::Formatters::Unserializers.list.
-          include?(ext.downcase.intern)
+        if ext == 'yaml'
           from_serialized_file(file)
+        elsif ext == 'xml'
+          beginning = nil
+          File.open(file) do |w| 
+            beginning = w.readlines(200) 
+          end
+          beginning = beginning.join(' ')
+          if beginning.index('<treat>')
+            from_serialized_file(file)
+          else
+            from_raw_file(file)
+          end
         else
           from_raw_file(file)
         end

data/lib/treat/categories.rb

@@ -2,25 +2,37 @@ module Treat
   # This module keeps track of all categories that
   # exist and the methods they implement.
   module Categories
-    class << self; attr_accessor :list; end
+    class << self
+      # A list of all categories.
+      attr_accessor :list
+    end
     # Array - list of all categories.
     self.list = []
-    # Boolean - does any of the categories have 
-    # a method that corresponds to sym?
-    def self.have_method?(sym); methods.include?(sym); end
-    # Cache the list of methods once it has been computed.
-    @@methods = []
-    # Array - provide a list of all methods implemented
-    # by all Treat categories.
-    def self.methods
-      return @@methods unless @@methods.empty?
-      self.list.each do |ns|
-        ns.methods.each { |method| @@methods << method }
+    @@lookup = nil
+    # Find the class of a group given its method.
+    def self.lookup(method)
+      return @@lookup[method] if @@lookup
+      @@lookup = {}
+      
+      self.list.each do |category|
+        category.groups.each do |group|
+          group = category.const_get(group)
+          @@lookup[group.method] = group
+          methods = group.presets.merge(
+            group.preprocessors.merge(
+              group.postprocessors
+            )
+          )
+          methods.each do |x,y|
+            @@lookup[x] = group
+          end
+        end
       end
-      @@methods
+      
+      @@lookup[method]
     end
+    # Require all categories.
     require 'treat/category'
-    require 'treat/detectors'
     require 'treat/formatters'
     require 'treat/processors'
     require 'treat/lexicalizers'

data/lib/treat/category.rb

@@ -4,7 +4,7 @@ module Treat
   module Category
     # Require the Group class.
     require 'treat/group'
-    # Add delegators to the Entities based on the
+    # Add workers to the Entities based on the
     # configuration for a given category.
     def self.extended(category)
       Treat::Categories.list << category
@@ -13,7 +13,7 @@ module Treat
           group = const_get(group)
           group.targets.each do |entity_type|
             entity = Treat::Entities.const_get(cc(entity_type))
-            entity.class_eval { add_delegators group }
+            entity.class_eval { add_workers group }
           end
         end
       end

data/lib/treat/delegatable.rb

@@ -1,76 +1,93 @@
 module Treat
   # Makes a class delegatable, allowing calls on it to be forwarded
-  # to a delegate class performing the appropriate call.
+  # to a worker class performing the appropriate call.
   module Delegatable
-    # Add decorator methods to entities.
-    def add_decorators(group, m)
-      decorators = group.methods -
-      Object.methods -
-      [:type, :type=, :targets, :targets=,
-        :default, :default=, :add,
-      :has_target?, :list]
-      decorators.each do |decorator_m|
-        define_method(decorator_m) do |delegate=nil, options={}|
-          options[:decorator] = decorator_m
-          send(m, delegate, options)
+    # Add postprocessor methods to entities.
+    def add_presets(group)
+      group.presets.each do |preset_m, presets|
+        define_method(preset_m) do |worker=nil, options={}|
+          options = presets.merge(options)
+          m = group.method
+          send(m, worker, options)
+          features[preset_m] = unset(m)
         end
       end
     end
-    # Add delegator group to all entities of a class.
-    def add_delegators(group)
+    def add_preprocessors(group)
+      group.preprocessors.each do |preprocessor_m, block|
+        define_method(preprocessor_m) do |worker=nil, options={}|
+          block.call(self, worker, options)
+          features[preprocessor_m] = unset(group.method)
+        end
+      end
+    end
+    # Add postprocessor methods to entities.
+    def add_postprocessors(group, m)
+      group.postprocessors.each do |postprocessor_m, block|
+        define_method(postprocessor_m) do |worker=nil, options={}|
+          options[:postprocessor] = postprocessor_m
+          send(m, worker, options)
+        end
+      end
+    end
+    # Add worker group to all entities of a class.
+    def add_workers(group)
       # Define each method in group.
       self.class_eval do
         m = group.method
-        add_decorators(group, m)
-        define_method(m) do |delegate=nil, options={}|
-          decorator = options.delete(:decorator)
-          puts self.id if !@features
+        add_presets(group)
+        add_preprocessors(group)
+        add_postprocessors(group, m)
+        define_method(m) do |worker=nil, options={}|
+          postprocessor = 
+            options.delete(:postprocessor)
           if !@features[m].nil?
             @features[m]
           else
-            self.class.call_delegator(
-            self, m, delegate, decorator, 
-            group, options)
+            self.class.call_worker(
+              self, m, worker, 
+              postprocessor, 
+              group, options
+            )
           end
         end
       end
     end
-    # Call a delegator.
-    def call_delegator(entity, m, delegate, decorator, group, options)
-      if delegate.nil?
-        delegate = get_missing_delegate(entity, group)
+    # Call a worker.
+    def call_worker(entity, m, worker, postprocessor, group, options)
+      if worker.nil? || worker == :default
+        worker = find_worker(entity, group)
       end
-      if not group.list.include?(delegate)
-        raise Treat::Exception, delegate_not_found(delegate, group)
+      if not group.list.include?(worker)
+        raise Treat::Exception, worker_not_found(worker, group)
       else
-        delegate_klass = group.const_get(:"#{cc(delegate.to_s)}")
-        result = entity.accept(group, delegate_klass, m, options)
-        if decorator
-          result = group.send(decorator, entity, result)
+        worker_klass = group.const_get(cc(worker.to_s).intern)
+        result = entity.accept(group, worker_klass, m, options)
+        if postprocessor
+          result = group.postprocessors[postprocessor].call(entity, result)
         end
         if group.type == :annotator
-          f = decorator.nil? ? m : decorator
-          entity.features[f] = result
+          f = postprocessor.nil? ? m : postprocessor
+          entity.features[f] = result unless result == nil
         end
         result
       end
     end
-    # Get the default delegate for that language
+    # Get the default worker for that language
     # inside the given group.
-    def get_language_delegate(language, group)
+    def find_worker_for_language(language, group)
       lang = Treat::Languages.describe(language)
       lclass = cc(lang).intern
       if Treat::Languages.constants.include?(lclass)
         cat = group.to_s.split('::')[-2].intern
-        lclass = Treat::Languages.const_get(lclass).const_get(cat)
+        lclass = Treat::Languages.get(lclass).const_get(cat)
         g = ucc(cl(group)).intern
         if !lclass[g] || !lclass[g][0]
           d = ucc(cl(group))
           d.gsub!('_', ' ')
-          d = d[0..-2] if d[-1] == 's'
-          d = 'delegator to find ' + d
+          d = 'worker to find "' + d
           raise Treat::Exception, "No #{d}" +
-          " is available for the #{lang} language."
+          "\" is available for the #{lang} language."
         end
         return lclass[g][0]
       else
@@ -78,20 +95,20 @@ module Treat
         "Language '#{lang}' is not supported (yet)."
       end
     end
-    # Get which delegate to use if none has been supplied.
-    def get_missing_delegate(entity, group)
-      delegate = group.default.nil? ?
-      self.get_language_delegate(entity.language, group) :
+    # Get which worker to use if none has been supplied.
+    def find_worker(entity, group)
+      worker = group.default.nil? ?
+      self.find_worker_for_language(entity.language, group) :
       group.default
-      if delegate == :none
+      if worker == :none
         raise NAT::Exception,
-        "There is intentionally no default delegate for #{group}."
+        "There is intentionally no default worker for #{group}."
       end
-      delegate
+      worker
     end
     # Return an error message and suggest possible typos.
-    def delegate_not_found(klass, group)
-      "Algorithm '#{ucc(klass)}' couldn't be found in group #{group}." +
+    def worker_not_found(klass, group)
+      "Algorithm '#{ucc(cl(klass))}' couldn't be found in group #{group}." +
       did_you_mean?(group.list.map { |c| ucc(c) }, ucc(klass))
     end
   end

data/lib/treat/doable.rb

@@ -0,0 +1,44 @@
+module Treat
+  module Doable
+    def do(*tasks)
+      tasks.each do |task|
+        if task.is_a?(Hash)
+          task.each do |k,v|
+            t, w = k, v
+            w, o = *w if w.is_a?(Array)
+            o ||= {}
+            do_task(t, w, o)
+          end
+        else
+          t = task.is_a?(Array) ? task[0] : task
+          w = task.is_a?(Array) ? task[1] : nil
+          w, o = *w if w.is_a?(Array)
+          o ||= {}
+          do_task(t, w, o)
+        end
+      end
+    end
+    def do_task(task, worker, options)
+      group = Categories.lookup(task)
+      unless group
+        raise Treat::Exception, "Task #{task} does not exist."
+      end
+      entity_types = group.targets
+      f = nil
+      entity_types.each do |t| 
+        f = true if Treat::Entities.match_types[type][t]
+      end
+      if f || entity_types.include?(:entity)
+        send(task, worker, options)
+      else
+        each_entity(*entity_types) do |entity|
+          entity.do_task(task, worker, options)
+        end
+        unless entity_types.include?(type)
+          features.delete(task)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/treat/entities.rb

@@ -6,17 +6,31 @@ module Treat
   # - Document
   # - Zone (a Section, Title, Paragraph, or List)
   # - Sentence
-  # - Constituent (a Phrase or Clause)
+  # - Phrases
   # - Token (a Word, Number, Punctuation, or Symbol).
   module Entities
+    # Cache a list of defined entity types to
+    # improve performance.
+    @@list = nil
+    # Provide a list of defined entity types,
+    # as non-camel case identifiers.
+    def self.list
+      return @@list if @@list
+      @@list = []
+      self.constants.each do |constant|
+        unless constant == :Entity
+          @@list << ucc(constant).intern 
+        end
+      end
+      @@list
+    end
     # Require Entity first.
     require 'treat/entities/entity'
     # Then require all possible entities.
     require 'treat/entities/collection'
     require 'treat/entities/document'
     require 'treat/entities/zones'
-    require 'treat/entities/sentence'
-    require 'treat/entities/constituents'
+    require 'treat/entities/phrases'
     require 'treat/entities/tokens'
     # Make the constants buildable.
     constants.each do |entity|
@@ -24,17 +38,23 @@ module Treat
         const_get(entity).build(value, id)
       end
     end
-    # Cache a list of defined entity types to
-    # improve performance.
-    @@list = []
-    # Provide a list of defined entity types,
-    # as non-camel case identifiers.
-    def self.list
-      return @@list unless @@list.empty?
-      self.constants.each do |constant|
-        @@list << :"#{ucc(constant)}"
+    # Create entity lookup table.
+    # Lookup table
+    @@match_types = nil
+    def self.match_types
+      return @@match_types if @@match_types
+      list = (Treat::Entities.list + [:entity])
+      @@match_types = {}
+      list.each do |type1|
+        @@match_types[type1] = {type1 => true}
+        list.each do |type2|
+          if Treat::Entities.const_get(cc(type1)) <
+            Treat::Entities.const_get(cc(type2))
+            @@match_types[type1][type2] = true
+          end
+        end
       end
-      @@list
+      @@match_types
     end
     # Return the hierarchy level of the entity
     # class, the minimum being a Token and the
@@ -43,7 +63,7 @@ module Treat
       klass = Entities.const_get(cc(type))
       compare = lambda { |a,b| a == b || a < b }
       return 0 if compare.call(klass, Token)
-      return 1 if compare.call(klass, Constituent)
+      return 1 if compare.call(klass, Phrase)
       return 2 if compare.call(klass, Sentence)
       return 3 if compare.call(klass, Zone)
       return 4 if compare.call(klass, Document)