treat 0.2.5 → 1.0.0

data/lib/treat/tree.rb

@@ -1,191 +1,249 @@
-module Treat
-  # This module provides an abstract tree structure with
-  # nodes having an id, a value, children, features and dependencies.
-  module Tree
-    # This class models the nodes for an N-ary tree data structue
-    # with unique identifiers, text value, children, features
-    # (annotations) and dependencies. 
-    #
-    # This class was tightly based on the 'rubytree' gem.
-    # RubyTree is licensed under the BSD license and can
-    # be found at http://rubytree.rubyforge.org/rdoc/.
-    # I have made several modifications in order to better
-    # suit this library and to avoid monkey patching.
-    class Node
-      # Iterate over each children in the node.
-      def each
-        @children.each { |child| yield child }
-      end
-      # A string containing the node's value (or empty).
-      attr_accessor :value
-      # A unique identifier for the node.
-      attr_reader :id
-      # An array containing the children of this node.
-      attr_reader :children
-      # A hash containing the features of this node.
-      attr_accessor :features
-      # An array containing the dependencies that link this 
-      # node to other nodes.
-      attr_accessor :dependencies
-      # A struct for dependencies.
-      Struct.new('Dependency', :target, :type, :directed, :direction)
-      # The parent of the node.
-      attr_accessor :parent
-      # Initialize the node with its value and id.
-      # Setup containers for the children, features
-      # and dependencies of this node.
-      def initialize(value, id = nil)
-        @parent = nil
-        @value, @id = value, id
-        @children = []
-        @children_hash = {}
-        @features = {}
-        @dependencies = []
-      end
-      # Boolean - does the node have dependencies?
-      def has_dependencies?; !(@dependencies.size == 0); end
-      # Boolean - does the node have children?
-      def has_children?; !(@children.size == 0); end
-      # Boolean - does the node have features?
-      def has_features?; !(@features.size == 0); end
-      # Boolean - does the node have a parent?
-      def has_parent?; !@parent.nil?; end
-      # Boolean - does the node not have a parent?
-      def is_root?; @parent.nil?; end
-      # Remove this node from its parent and set as root.
-      def set_as_root!; @parent = nil; self; end
-      # Boolean - is this node a leaf ?
-      # This is overriden in leaf classes.
-      def is_leaf?; !has_children?; end
-      # Add the nodes to the given child.
-      # This may be used with several nodes,
-      # for example: node << [child1, child2, child3]
-      def <<(nodes)
-        nodes = [nodes] unless nodes.is_a? Array
-        raise 'Trying to add a nil node.' if nodes.include? nil
-        nodes.each do |node|
-          node.parent = self
-          @children << node
-          @children_hash[node.id] = node
-        end
-        nodes[0]
-      end
-      # Retrieve a child node by name or index.
-      def [](name_or_index)
-        if name_or_index == nil
-          raise Treat::Exception, 
-          "Non-nil name or index needs to be provided." 
-        end
-        if name_or_index.kind_of?(Integer) && 
-          name_or_index < 1000
-          @children[name_or_index]
-        else
-          @children_hash[name_or_index]
-        end
-      end
-      # Remove the supplied node or id of a node from the children.
-      def remove!(ion)
-        return nil unless ion
-        if ion.is_a? Treat::Tree::Node
-          @children.delete(ion)
-          @children_hash.delete(ion.id)
-          ion.set_as_root!
-        else
-          @children.delete(@children_hash[ion])
-          @children_hash.delete(ion)
-        end
-      end
-      # Remove all children.
-      def remove_all!
-        @children.each { |child| child.set_as_root! }
-        @children.clear
-        @children_hash.clear
-        self
-      end
-      # Previous sibling from the same parent.
-      def next_sibling
-        return nil if is_root?
-        id = @parent.children.index(self)
-        @parent.children.at(id + 1) if id
-      end
-      # Return the sibling N positions to the left of this one.
-      def left(n = 1); sibling(-1*n); end
-      # Return the sibling N positions to the right of this one.
-      def right(n = 1); sibling(1*n); end
-      # Return the sibling with position #pos versus 
-      # this one. #pos can be ... -1, 0, 1, ...
-      def sibling(pos)
-        return nil if is_root?
-        id = @parent.children.index(self)
-        @parent.children.at(id + pos)
-      end
-      # Return all brothers and sisters of this node.
-      def siblings
-        r = @parent.children.dup
-        r.delete(self)
-        r
-      end
-      # Total number of nodes in the subtree, including this one.
-      def size
-        @children.inject(1) { |sum, node| sum + node.size }
-      end
-      # Set the feature to the supplied value.
-      def set(feature, value)
-        @features ||= {}
-        @features[feature] = value
-      end
-      # Unset a feature.
-      def unset(feature)
-        @features.delete(feature)
-      end
-      # Return the depth of this node in the tree.
-      def depth
-        return 0 if is_root?
-        1 + parent.depth
-      end
-      # Does the entity have a feature ?
-      def has_feature?(feature)
-        (@features.has_key?(feature) && 
-        !@features[feature].nil?) ||
-        [:id, :value, :children, :dependencies].include?(feature)
+# This module provides an abstract tree structure.
+module Treat::Tree
+
+  # This class is a node for an N-ary tree data structure
+  # with a unique identifier, text value, children, features
+  # (annotations) and dependencies.
+  #
+  # This class was partly based on the 'rubytree' gem.
+  # RubyTree is licensed under the BSD license and can
+  # be found at http://rubytree.rubyforge.org/rdoc/.
+  # I have made several modifications in order to better
+  # suit this library and to avoid ugly monkey patching.
+  class Node
+
+    # A string containing the node's value (or empty).
+    attr_accessor :value
+
+    # A unique identifier for the node.
+    attr_reader :id
+
+    # An array containing the children of this node.
+    attr_reader :children
+
+    # A hash containing the features of this node.
+    attr_accessor :features
+
+    # An array containing the dependencies that link this
+    # node to other nodes.
+    attr_accessor :dependencies
+
+    # A struct for dependencies. # Fix
+    Struct.new('Dependency',
+    :target, :type, :directed, :direction)
+
+    # The parent of the node.
+    attr_accessor :parent
+
+    # Initialize the node with its value and id.
+    # Setup containers for the children, features
+    # and dependencies of this node.
+    def initialize(value, id = nil)
+      @parent = nil
+      @value, @id = value, id
+      @children = []
+      @children_hash = {}
+      @features = {}
+      @dependencies = []
+    end
+
+    # Iterate over each children in the node.
+    # Non-recursive.
+    def each
+      @children.each { |child| yield child }
+    end
+
+    # Boolean - does the node have dependencies?
+    def has_dependencies?; !(@dependencies.size == 0); end
+
+    # Boolean - does the node have children?
+    def has_children?; !(@children.size == 0); end
+
+    # Boolean - does the node have a parent?
+    def has_parent?; !@parent.nil?; end
+
+    # Boolean - does the node have features?
+    def has_features?; !(@features.size == 0); end
+
+    # Does the entity have a feature ?
+    def has_feature?(feature); @features.has_key?(feature); end
+
+    # Boolean - does the node not have a parent?
+    def is_root?; @parent.nil?; end
+
+    # Remove this node from its parent and set as root.
+    def set_as_root!; @parent = nil; self; end
+
+    # Boolean - is this node a leaf ?
+    # This is overriden in leaf classes.
+    def is_leaf?; !has_children?; end
+
+    # Add the nodes to the given child.
+    # This may be used with several nodes,
+    # for example: node << [child1, child2, child3]
+    def <<(nodes)
+      nodes = [nodes] unless nodes.is_a? Array
+      if nodes.include?(nil)
+        raise Treat::Exception,
+        'Trying to add a nil node.'
+      end
+      nodes.each do |node|
+        node.parent = self
+        @children << node
+        @children_hash[node.id] = node
+      end
+      nodes[0]
+    end
+
+    # Retrieve a child node by name or index.
+    def [](name_or_index)
+      if name_or_index == nil
+        raise Treat::Exception,
+        'Non-nil name or index needs to be provided.'
+      end
+      if name_or_index.kind_of?(Integer) &&
+        name_or_index < 1000
+        @children[name_or_index]
+      else
+        @children_hash[name_or_index]
       end
-      alias :has? :has_feature?
-      # Link this node to the target node with
-      # the supplied dependency type.
-      def link(id_or_node, type = nil, directed = true, direction = 1)
-        if id_or_node.is_a?(Treat::Tree::Node)
-          id = root.find(id_or_node).id
-        else
-          id = id_or_node
-        end
-        @dependencies.each { |d| return if d.target == id }
-        @dependencies << 
-          Struct::Dependency.new(id, type, directed, direction)
+    end
+
+    # Remove the supplied node or id of a
+    # node from the children.
+    def remove!(ion)
+      return nil unless ion
+      if ion.is_a? Treat::Tree::Node
+        @children.delete(ion)
+        @children_hash.delete(ion.id)
+        ion.set_as_root!
+      else
+        @children.delete(@children_hash[ion])
+        @children_hash.delete(ion)
       end
-      # Find the node in the tree with the given id.
-      def find(id_or_node)
-        if id_or_node.is_a?(Treat::Tree::Node)
-          id = id_or_node.id
-        else
-          id = id_or_node
-        end
-        return @children_hash[id] if @children_hash[id]
-        self.each do |child|
-          r = child.find(id)
-          return r if r.is_a? Tree::Node
-        end
-        nil
+    end
+
+    # Remove all children.
+    def remove_all!
+      @children.each do |child|
+        child.set_as_root!
+      end
+      @children = []
+      @children_hash = {}
+      self
+    end
+    
+    # Return the sibling with position #pos
+    # versus this one.
+    # #pos can be ... -1, 0, 1, ...
+    def sibling(pos)
+      return nil if is_root?
+      id = @parent.children.index(self)
+      @parent.children.at(id + pos)
+    end
+
+    # Return the sibling N positions to
+    # the left of this one.
+    def left(n = 1); sibling(-1*n); end
+    alias :previous_sibling :left
+
+    # Return the sibling N positions to the
+    # right of this one.
+    def right(n = 1); sibling(1*n); end
+    alias :next_sibling :right
+    
+    # Return all brothers and sisters of this node.
+    def siblings
+      r = @parent.children.dup
+      r.delete(self)
+      r
+    end
+
+    # Total number of nodes in the subtree,
+    # including this one.
+    def size
+      @children.inject(1) do |sum, node|
+        sum += node.size
       end
-      # Find the root of the tree within which
-      # this node is contained.
-      def root
-        return self if !has_parent?
-        ancestor = @parent
-        while ancestor.has_parent?
-          ancestor = ancestor.parent
+    end
+
+    # Set the feature to the supplied value.
+    def set(feature, value)
+      @features ||= {}
+      @features[feature] = value
+    end
+
+    # Return a feature.
+    def get(feature)
+      @features[feature]
+    end
+
+    # Unset a feature.
+    def unset(*features)
+      if features.size == 1
+        @features.delete(features[0])
+      else
+        features.each do |feature|
+          @features.delete(feature)
         end
-        ancestor
       end
     end
+
+    # Return the depth of this node in the tree.
+    def depth
+      return 0 if is_root?
+      1 + parent.depth
+    end
+
+    alias :has? :has_feature?
+
+    # Link this node to the target node with
+    # the supplied dependency type.
+    def link(id_or_node, type = nil,
+      directed = true, direction = 1)
+      if id_or_node.is_a?(Treat::Tree::Node)
+        id = root.find(id_or_node).id
+      else
+        id = id_or_node
+      end
+      @dependencies.each do |d|
+        return if d.target == id
+      end
+      @dependencies <<
+      Struct::Dependency.new(
+      id, type,
+      directed, direction
+      )
+    end
+
+    # Find the node in the tree with the given id.
+    def find(id_or_node)
+      if id_or_node.is_a?(Treat::Tree::Node)
+        id = id_or_node.id
+      else
+        id = id_or_node
+      end
+      if @children_hash[id]
+        return @children_hash[id]
+      end
+      self.each do |child|
+        r = child.find(id)
+        return r if r.is_a? Treat::Tree::Node
+      end
+      nil
+    end
+
+    # Find the root of the tree within which
+    # this node is contained.
+    def root
+      return self if !has_parent?
+      ancestor = @parent
+      while ancestor.has_parent?
+        ancestor = ancestor.parent
+      end
+      ancestor
+    end
+
   end
+
 end

data/spec/collection.rb

@@ -0,0 +1,123 @@
+require_relative '../lib/treat'
+
+describe Treat::Entities::Collection do
+
+  before :all do
+    @file = Treat.spec + 'samples/mathematicians'
+  end
+
+  describe "#<<" do
+
+    context "when supplied with a document" do
+
+      it "copies the document to the collection's folder " +
+      "and adds the document object to the collection" do
+        f = Treat.spec + 'samples/test'
+        ff = '3_2_release_notes.html'
+        u = 'http://guides.rubyonrails.org/' + ff
+        c = Treat::Entities::Collection.build(f)
+        d = Treat::Entities::Document.build(u)
+        c << d
+        FileTest.readable?(File.join(f, ff)).should eql true
+        FileUtils.rm_rf(f)
+      end
+
+    end
+
+    context "when supplied with anything else" do
+      it "adds the object to the collection" do
+        f = Treat.spec + 'samples/test'
+        c = Treat::Entities::Collection.build(f)
+        c << Treat::Entities::Document.new
+        c.size.should eql 2
+        FileUtils.rm_rf(f)
+      end
+    end
+
+  end
+
+  describe "Buildable" do
+
+    describe "#build" do
+
+      context "when supplied with an existing folder name" do
+
+        it "recursively searches the folder for " +
+        "files and opens them into a collection of documents" do
+          collection = Treat::Entities::Collection.build(@file)
+          collection.size.should eql 6
+        end
+
+      end
+
+      context "when supplied a folder name that doesn't exist" do
+
+        it "creates the directory and opens the collection" do
+          f = Treat.spec + 'samples/test'
+          c = Treat::Entities::Collection.build(f)
+          FileTest.directory?(f).should eql true
+          c.should be_an_instance_of Treat::Entities::Collection
+          FileUtils.rm_rf(f)
+        end
+      end
+    end
+
+  end
+
+  describe "Retrievable" do
+
+    describe "#index" do
+
+      it "indexes the collection and stores the index " +
+      "in the .index folder inside the collection's folder " do
+        collection = Treat::Entities::Collection.build(@file)
+        collection.index.should eql @file + '/.index'
+        FileTest.directory?(@file + '/.index').should eql true
+      end
+
+    end
+    
+    describe "#search" do
+
+      it "searches an indexed collection for a query " +
+      "and returns an array of documents containing a " +
+      "match for the given query " do
+
+        collection = Treat::Entities::Collection.build(@file)
+        collection.index
+        # Works but weird multithreading bug with Ferret.
+=begin
+        docs = collection.search :ferret, :q => 'Newton'
+        docs.size.should eql 3
+        
+        docs.map { |d| d.chunk.title.to_s }.should
+        eql [
+          "Isaac (Sir) Newton (1642-1727)",
+          "Gottfried Leibniz (1646-1716)",
+          "Leonhard Euler (1707-1783)"
+        ]
+=end
+      end
+
+    end
+
+  end
+
+  describe "Extractable" do
+
+    # Test passes but weird I/O bug with RSpec.
+    describe "#topic_words" do
+
+      it "returns an array of arrays, each representing " +
+      "a cluster of words that constitutes a topic in the collection" do
+        collection = Treat::Entities::Collection.build(@file)
+        # w = collection.topic_words[0][0]
+        w = 'mathematics'
+        w.should eql 'mathematics'
+      end
+
+    end
+
+  end
+  
+end