treat 0.2.5 → 1.0.0

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

@@ -0,0 +1,31 @@
+# This module implements methods that are used
+# by workers to determine if an entity is properly
+# formatted before working on it.
+module Treat::Entities::Abilities::Checkable
+
+  # Check if the entity has the given feature,
+  # and if so return it. If not, calculate the
+  # requested feature if do_it is set to true,
+  # or raise an exception if do_it is set to false.
+  def check_has(feature, do_it = true)
+    return @features[feature] if has?(feature)
+    return send(feature) if do_it
+    task = caller_method(2) # This is dangerous !
+    g1 = Treat::Categories.lookup(task)
+    g2 = Treat::Categories.lookup(feature)
+
+    raise Treat::Exception,
+    "#{g1.type.to_s.capitalize} #{task} " +
+    "requires #{g2.type} #{g2.method}."
+  end
+
+  # Raises an error if the entity has children.
+  def check_hasnt_children
+    return unless has_children?
+    raise Treat::Exception,
+    "Warning: can't #{caller_method(2)} "+
+    "an entity that has children. Removing " +
+    " all children of text \"[#{short_value}].\""
+  end
+
+end

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

@@ -0,0 +1,45 @@
+module Treat::Entities::Abilities::Copyable
+  
+  require 'fileutils'
+  
+  def copy_into(collection)
+    unless collection.is_a?(
+    Treat::Entities::Collection)
+      raise Treat::Exception,
+      "Cannot copy an entity into " +
+      "something else than a collection."
+    end
+    if type == :document
+      copy_document_into(collection)
+    elsif type == :collection
+      copy_collection_into(collection)
+    else
+      raise Treat::Exception,
+      "Can only copy a document " +
+      "or collection into a collection."
+    end
+  end
+  
+  def copy_collection_into(collection)
+    copy = dup
+    f = File.dirname(folder)
+    f = f.split(File::SEPARATOR)[-1]
+    f = File.join(collection.folder, f)
+    FileUtils.mkdir(f) unless
+    FileTest.directory(f)
+    FileUtils.cp_r(folder, f)
+    copy.set :folder, f
+    copy
+  end
+  
+  def copy_document_into(collection)
+    copy = dup
+    return copy unless file
+    f = File.basename(file)
+    f = File.join(collection.folder, f)
+    FileUtils.cp(file, f)
+    copy.set :file, f
+    copy
+  end
+
+end

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

@@ -0,0 +1,51 @@
+module Treat::Entities::Abilities::Countable
+
+  # Find the position of the current entity
+  # inside the parent entity, starting at 1.
+  def position
+    
+    unless has_parent?
+      raise Treat::Exception,
+      "No parent to get position in."
+    end
+
+    parent.children.index(self) + 1
+    
+  end
+
+  # Find the frequency of the entity in
+  # the supplied parent or in the root
+  # node if nil.
+  def frequency_in(parent_type = nil)
+
+    unless parent_type
+      root.registry[:value][id]
+    end
+
+    registry(parent_type)[:value][value]
+
+  end
+
+  # Get the frequency of this entity's
+  # value in the root node.
+  alias :frequency :frequency_in
+
+  # Get the number of children with a type
+  # in this entity.
+  def count(type)
+    @registry[:type][type].size
+  end
+
+  # Returns the frequency of the given value
+  # in the this entity.
+  def frequency_of(value)
+    if is_a?(Treat::Entities::Token)
+      raise Treat::Exception,
+      "Cannot get the frequency " +
+      "of something within a leaf."
+    end
+    tv = @registry[:value][value]
+    tv ? tv : 0
+  end
+
+end

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

@@ -0,0 +1,83 @@
+# When Treat.debug is set to true, each call to
+# #call_worker will result in a debug message being
+# printed by the #print_debug function.
+module Treat::Entities::Abilities::Debuggable
+  
+  @@prev = nil
+  @@i = 0
+
+  # Explains what Treat is currently doing.
+  def print_debug(entity, task, worker, group, options)
+
+    targs = group.targets.map do |target|
+      target.to_s
+    end
+    
+    if targs.size == 1
+      t = targs[0]
+    else
+      t = targs[0..-2].join(', ') +
+      ' and/or ' + targs[-1]
+    end
+
+    genitive = targs.size > 1 ?
+    'their' : 'its'
+
+    doing = ''
+
+    human_task = task.to_s.gsub('_', ' ')
+
+    if group.type == :transformer ||
+      group.type == :computer
+      
+      tt = human_task
+      tt = tt[0..-2] if tt[-1] == 'e'
+      ed = tt[-1] == 'd' ? '' : 'ed'
+      doing = "#{tt.capitalize}#{ed} #{t}"
+      
+    elsif group.type == :annotator
+
+      if group.preset_option
+        opt = options[group.preset_option]
+        form = opt.to_s.gsub('_', ' ')
+        human_task[-1] = ''
+        human_task = form + ' ' + human_task
+      end
+
+      doing = "Annotated #{t} with " +
+      "#{genitive} #{human_task}"
+    end
+    
+    if group.to_s.index('Formatters')
+      curr = doing +
+      ' in format ' +
+      worker.to_s
+    else
+      curr = doing +
+      ' using ' +
+      worker.to_s.gsub('_', ' ')
+    end
+    
+    curr.gsub!('ss', 's')
+    curr += '.'
+    
+    if curr == @@prev
+      @@i += 1
+    else
+      if @@i > 1
+        Treat::Entities.list.each do |e|
+          @@prev.gsub!(e.to_s, e.to_s + 's')
+        end
+        @@prev.gsub!('its', 'their')
+        @@prev = @@prev.split(' ').
+        insert(1, @@i.to_s).join(' ')
+      end
+      @@i = 0
+      puts @@prev     # Last call doesn't get shown.
+    end
+    
+    @@prev = curr
+  
+  end
+  
+end

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

@@ -0,0 +1,123 @@
+# Makes a class delegatable, allowing calls
+# on it to be forwarded to a worker class
+# able to perform the appropriate task.
+module Treat::Entities::Abilities::Delegatable
+
+  # Add preset methods to an entity class.
+  def add_presets(group)
+
+    opt = group.preset_option
+    return unless opt
+
+    group.presets.each do |preset|
+      define_method(preset) do |worker=nil, options={}|
+        return get(preset) if has?(preset)
+        options = {opt => preset}.merge(options)
+        m = group.method
+        send(m, worker, options)
+        f = unset(m)
+        features[preset] = f if f
+      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 =
+          worker, nil
+        end
+        if !@features[task].nil?
+          @features[task]
+        else
+          self.class.call_worker(
+          self, task, worker,
+          group, options
+          )
+        end
+      end
+    end
+
+  end
+
+  # Ask a worker found in the given group to perform
+  # a task on the entity with the supplied options.
+  def call_worker(entity, task, worker, group, options)
+
+    if worker.nil? || worker == :default
+      worker = find_worker(entity, group)
+    end
+
+    print_debug(entity, task, worker,
+    group, options) if Treat.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)
+
+      if group.type == :annotator && result
+        entity.features[task] = result
+      end
+
+      if group.type == :transformer
+        entity
+      else
+        result
+      end
+
+    end
+  end
+
+  # Find which worker to use if none has been supplied.
+  def find_worker(entity, group)
+    group.default.nil? ?
+    self.find_worker_for_language(
+    entity.language, group) :
+    group.default
+  end
+
+  # Get the default worker for that language
+  # 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 = 'worker to find "' + d
+      raise Treat::Exception, "No #{d}" +
+      "\" is available for the " +
+      "#{lang.to_s.capitalize} language."
+    end
+    return klass[g][0]
+
+  end
+
+  # Return an error message and suggest possible typos.
+  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/entities/abilities/doable.rb

@@ -0,0 +1,62 @@
+# Implement support for the functions #do and #do_task.
+module Treat::Entities::Abilities::Doable
+
+  # Perform the supplied tasks on the entity.
+  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
+    self
+  end
+
+  # Perform an individual task on an entity
+  # given a worker and options to pass to it.
+  def do_task(task, worker, options, group = nil)
+    group ||= get_group(task)
+    entity_types = group.targets
+    f = nil
+    entity_types.each do |t|
+      f = true if Treat::Entities.match_types[t][type]
+    end
+    if f || entity_types.include?(:entity)
+      send(task, worker, options)
+    else
+      each_entity(*entity_types) do |entity|
+        entity.do_task(task, worker, options, group)
+      end
+      unless entity_types.include?(type)
+        features.delete(task)
+      end
+      nil
+    end
+  end
+
+  # Get the group of a task.
+  def get_group(task)
+    g = Treat::Categories.lookup(task)
+    unless g
+      raise Treat::Exception,
+      "Task #{task} does not exist."
+    end
+    g
+  end
+
+
+end

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

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

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

@@ -0,0 +1,115 @@
+module Treat::Entities::Abilities::Iterable
+
+  # Yields each entity of any of the supplied
+  # types in the children tree of this Entity.
+  # Note that this function is recursive, unlike
+  # #each. It does not yield the top element being
+  # recursed.
+  #
+  # This function NEEDS to be ported to C.
+  def each_entity(*types)
+    types = [:entity] if types.size == 0
+    f = false
+    types.each do |t2|
+      if Treat::Entities.match_types[t2][type]
+        f = true; break
+      end
+    end
+    yield self if f
+    unless @children.size == 0
+      # return unless contains_types?(types)
+      @children.each do |child|
+        child.each_entity(*types) { |y| yield y }
+      end
+    end
+  end
+
+  # Returns an array of the children that have a feature
+  # equal to value within the entities of the given type.
+  def entities_with_feature(feature, value, type = nil)
+    a = []
+    type = :entity unless type
+    each_entity(type) do |e|
+      a << e if (e.has?(feature) &&
+      e.features[feature] == value) ||
+      ([:id, :value, :type].include?(feature) &&
+      e.send(feature) == value)
+    end
+    a
+  end
+  
+  # Returns an array of the children that have a type
+  # within the supplied types.
+  def entities_with_types(*types)
+    a = []
+    each_entity(*types) { |e| a << e }
+    a
+  end
+  
+  alias :entities_with_type :entities_with_types
+  
+  # Returns an array of the entities with the given
+  # category.
+  def entities_with_category(category, type = nil)
+    entities_with_feature(:category, type)
+  end
+  
+  # Returns the first ancestor of this entity 
+  # that has the given type.
+  def ancestor_with_types(*types)
+    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
+    end
+  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?
+    ancestor = self
+    while (a = ancestor.ancestor_with_types(*types))
+      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
+  end
+
+  alias :ancestors_with_type :ancestors_with_types
+
+  # Return the first element in the array, warning if not
+  # the only one in the array. Used for magic methods: e.g.,
+  # the magic method "word" if called on a sentence with many 
+  # words, Treat will return the first word, but warn the user.
+  def first_but_warn(array, type)
+    if array.size > 1
+      warn "Warning: requested one #{type}, but" +
+      " there are many #{type}s in this entity."
+    end
+    array[0]
+  end
+
+  
+end