treat 0.1.4 → 0.2.0

data/lib/treat/entities/collection.rb

@@ -6,6 +6,7 @@ module Treat
       # containing the texts of the collection.
       def initialize(folder = nil, id = nil)
         super('', id)
+        @type = :collection
         if folder
           set :folder, folder
           Dir.glob("#{folder}/*").each do |f|
@@ -14,6 +15,7 @@ module Treat
           end
         end
       end
+      def type; :collection; end
     end
   end
 end

data/lib/treat/entities/document.rb

@@ -2,9 +2,10 @@ module Treat
   module Entities
     # Represents a document.
     class Document < Entity
-      def initialize(file, id = nil)
+      def initialize(file = nil, id = nil)
         super('', id)
-        set :file, file
+        set :file, file if file
+        @type = :document
       end
     end
   end

data/lib/treat/entities/entity.rb

@@ -4,27 +4,27 @@ require 'treat/delegatable'
 require 'treat/visitable'
 require 'treat/registrable'
 require 'treat/buildable'
+require 'treat/doable'
+require 'treat/viewable'
+require 'treat/features'
 
 module Treat
   module Entities
     class Entity < Tree::Node
+      # A Symbol representing the lowercase version of the class name.
+      attr_accessor :type
       # Implements support for #register
       include Registrable
       # Implement support for #accept.
       include Visitable
-      # Implement support for #self.add_delegators
+      # Implement support for #self.add_workers
       extend Delegatable
       # Implement support for #self.from_*
       extend 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 self.build(file_or_value = '', id = nil)
-        from_anything(file_or_value, id)
-      end
+      # Implement support for #do.
+      include Doable
+      # Implement support for to_s, inspect, etc.
+      include Viewable
       # Initialize the entity with its value and
       # (optionally) a unique identifier. By default,
       # the object_id will be used as id. Also initialize
@@ -32,12 +32,10 @@ module Treat
       def initialize(value = '', id = nil)
         id ||= object_id
         super(value, id)
+        @type = :entity
       end
-      # Return a lowercase identifier representing the
-      # type of entity (e.g. :word, :token, etc.)
-      def type; :"#{cl(self.class).downcase}"; end
       # Catch missing methods to support method-like
-      # access to features (e.g. entity.cat instead of
+      # access to features (e.g. entity.categoryinstead of
       # entity.features[:cat]) and to support magic
       # methods (see #parse_magic_method). If the
       # feature does not exist
@@ -49,8 +47,8 @@ module Treat
             begin
               super(sym, *args, &block)
             rescue NoMethodError
-              # Check...
-              if Categories.have_method?(sym)
+              return false if sym.to_s[-1] == '?'
+              if Categories.lookup(sym)
                 msg = "Method #{sym} cannot be called on a #{type}."
               else
                 msg = "Method #{sym} does not exist."
@@ -87,77 +85,81 @@ module Treat
       # - nouns_with_*(value)
       # - noun_with_*(value)
       #
-      # Note that repetition of code in this method
-      # (instead of method chaining) is intentional
-      # and aims to reduce the number of method
-      # dispatches done by Ruby to improve performance.
-      def parse_magic_method(sym, *args, &block)
+      def parse_magic_method(sym, *args)
         @@entities_regexp ||= "(#{Treat::Entities.list.join('|')})"
-        @@cats_regexp ||= "(#{Treat::Languages::English::Categories.join('|')})"
+        @@cats_regexp ||= "(#{Treat::Languages::WordCategories.join('|')})"
         method = sym.to_s =~ /entities/ ?
-        sym.to_s.gsub('entities', 'entitys'):
+        sym.to_s.gsub('entities', 'entitys') :
         method = sym.to_s
-        a = []
-        if method =~ /^parent_#{@@entities_regexp}$/           # Optimize all
-          self.class.send(:define_method, "parent_#{$1}") do
-            ancestor_with_types(:"#{$1}")
-          end
-          ancestor_with_types(:"#{$1}")
-        elsif method =~ /^each_#{@@entities_regexp}$/
-          each_entity(:"#{$1}") { |entity| yield entity }
-        elsif method =~ /^#{@@entities_regexp}s$/
-          each_entity(:"#{$1}") { |e| a << e }
+        if method =~ /^#{@@entities_regexp}s$/
+          a = []
+          each_entity($1.intern) { |e| a << e }
           a
         elsif method =~ /^#{@@entities_regexp}$/
-          each_entity(:"#{$1}") { |e| a << e }
+          a = []
+          each_entity($1.intern) { |e| a << e }
           first_but_warn(a, $1)
+        elsif method =~ /^parent_#{@@entities_regexp}$/
+          ancestor_with_types($1.intern)
+        elsif method =~ /^each_#{@@entities_regexp}$/
+          each_entity($1.intern) { |e| yield e }
         elsif method =~ /^#{@@entities_regexp}_count$/
           i = 0
-          each_entity(:"#{$1}") { |e| i += 1 }
+          each_entity($1.intern) { |e| i += 1 }
           i
-        elsif method =~ /^#{@@entities_regexp}s_with_([a-z]*)$/
-          each_entity(:"#{$1}") do |e|
-            a << e if e.has?(:"#{$2}") &&
-            e.send(:"#{$2}") == args[0]
+        elsif method =~ /^#{@@entities_regexp}s_with_([a-z]+)$/
+          a = []
+          each_entity($1.intern) do |e|
+            a << e if e.has?($2.intern) &&
+            e.send($2.intern) == args[0]
           end
           a
         elsif method =~ /^#{@@entities_regexp}s_with_([a-z]*)$/
-          each_entity(:"#{$1}") do |e|
-            a << e if e.has?(:"#{$2}") &&
-            e.send(:"#{$2}") == args[0]
+          a = []
+          each_entity($1.intern) do |e|
+            a << e if e.has?($2.intern) &&
+            e.send($2.intern) == args[0]
           end
           first_but_warn(a, $1)
         elsif method =~ /^each_with_([a-z]*)$/
           each_entity do |e|
-            yield e if e.has?(:"#{$2}") &&
-            e.send(:"#{$2}") == args[0]
+            yield e if e.has?($1.intern) &&
+            e.send($1.intern) == args[0]
           end
         elsif method =~ /^each_#{@@cats_regexp}$/
-          each_entity(:word) { |e| yield e if e.cat == :"#{$1}" }
+          each_entity(:word) { |e| yield e if e.category == $1.intern }
         elsif method =~ /^#{@@cats_regexp}s$/
-          each_entity(:word) { |e| a << e if e.cat == :"#{$1}" }
+          a = []
+          each_entity(:word) { |e| a << e if e.category == $1.intern }
           a
         elsif method =~ /^#{@@cats_regexp}$/
-          each_entity(:word) { |e| a << e if e.cat == :"#{$1}" }
+          a = []
+          each_entity(:word) { |e| a << e if e.category == $1.intern }
           first_but_warn(a, $1)
         elsif method =~ /^#{@@cats_regexp}_count$/
           i = 0
-          each_entity(:word) { |e| i += 1 if e.cat == :"#{$1}" }
+          each_entity(:word) { |e| i += 1 if e.category == $1.intern }
           i
         elsif method =~ /^#{@@cats_regexp}s_with_([a-z]*)$/
+          a = []
           each_entity(:word) do |e|
-            a << e if e.cat == :"#{$1}" &&
-            e.has?(:"#{$2}") && e.send(:"#{$2}") == args[0]
+            a << e if e.category == $1.intern &&
+            e.has?($2.intern) && e.send($2.intern) == args[0]
           end
           a
         elsif method =~ /^#{@@cats_regexp}_with_([a-z]*)$/
+          a = []
           each_entity(:word) do |e|
-            a << e if e.cat == :"#{$1}" &&
-            e.has?(:"#{$2}") && e.send(:"#{$2}") == args[0]
+            a << e if e.category== $1.intern &&
+            e.has?($2.intern) && e.send($2.intern) == args[0]
           end
           first_but_warn(a, $1)
+        elsif method =~ /^is_#{@@entities_regexp}\?$/
+          type.to_s == $1
+        elsif method =~ /^is_#{@@cats_regexp}\?$/
+          category.to_s == $1
         else
-          :no_magic
+          return :no_magic
         end
       end
       # Add an entity to the current entity.
@@ -168,9 +170,9 @@ module Treat
       def <<(entities, clear_parent = true)
         entities = [entities] unless entities.is_a? Array
         entities.each do |entity|
-          if entity.is_a?(Treat::Entities::Token) || 
-            entity.is_a?(Treat::Entities::Constituent)
-              register_token(entity) unless entity.value == ''
+          if entity.is_a?(Treat::Entities::Token) ||
+            entity.is_a?(Treat::Entities::Phrase)
+            register_token(entity) unless entity.value == ''
           end
         end
         super(entities)
@@ -182,39 +184,64 @@ module Treat
       # 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 (see source).
       def each_entity(*types)
-        yield self if match_types(self, types)
-        if has_children?
+=begin  
+     # Replace with:
+    inline do |builder|
+
+      builder.c_raw <<-EOS, :arity => -1
+      VALUE each_entity_c(int argc, VALUE *types, VALUE self)
+      {
+
+      }
+      EOS
+    end
+=end
+        types = [:entity] if types.size == 0
+        f = false
+        types.each { |t2| f = true if Treat::Entities.match_types[type][t2] }
+        yield self if f
+        unless @children.size == 0
           @children.each do |child|
             child.each_entity(*types) { |y| yield y }
           end
         end
       end
-      # Returns the first ancestor of this
-      # entity that has the given type.
+      # Returns the first ancestor of this entity that has the given type.
       def ancestor_with_types(*types)
         ancestor = @parent
-        while not match_types(ancestor, types)
-          return nil unless ancestor.has_parent?
-          ancestor = ancestor.parent
+        match_types = lambda do |t1, t2s|
+          f = false
+          t2s.each do |t2|
+            if Treat::Entities.match_types[t1][t2]
+              f = true; break
+            end
+          end
+          f
+        end
+        if ancestor
+          while not match_types.call(ancestor.type, types)
+            return nil unless (ancestor && ancestor.has_parent?)
+            ancestor = ancestor.parent
+          end
+          match_types.call(ancestor.type, types) ? ancestor : nil
         end
-        match_types(ancestor, types) ? ancestor : nil
       end
       alias :ancestor_with_type :ancestor_with_types
-      # Return the entity's string value in plain text format.
-      def to_string; @value; end
-      # An alias for #to_string.
-      def to_s; visualize(:txt); end
-      alias :to_str :to_s
-      # Return an informative string representation of the entity.
-      def inspect; visualize(:inspect); end
-      # Print out an ASCII representation of the tree.
-      def print_tree; puts visualize(:tree); end
-      # Return a shortened value of the entity's string value using [...].
-      def short_value(ml = 6); visualize(:short_value, :max_length => ml); end
-      # Convenience functions. Convenience decorators.
-      def frequency_of(word); statistics(:frequency_of, value: word); end
-      private
+      # Returns the (direct) ancestors of this entity that
+      # have the given type.
+      def ancestors_with_types(*types)
+        ancestor = self
+        ancestors = []
+        while (a = ancestor.ancestor_with_types(*types))
+          ancestors << a
+          ancestor = ancestor.parent
+        end
+        ancestors
+      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
@@ -227,18 +254,6 @@ module Treat
         end
         array[0]
       end
-      # Cache a list of the type => class relationships.
-      @@type_classes = {}
-      # Returns true if the node is of the same type or
-      # is a subtype of of one of the specified entity types,
-      # which are supplied as identifiers rather than classes.
-      def match_types(node, entity_types)
-        entity_types.each do |type|
-          @@type_classes[type] ||= Entities.const_get(cc(type))
-          return true if node.is_a? @@type_classes[type]
-        end
-        false
-      end
     end
   end
 end

data/lib/treat/entities/phrases.rb

@@ -0,0 +1,17 @@
+module Treat
+  module Entities
+    # Represents any syntactic phrase of a sentence.
+    class Phrase < Entity
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :phrase
+      end
+    end
+    class Sentence < Phrase
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :sentence
+      end
+    end
+  end
+end

data/lib/treat/entities/tokens.rb

@@ -4,25 +4,24 @@ module Treat
     class Token < Entity
       # All tokens are leafs.
       def is_leaf?; true; end
-      # Convenience function for statistics.
-      def frequency; statistics(:frequency_in); end
-      def frequency_in(type); statistics(:frequency_in, type: type); end
-      def position_in(type); statistics(:position_in_parent); end
-      def tf_idf; statistics(:tf_idf); end
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :token
+      end
     end
     # Represents a word.
     class Word < Token
-      # Convenience function for conjugations.
-      def infinitive(conjugator = nil); conjugations(conjugator, :mode => :infinitive); end
-      # Convenience function for conjugations.
-      def present_participle(conjugator = nil); conjugations(conjugator, :tense => :present, :mode => :participle); end
-      # Convenience function for declensions.
-      def plural(declensor = nil); declensions(declensor, :count => :plural); end
-      # Convenience function for declensions.
-      def singular(declensor = nil); declensions(declensor, :count => :singular); end
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :word
+      end
     end
     # Represents a clitic ('s).
     class Clitic < Token
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :clitic
+      end
     end
     # Represents a number.
     class Number < Token
@@ -30,17 +29,33 @@ module Treat
       def to_i; to_s.to_i; end
       # Convert the number to a float.
       def to_f; to_s.to_f; end
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :number
+      end
     end
     # Represents a punctuation sign.
     class Punctuation < Token
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :punctuation
+      end
     end
     # Represents a character that is neither
     # alphabetical, numerical or a punctuation
     # character (e.g. @#$%&*).
     class Symbol < Token
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :symbol
+      end
     end
     # Represents an entity of unknown type.
     class Unknown < Token
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :unknown
+      end
     end
   end
 end

data/lib/treat/entities/zones.rb

@@ -3,19 +3,39 @@ module Treat
     # Represents a zone of text 
     # (Title, Paragraph, List, Quote).
     class Zone < Entity
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :zone
+      end
     end
     # Represents a title, subtitle, logical header.
     class Title < Zone
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :title
+      end
     end
     # Represents a paragraph.
     class Paragraph < Zone
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :paragraph
+      end
     end
     # Represents a list.
     class List < Zone
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :list
+      end
     end
     # Represents a section, usually with a title
     # and at least one paragraph.
     class Section < Zone
+      def initialize(value = '', id = nil)
+        super(value, id)
+        @type = :section
+      end
     end
   end
 end