treat 1.0.6 → 1.1.0

data/lib/treat/entities/abilities/copyable.rb

@@ -2,6 +2,8 @@ module Treat::Entities::Abilities::Copyable
   
   require 'fileutils'
   
+  # What happens when it is a database-stored
+  # collection or document ?
   def copy_into(collection)
     unless collection.is_a?(
     Treat::Entities::Collection)

data/lib/treat/entities/abilities/countable.rb

@@ -7,7 +7,7 @@ module Treat::Entities::Abilities::Countable
       raise Treat::Exception,
       "No parent to get position in."
     end
-    parent.children.index(self) + 1
+    parent.children.index(self)
   end
 
   # Find the position of this entity from

data/lib/treat/entities/abilities/debuggable.rb

@@ -65,7 +65,7 @@ module Treat::Entities::Abilities::Debuggable
       @@i += 1
     else
       if @@i > 1
-        Treat::Entities.list.each do |e|
+        Treat.core.entities.list.each do |e|
           @@prev.gsub!(e.to_s, e.to_s + 's')
         end
         @@prev.gsub!('its', 'their')

data/lib/treat/entities/abilities/delegatable.rb

@@ -9,6 +9,7 @@ module Treat::Entities::Abilities::Delegatable
     opt = group.preset_option
     return unless opt
 
+    self.class_eval do
     group.presets.each do |preset|
       define_method(preset) do |worker=nil, options={}|
         return get(preset) if has?(preset)
@@ -19,15 +20,17 @@ module Treat::Entities::Abilities::Delegatable
         features[preset] = f if f
       end
     end
+  end
 
   end
 
   # Add the workers to perform a task on an entity class.
   def add_workers(group)
-
     self.class_eval do
+      
       task = group.method
       add_presets(group)
+      
       define_method(task) do |worker=nil, options={}|
         if worker.is_a?(Hash)
           options, worker =
@@ -37,8 +40,8 @@ module Treat::Entities::Abilities::Delegatable
           @features[task]
         else
           self.class.call_worker(
-          self, task, worker,
-          group, options
+            self, task, worker,
+            group, options
           )
         end
       end
@@ -55,30 +58,25 @@ module Treat::Entities::Abilities::Delegatable
     end
 
     print_debug(entity, task, worker,
-    group, options) if Treat.debug
-
+    group, options) if Treat.core.verbosity.debug
     if not group.list.include?(worker)
       raise Treat::Exception,
       worker_not_found(worker, group)
-    else
-
-      worker = group.const_get(
-      cc(worker.to_s).intern
-      )
-      
-      result = worker.send(group.method, entity, options)
+    end
 
-      if group.type == :annotator && result
-        entity.features[task] = result
-      end
+    worker = group.const_get(cc(worker.to_s).intern)
+    result = worker.send(group.method, entity, options)
 
-      if group.type == :transformer
-        entity
-      else
-        result
-      end
+    if group.type == :annotator && result
+      entity.features[task] = result
+    end
 
+    if group.type == :transformer
+      entity
+    else
+      result
     end
+
   end
 
   # Find which worker to use if none has been supplied.
@@ -93,23 +91,31 @@ module Treat::Entities::Abilities::Delegatable
   # inside the given group.
   def find_worker_for_language(language, group)
 
-    lang = Treat::Languages.describe(language)
-    klass = cc(lang).intern
-    lclass = Treat::Languages.const_get(klass)
-    cat = group.to_s.split('::')[-2].intern
-    klass = lclass.const_get(cat)
-
-    g = ucc(cl(group)).intern
-
-    if !klass[g] || !klass[g][0]
-      d = ucc(cl(group))
-      d.gsub!('_', ' ')
-      d = d[0..-2]
-      raise Treat::Exception, "No #{d}" +
-      " is available for the " +
-      "#{lang.to_s.capitalize} language."
+    lang = Treat.languages[language]
+    cat = group.to_s.split('::')[2].downcase.intern
+    group = ucc(cl(group)).intern
+
+    if lang.nil?
+      raise Treat::Exception,
+      "No configuration file loaded for language #{language}."
+    end
+    
+    workers = lang.workers
+    
+    if !workers.respond_to?(cat) ||
+       !workers[cat].respond_to?(group)
+        workers = Treat.languages.agnostic.workers
+    end
+    
+    if !workers.respond_to?(cat) || 
+       !workers[cat].respond_to?(group)
+      raise Treat::Exception,
+      "No #{group} is/are available for the " +
+      "#{language.to_s.capitalize} language."
     end
-    return klass[g][0]
+  
+    
+    workers[cat][group].first
 
   end
 

data/lib/treat/entities/abilities/doable.rb

@@ -33,7 +33,7 @@ module Treat::Entities::Abilities::Doable
     entity_types = group.targets
     f = nil
     entity_types.each do |t|
-      f = true if Treat::Entities.match_types[t][type]
+      f = true if is_a?(Treat::Entities.const_get(cc(t)))
     end
     if f || entity_types.include?(:entity)
       send(task, worker, options)
@@ -55,7 +55,7 @@ module Treat::Entities::Abilities::Doable
 
   # Get the group of a task.
   def get_group(task)
-    g = Treat::Categories.lookup(task)
+    g = Treat::Workers.lookup(task)
     unless g
       raise Treat::Exception,
       "Task #{task} does not exist."

data/lib/treat/entities/abilities/exportable.rb

@@ -1,7 +1,7 @@
 module Treat::Entities::Abilities::Exportable
   
   def export(classification)
-    ds = Treat::DataSet.new(classification)
+    ds = Treat::Core::DataSet.new(classification)
     each_entity(*classification.types) do |e|
       ds << e
     end

data/lib/treat/entities/abilities/iterable.rb

@@ -11,7 +11,7 @@ module Treat::Entities::Abilities::Iterable
     types = [:entity] if types.size == 0
     f = false
     types.each do |t2|
-      if Treat::Entities.match_types[t2][type]
+      if is_a?(Treat::Entities.const_get(cc(t2)))
         f = true; break
       end
     end
@@ -54,57 +54,45 @@ module Treat::Entities::Abilities::Iterable
   
   # Returns the first ancestor of this entity 
   # that has the given type.
-  def ancestor_with_types(*types)
+  def ancestor_with_type(type)
+    return unless has_parent?
     ancestor = @parent
-    match_types = lambda do |t1, t2|
-      f = false
-      types.each do |t2|
-        if Treat::Entities.match_types[t2][t1]
-          f = true; break
-        end
-      end
-      f
-    end
-    if ancestor
-      while not match_types.call(ancestor.type, type)
-        return nil unless (ancestor && ancestor.has_parent?)
-        ancestor = ancestor.parent
-      end
-      match_types.call(ancestor.type, types) ? ancestor : nil
+    type_klass = Treat::Entities.const_get(cc(type))
+    while not ancestor.is_a?(type_klass)
+      return nil unless (ancestor && ancestor.has_parent?)
+      ancestor = ancestor.parent
     end
+    ancestor
   end
 
-  alias :ancestor_with_type :ancestor_with_types
-
   # Yields each ancestors of this entity that
-  # has one of the the given types. May skip levels.
-  def each_ancestor(*types)
-    types = [:entity] if types.empty?
+  # has the given type.
+  def each_ancestor(type = :entity)
     ancestor = self
-    while (a = ancestor.ancestor_with_types(*types))
+    while (a = ancestor.ancestor_with_type(type))
       yield a
       ancestor = ancestor.parent
     end
   end
   
-  # Returns an array of ancestors of this entity that
-  # has one of the the given types. May skip levels.
-  def ancestors_with_types(*types)
-    as = []
-    each_ancestor(*types) { |a| as << a }
-    as
+  # Returns an array of ancestors of this 
+  # entity that have the given type.
+  def ancestors_with_type(type)
+    ancestors = []
+    each_ancestor(type) do |a| 
+      ancestors << a
+    end
+    ancestors
   end
 
   # Returns the first ancestor that has a feature
   # with the given name, otherwise nil.
-  def ancestor_with_feature(type, feature)
-    each_ancestor(type) do |ancestor|
+  def ancestor_with_feature(feature)
+    each_ancestor do |ancestor|
       return ancestor if ancestor.has?(feature)
     end
   end
   
-  alias :ancestors_with_type :ancestors_with_types
-
   # Number of children that have a given feature.
   def num_children_with_feature(feature)
     i = 0

data/lib/treat/entities/abilities/magical.rb

@@ -24,8 +24,9 @@ module Treat::Entities::Abilities::Magical
   #
   def magic(sym, *args)
 
-    @@entities_regexp ||= "(#{Treat::Entities.list.join('|')})"
-    @@cats_regexp ||= "(#{Treat::Languages::Language::WordCategories.join('|')})"
+    # Cache this for performance.
+    @@entities_regexp ||= "(#{Treat.core.entities.list.join('|')})"
+    @@cats_regexp ||= "(#{Treat.linguistics.categories.join('|')})"
 
     method = sym.to_s =~ /entities/ ?
     sym.to_s.gsub('entities', 'entitys') :
@@ -56,17 +57,16 @@ module Treat::Entities::Abilities::Magical
       entities_with_feature($2.intern, 
       args[0], $1.intern).each { |e| yield e }
     elsif method =~ /^each_#{@@cats_regexp}$/
-      entities_with_category($1.intern
-      ).each { |e| yield e }
+      entities_with_category($1).each { |e| yield e }
     elsif method =~ /^#{@@cats_regexp}s$/
-      entities_with_category($1.intern)
+      entities_with_category($1)
     elsif method =~ /^#{@@cats_regexp}$/
-     first_but_warn(entities_with_category($1.intern), $1)
+     first_but_warn(entities_with_category($1), $1)
     elsif method =~ /^first_#{@@cats_regexp}$/
-     e = entities_with_category($1.intern)
+     e = entities_with_category($1)
      e ? e[0] : nil
     elsif method =~ /^#{@@cats_regexp}_count$/
-      entities_with_category($1.intern).size
+      entities_with_category($1).size
     elsif method =~ /^(.*)_count$/
       num_children_with_feature($1.intern)
     elsif method =~ /^#{@@cats_regexp}s_with_([a-z]*)$/

data/lib/treat/entities/abilities/registrable.rb

@@ -43,42 +43,4 @@ module Treat::Entities::Abilities::Registrable
     end
   end
 
-  def contains_id?(id)
-    
-    @registry[:id][id]
-    
-  end
-
-  def contains_value?(val)
-    
-    @registry[:value][val] ?
-    true : false
-    
-  end
-
-  def contains_type?(type1)
-    
-    return true if @registry[:type][type1]
-    
-    @registry[:type].each do |type2, count|
-      if Treat::Entities.
-        match_types[type1][type2]
-        return true
-      end
-    end
-    
-    false
-    
-  end
-
-  def contains_types?(types)
-    
-    types.each do |type|
-      return true if contains_type?(type)
-    end
-    
-    false
-    
-  end
-
 end

data/lib/treat/entities/abilities/stringable.rb

@@ -32,28 +32,28 @@ module Treat::Entities::Abilities::Stringable
     end
   end
 
-  # Return an informative string representation
-  # of the entity.
-  def inspect
-    s = "#{cl(self.class)} (#{@id.to_s})"
-    if caller_method(2) == :inspect
-      @id.to_s
-    else
-      dependencies = []
-      @dependencies.each do |dependency|
-        dependencies <<
-        "#{dependency.target}#{dependency.type}"
-      end
-      s += "  --- #{short_value.inspect}" +
-      "  ---  #{@features.inspect} " +
-      "  --- #{dependencies.inspect} "
-    end
-    s
-  end
-
   # Print out an ASCII representation of the tree.
   def print_tree; puts visualize(:tree); end
   
+  # Return an informative string representation
+   # of the entity.
+   def inspect
+     s = "#{cl(self.class)} (#{@id.to_s})"
+     if caller_method(2) == :inspect
+       @id.to_s
+     else
+       dependencies = []
+       @dependencies.each do |dependency|
+         dependencies <<
+         "#{dependency.target}#{dependency.type}"
+       end
+       s += "  --- #{short_value.inspect}" +
+       "  ---  #{@features.inspect} " +
+       "  --- #{dependencies.inspect} "
+     end
+     s
+   end
+   
   # Helper method to implode the string value of the subtree.
   def implode
     

data/lib/treat/entities/collection.rb

@@ -0,0 +1,31 @@
+module Treat::Entities
+  # Represents a collection of texts.
+  class Collection < Treat::Entities::Entity
+
+    # Initialize the collection with a folder
+    # containing the texts of the collection.
+    def initialize(folder = nil, id = nil)
+      super('', id)
+      set :folder, folder
+      i = folder + '/.index'
+      set :index, i if FileTest.directory?(i)
+    end
+
+    # Works like the default <<, but if the
+    # file being added is a collection or a
+    # document, then copy that collection or
+    # document into this collection's folder.
+    def <<(entities, copy = true)
+      unless entities.is_a? Array
+        entities = [entities]
+      end
+      entities.each do |entity|
+        if [:document, :collection].
+          include?(entity.type) && copy
+          entity = entity.copy_into(self)
+        end
+      end
+      super(entities)
+    end
+  end
+end

data/lib/treat/entities/document.rb

@@ -0,0 +1,10 @@
+module Treat::Entities
+  # Represents a document.
+  class Document < Treat::Entities::Entity
+    # Initialize a document with a file name.
+    def initialize(file = nil, id = nil)
+      super('', id)
+      set :file, file
+    end
+  end
+end

data/lib/treat/entities/entity.rb

@@ -1,17 +1,20 @@
 module Treat::Entities
 
-  # Require base class for Entity.
-  require 'treat/tree'
+  module Abilities; end
 
-  class Entity < Treat::Tree::Node
+  # Require abilities.
+  p = Treat.paths.lib +
+  'treat/entities/abilities/*.rb'
+  Dir.glob(p).each { |f| require f }
+
+  require 'birch'
+
+  class Entity < Treat::Core::Node
 
     # A Symbol representing the lowercase
     # version of the class name.
     attr_accessor :type
 
-    # Require abilities.
-    require 'treat/entities/abilities'
-
     # Implements support for #register,
     # #registry, and #contains_* methods.
     include Abilities::Registrable
@@ -48,14 +51,17 @@ module Treat::Entities
     # #entities_with_type, #ancestors_with_type,
     # #entities_with_feature, #entities_with_category.
     include Abilities::Iterable
-    
+
     # Implement support for #export to export
     # a line of a data set based on a classification.
     include Abilities::Exportable
-    
+
     # Implement support for #copy_into.
     include Abilities::Copyable
-    
+
+    # Implement support for #self.compare_with
+    extend Abilities::Comparable
+
     # Initialize the entity with its value and
     # (optionally) a unique identifier. By default,
     # the object_id will be used as id.
@@ -65,7 +71,7 @@ module Treat::Entities
       @type = :entity if self == Entity
       @type ||= ucc(cl(self.class)).intern
     end
-    
+
     # Add an entity to the current entity.
     # Registers the entity in the root node
     # token registry if the entity is a leaf.
@@ -83,7 +89,6 @@ module Treat::Entities
       entities[0]
     end
 
-
     # Catch missing methods to support method-like
     # access to features (e.g. entity.category
     # instead of entity.features[:category]) and to
@@ -105,13 +110,13 @@ module Treat::Entities
           super(sym, *args, &block)
         rescue NoMethodError
           raise Treat::Exception,
-          if Treat::Categories.lookup(sym)
+          if Treat::Workers.lookup(sym)
             msg = "Method #{sym} cannot " +
             "be called on a #{type}."
           else
             msg = "Method #{sym} does not exist."
             msg += did_you_mean?(
-            Treat::Categories.methods, sym)
+            Treat::Workers.methods, sym)
           end
         end
       else

data/lib/treat/entities/group.rb

@@ -0,0 +1,15 @@
+module Treat::Entities
+  
+  # Any kind of grouped entities.
+  class Group < Treat::Entities::Entity; end
+
+  # Represents a group of words with a sentence ender.
+  class Sentence < Group; end
+
+  # Represents a group of words.
+  class Phrase < Group; end
+
+  # Represents a non-linguistic fragment
+  class Fragment < Group; end
+
+end

data/lib/treat/entities/section.rb

@@ -0,0 +1,13 @@
+module Treat::Entities
+  # Represents a section.
+  class Section < Treat::Entities::Entity; end
+
+  # Represents a page of text.
+  class Page < Section; end
+
+  # Represents a block of text 
+  class Block < Section; end
+
+  # Represents a list.
+  class List < Section; end
+end

data/lib/treat/entities/token.rb

@@ -0,0 +1,35 @@
+module Treat::Entities
+  # Represents a terminal element in the text structure.
+  class Token < Treat::Entities::Entity; end
+
+  # Represents a word.
+  class Word < Token; end
+
+  # Represents a clitic ('s).
+  class Enclitic < Token; end
+
+  # Represents a number.
+  class Number < Token
+    def to_i; to_s.to_i; end
+    def to_f; to_s.to_f; end
+  end
+
+  # Represents a punctuation sign.
+  class Punctuation < Token; end
+
+  # Represents a character that is neither
+  # alphabetical, numerical or a punctuation
+  # character (e.g. @#$%&*).
+  class Symbol < Token; end
+
+  # Represents a url.
+  class Url < Token; end
+
+  # Represents a valid RFC822 address.
+  class Email < Token; end
+  
+  # Represents a token whose type
+  # cannot be identified.
+  class Unknown; end
+  
+end

data/lib/treat/entities/zone.rb

@@ -0,0 +1,11 @@
+module Treat::Entities
+  # Represents a zone of text
+  # (Title, Paragraph, List, Quote).
+  class Zone < Treat::Entities::Entity; end
+
+  # Represents a title, subtitle, logical header.
+  class Title < Zone; end
+
+  # Represents a paragraph.
+  class Paragraph < Zone; end
+end

data/lib/treat/entities.rb

@@ -1,76 +1,6 @@
-# Entities are Tree structures that represent textual entities
-# (from a collection of texts down to an individual word) with
-# a unique identifier, a value, features, children and dependencies
-# linking them to other textual entities.
-#
-# - A Collection represents a folder containing documents (and folders).
-# - A Document represents a file with a textual content.
-# - A Zone represents a logical division of content in a document.
-# - A Phrase is a group of words; a Sentence is a Phrase with an ender.
-# - A Token represents a Word, a Number, a Punctuation or a Symbol.
+# Contains the textual model used by Treat.
 module Treat::Entities
-
-  # Variables for the singleton class.
-  class << self
-    # Provide a list of all entity types except Entity,
-    # as non_camel_case identifiers.
-    attr_accessor :list
-  end
-
-  # Require all entities.
-  require 'treat/entities/entities'
-  
-  # Add each constant to the list, except Entity.
-  self.list = []
-  constants.each do |constant|
-    unless constant == :Entity || 
-           constant == :Abilities
-      self.list << ucc(constant).intern
-    end
-  end
-
-  # Make each Entity class buildable magically.
-  # This enables to create Entities without calling
-  # #new (e.g. Word 'hello').
-  constants.each do |entity|
-    define_singleton_method(entity) do |value='', id=nil|
-      const_get(entity).build(value, id)
-    end
-  end
-
-  # Create entity 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|
-      list.each do |type2|
-        @@match_types[type2] ||= {}
-        if (type1 == type2) ||
-          (Treat::Entities.const_get(cc(type1)) <
-          Treat::Entities.const_get(cc(type2)))
-          @@match_types[type2][type1] = true
-        end
-      end
-    end
-    @@match_types
-  end
-  
-  # A bottom-up ordering of general types of entities.
-  @@order = [Token, Phrase, Zone, Section, Document, Collection]
-  
-  # Return the hierarchy level of the entity
-  # class, the minimum being a Token and the
-  # maximum being a Collection.
-  #
-  # Implement as true comparison functions.
-  def self.rank(type)
-    klass = Treat::Entities.const_get(cc(type))
-    compare = lambda { |a,b| a == b || a < b }
-    1.upto(@@order.size) do |i|
-      return i if compare.call(klass, @@order[i])
-    end
-  end
-
-end
+  require 'treat/entities/entity'
+  p = Treat.paths.lib + 'treat/entities/*.rb'
+  Dir.glob(p).each { |f| require f }
+end