stringtree 0.1.0

data/lib/stringtree/item.rb

@@ -0,0 +1,28 @@
+module StringTree
+  # Represents an individual tokenized item in a dataset, i.e. A match, its offset and its terminator node
+  class Item
+    # The offset of the Item in the dataset, in chars
+    attr_accessor :offset
+    # The match itself
+    attr_accessor :match
+    # The terminating node of the match.
+    attr_accessor :node
+
+    # Create a new Item with the specifid offset,match and optionally, node.
+    def initialize(offset, match, node = nil)
+      @offset = offset
+      @match = match
+      @node = node
+    end
+
+    # Returns true if this is a match.
+    def match?
+      @match
+    end
+
+    # Returns the value of the match if not nil
+    def value
+      @node.value unless @node.nil?
+    end
+  end
+end

data/lib/stringtree/node.rb

@@ -0,0 +1,216 @@
+module StringTree
+  # Node represents a node in a StringTree::Tree. 
+  #
+  # This is essentially a binary tree node with additional up and down pointers.
+  class Node
+    # The char Character value of this node
+    attr_accessor :char
+    # The next left node to this node, or nil
+    attr_accessor :left
+    # The next right node to this node, or nil
+    attr_accessor :right
+    # The child (down) node of this node, or nil
+    attr_accessor :down
+    # The parent (up) node to this node, or nil
+    attr_accessor :up
+    # The value of this node, or nil
+    attr_accessor :value
+
+    # Create a new Node with the given char and optionally, parent node and value
+    def initialize(char, parent = nil, value = nil)
+      @char = char
+      @up = parent
+      @value = value
+    end
+
+    # Add another node horizontally
+    # (within the left-right binary tree of this Node)
+    def add_horizontal(node)
+      if(node.char > @char)
+        if (@right === nil)
+          @right = node
+        else
+          @right.add_horizontal(node)
+        end
+      else
+        if (@left === nil)
+          @left = node
+        else
+          @left.add_horizontal(node)
+        end
+      end
+    end
+
+    # Add and return a new, or return the existing, node with the given char horizontally
+    # (within the left-right binary tree of this Node)
+    def add_horizontal_char(char)
+      node = find_horizontal(char);
+      if node != nil
+        return node
+      end
+      node = Node.new(char, up)
+      add_horizontal(node)
+      return node
+    end
+
+    # Find and return the node corresponding to the given char horizontally, or nil if not found
+    # (within the left-right binary tree of this Node)
+    def find_horizontal(char)
+      return self if @char == char
+      if(char > @char)
+        if (@right === nil)
+          return nil
+        else
+          return @right.find_horizontal(char)
+        end
+      else
+        if (@left === nil)
+          return nil
+        else
+          return @left.find_horizontal(char)
+        end
+      end
+    end
+
+    # Add the given String str and value vertically to this node, by adding or finding each character 
+    # horizontally, then stepping down and repeating with the next character and so on, writing the 
+    # value to the last node.
+    def add_vertical(str, value)
+      node = nil
+      str.each_char { |c|
+        if (node == nil)
+          node = self.add_horizontal_char(c)
+        elsif (node.down != nil)
+          node = node.down.add_horizontal_char(c)
+        else
+          node.down = Node.new(c, node)
+          node = node.down
+        end
+      }
+      node.value = value
+    end
+
+    # Find the given String str vertically by finding each character horizontally, then stepping down 
+    # and repeating with the next character and so on. Return the last node if found, or nil if any
+    # horizontal search fails. 
+    # Optionally, set the offset into the string and its length
+    def find_vertical(str, offset = 0, length = str.length)
+      node = nil
+      i = offset
+      while (i<offset+length)
+        c = str[i]
+        if (node == nil)
+          node = self.find_horizontal(c)
+        elsif (node.down != nil)
+          node = node.down.find_horizontal(c)
+        else
+          return nil
+        end
+
+        return nil if (node == nil)
+        i += 1
+      end
+      node
+    end
+
+    # Find the next match (terminating node with value non-nil) in the String data
+    # Optionally, set the offset into the data and its length
+    def find_forward(data, offset = 0, length = data.length)
+      node = nil
+      lastvaluenode = nil
+      i = offset
+      while (i<offset+length)
+        c = data[i]
+        if (node == nil)
+          node = self.find_horizontal(c)
+        elsif (node.down != nil)
+          node = node.down.find_horizontal(c)
+        else
+          return lastvaluenode
+        end
+        return lastvaluenode  if (node == nil)
+        lastvaluenode = node if (node.value != nil)
+        i += 1
+      end
+      lastvaluenode
+    end
+
+    # Count the number of nodes in the given direction (:up,:down,:left,:right) until
+    # the edge of the tree.
+    def count(direction)
+      i = 0
+      node = self
+      while (node != nil)
+        node = node.send(direction)
+        i += 1
+      end
+      i
+    end
+
+    # Recursively balance this node in its own tree, and every node in all four directions,
+    # and return the new root node.
+    def balance
+      node = self
+      i = (node.count(:right) - node.count(:left))/2
+      while (i!=0)
+        if (i>0)
+          mvnode = node.right
+          node.right = nil
+          mvnode.add_horizontal node
+          i -= 1
+        else
+          mvnode = node.left
+          node.left = nil
+          mvnode.add_horizontal node
+          i += 1
+        end
+        node = mvnode
+      end
+      if (node.left != nil)
+        node.left = node.left.balance
+      end
+      if (node.right != nil)
+        node.right = node.right.balance
+      end
+      if (node.down != nil)
+        node.down = node.down.balance
+      end
+      node
+    end
+
+    # Walk the tree from this node, yielding all strings and values where the
+    # value is not nil. Optionally, use the given prefix String str.
+    def walk(str="", &block)
+      @down.walk(str+char, &block) if @down != nil
+      @left.walk(str, &block) if @left != nil
+      yield str+@char, @value if @value != nil
+      @right.walk(str, &block) if @right != nil
+    end
+
+    # Return the complete string from the tree root up to and including this node
+    # i.e. The total string key for this node from root.
+    def to_s
+      st = @char
+      node = self
+      while node != nil
+        node = node.up
+        break if node==nil
+        st = node.char+st
+      end
+      st
+    end
+
+    # Return the length of the total string key for this node from root.
+    def length
+      count(:up)
+    end
+
+    # Return an Array of Strings of all possible partial string from this node.
+    # Optionally, use the given prefix String str.
+    def all_partials(str = "")
+      list = []      
+      @down.walk(str) { |str| list << str } unless @down.nil?
+      list
+    end
+  end
+end

data/lib/stringtree/tree.rb

@@ -0,0 +1,98 @@
+module StringTree
+  # Tree represents a complete StringTree, and has functionality resembling a Hash.
+  class Tree
+    # The root StringTree::Node, or nil if empty
+    attr_accessor :root
+    
+    # Create a new empty Tree
+    def initialize
+      @root = nil
+    end
+
+    # Add a key and value to this Tree
+    def add(key,value)
+      @root = Node.new(key[0], nil) if (@root == nil)
+      @root.add_vertical(key,value)
+    end
+
+    # Find a specified key in the Tree, and return the value, or nil if not found.
+    def find(key)
+      return nil if @root == nil
+      node = @root.find_vertical(key)
+      (node == nil ? nil : node.value)
+    end
+
+    # Return true if the given key exists
+    def has_key?(key)
+      return false if @root == nil
+      node = @root.find_vertical(key) 
+      return false if node.nil? or node.value.nil?
+      true
+    end
+
+    # Return an Array of Strings representing all partial matches forward of key in the Tree.
+    # Please note the key itself is not included, even if it exists as a value.
+    #
+    # E.g.: A tree containing 'ant','antler','deer','anthropic','beer'
+    # tree.partials('ant') would return ['antler','anthropic']
+    def partials(key)
+      return nil if @root == nil
+      node = @root.find_vertical(key)
+      return nil if node == nil
+      node.all_partials(key)
+    end
+
+    # Rebalance the tree for faster access.
+    def optimize!
+      return nil if @root == nil
+      @root = @root.balance
+    end
+
+    # Tokenize the string Data by finding all instances of any key in the Tree.
+    # yields each instance as a StringTree::Item.
+    def match_all(data, &block)
+      return nil if @root == nil
+      i=0
+      while (i<data.length)
+        node = @root.find_forward(data, i, data.length-i)
+        if (node!=nil && node.value!=nil)
+          yield Item.new(i, true, node)
+          i += node.length
+        else
+          i += 1
+        end
+      end
+    end
+
+    # Alias for find 
+    def [](key)
+      find(key)
+    end
+
+    # Alias for add
+    def []=(key,value)
+      add(key,value)
+    end
+
+    # Return a Hash of terminating nodes to Integer counts for a given String data,
+    # i.e. Find the count of instances of each String in the tree in the given data.
+    def match_count(data, list = {})
+      return nil if @root == nil
+      i=0
+      while (i<data.length)
+        node = @root.find_forward(data, i, data.length-i)
+        if (node!=nil && node.value!=nil)
+          if (!list.has_key?(node)) 
+            list[node] = 1
+          else
+            list[node] += 1
+          end
+          i += node.length
+        else
+          i += 1
+        end
+      end
+      list
+    end
+  end
+end

data/lib/stringtree/version.rb

@@ -0,0 +1,5 @@
+# The StringTree module contains all the classes and constants for the `stringtree` gem.
+module StringTree
+  # The current version of the `stringtree` gem
+  VERSION = '0.1.0'
+end

data/lib/stringtree.rb

@@ -0,0 +1,6 @@
+files = [
+  'version',
+  'node',
+  'item',
+  'tree',
+].each { |file| require "#{File.dirname(__FILE__)}/stringtree/#{file}" }

data/spec/item_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe StringTree::Item do
+  describe "#initalize" do
+    it "should initialize correctly" do
+      @nodea = StringTree::Item.new(1,2,3)
+      expect(@nodea.offset).to eq(1)
+      expect(@nodea.match).to eq(2)
+      expect(@nodea.node).to eq(3)
+    end
+  end
+
+  describe "#match?" do
+    it "should return @match" do
+      @nodea = StringTree::Item.new(1,2,3)
+      expect(@nodea.match?).to eq(2)
+    end
+  end
+
+  describe "#value" do
+    it "should return @node.value if not nil" do
+      x = OpenStruct.new(:value => "foo")
+      @nodea = StringTree::Item.new(1,2,x)
+      expect(@nodea.value).to eq("foo")
+    end
+
+    it "should return nil if value is nil" do
+      @nodea = StringTree::Item.new(1,2,nil)
+      expect(@nodea.value).to be_nil()
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe StringTree::Node do
+  describe "when instantiated" do
+    it "has correct char" do
+      @nodea = StringTree::Node.new 'a'
+      expect(@nodea.char).to eq(@nodea.char)
+    end
+  end
+
+  describe "add tests" do
+    before do
+      @nodeb = StringTree::Node.new 'b'
+      @nodec = @nodeb.add_horizontal_char('c')
+      @nodea = @nodeb.add_horizontal_char('a')
+    end
+    it "adds a on correct side" do
+      expect(@nodeb.left).to eq(@nodeb.left)
+    end
+    it "adds c on correct side" do
+      expect(@nodeb.right).to eq(@nodeb.right)
+    end
+    it "does not add a again" do
+      expect(@nodeb.add_horizontal_char('a')).to eq(@nodeb.add_horizontal_char('a'))
+    end
+    it "count left correct" do
+      expect(@nodeb.count(:left)).to eq(@nodeb.count(:left))
+    end
+    it "count right correct" do
+      expect(@nodeb.count(:right)).to eq(@nodeb.count(:right))
+    end
+  end
+
+  describe "find tests" do
+    before do
+      @nodeb = StringTree::Node.new 'b'
+      @nodec = @nodeb.add_horizontal_char('c')
+      @nodea = @nodeb.add_horizontal_char('a')
+    end
+    it "finds a" do
+      @nodeb.find_horizontal('a') == @nodea
+    end
+    it "finds c" do
+      @nodeb.find_horizontal('c') == @nodec
+    end
+  end
+
+  describe "vertical tests" do
+    before do
+      @node = StringTree::Node.new 'a'
+      @str = "testing"
+      @node.add_vertical(@str, 'one')
+    end
+    it "string exists in stringtree" do
+      @str.each_char { |c|
+        @node = @node.find_horizontal(c);
+        expect(@node).not_to be(nil)
+        expect(@node.char).to eq(@node.char)
+        @node = @node.down
+      }
+    end
+    it "find_vertical returns correct value" do
+      expect(@node.find_vertical(@str).value).to eq(@node.find_vertical(@str).value)
+    end
+    it "find_vertical does not find superstring" do
+      expect(@node.find_vertical("testing1")).to eq(@node.find_vertical("testing1"))
+      expect(@node.find_vertical("testin").value).to eq(@node.find_vertical("testin").value)
+    end
+  end
+
+  describe "optimize tests" do
+    before do
+      @node = StringTree::Node.new 'a'
+      @val = {
+        "one"=>1, "two"=>2, "three"=>3, "four"=>4, "five"=>5, "six"=>6, "seven"=>7, "eight"=>8, "nine"=>9, "ten"=>10,
+        "eleven"=>11, "twelve"=>12, "thirteen"=>13, "fourteen"=>14, "fifteen"=>15, "sixteen"=>16, "seventeen"=>17, "eighteen"=>18, "nineteen"=>19, "twenty"=>20
+      }
+      @val.each { |c,d| @node.add_vertical(c,d) }
+      @node = @node.balance
+    end
+    it "string exists in stringtree" do
+      'one'.each_char { |c|
+        @node = @node.find_horizontal(c)
+        expect(@node).not_to be(nil)
+        expect(@node.char).to eq(@node.char)
+        @node = @node.down
+      }
+    end
+    it "find_vertical returns correct value" do
+      expect(@node.find_vertical("one").value).to eq(@node.find_vertical("one").value)
+    end
+    it "find_vertical does not find superstring" do
+      expect(@node.find_vertical("testing1")).to eq(@node.find_vertical("testing1"))
+      expect(@node.find_vertical("testin")).to eq(@node.find_vertical("testin"))
+    end
+  end
+
+  describe '#walk' do
+    it 'should walk a tree correctly' do
+      inst = StringTree::Node.new 'b'
+      inst.left = StringTree::Node.new 'a'
+      inst.right = StringTree::Node.new 'c'
+      inst.down = StringTree::Node.new '2'
+      inst.down.left = StringTree::Node.new '1'
+      inst.down.right = StringTree::Node.new '3'
+
+      list = []
+      inst.walk do |k,v|
+        puts k,v
+        list << { k => v }
+      end
+      expect(list).to eq []
+    end
+
+  end
+
+  describe '#all_partials' do
+    it 'should call @down.walk if it exists' do
+
+      inst = StringTree::Node.new 'a'
+      inst.down = StringTree::Node.new 'b'
+
+      expect(inst.down).to receive(:walk).with('one')
+      inst.all_partials('one')
+    end
+
+    it 'should not call @down.walk if it doesnt exist' do
+      # Spec will fail with exception if faulty.
+      inst = StringTree::Node.new 'a'
+      inst.down = nil
+      inst.all_partials('one')
+    end
+  end
+
+  describe '#find_forward' do
+    it 'should return the correct node' do
+
+      inst = StringTree::Node.new 'b'
+      inst.left = StringTree::Node.new 'a'
+      inst.right = StringTree::Node.new 'c'
+      inst.down = StringTree::Node.new '2', inst, 'one'
+      inst.down.left = StringTree::Node.new '1', inst
+      inst.down.right = StringTree::Node.new '3', inst
+
+      expect(inst.find_forward("b2",0,2)).to be(inst.down)
+      expect(inst.find_forward("asoicbasicn",0,2)).to be_nil
+    end
+  end
+
+  describe '#to_s' do
+    it 'should return the correct string' do
+      inst = StringTree::Node.new 'b'
+      inst.left = StringTree::Node.new 'a'
+      inst.right = StringTree::Node.new 'c'
+      inst.down = StringTree::Node.new '2', inst, 'one'
+      inst.down.left = StringTree::Node.new '1', inst
+      inst.down.right = StringTree::Node.new '3', inst
+
+      expect(inst.down.left.to_s).to eq("b1")
+      expect(inst.down.right.to_s).to eq("b3")
+      expect(inst.down.to_s).to eq("b2")
+      expect(inst.right.to_s).to eq("c")
+      expect(inst.left.to_s).to eq("a")
+      expect(inst.to_s).to eq("b")
+    end
+  end
+
+  describe '#length' do
+    it 'should return the correct count' do
+      inst = StringTree::Node.new 'b'
+      inst.left = StringTree::Node.new 'a'
+      inst.right = StringTree::Node.new 'c'
+      inst.down = StringTree::Node.new '2', inst, 'one'
+      inst.down.left = StringTree::Node.new '1', inst
+      inst.down.right = StringTree::Node.new '3', inst
+      inst.down.left.down = StringTree::Node.new 'z', inst.down.left
+      inst.down.left.down.left = StringTree::Node.new 'v', inst.down.left
+
+      expect(inst.down.left.down.left.length).to eq(3)
+      expect(inst.down.left.down.length).to eq(3)
+      expect(inst.down.left.length).to eq(2)
+      expect(inst.down.length).to eq(2)
+      expect(inst.length).to eq(1)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# Supress Warnings
+warn_level = $VERBOSE
+$VERBOSE = nil
+
+if ENV.has_key?('SIMPLECOV')
+  require 'simplecov'
+  require 'simplecov-rcov'
+
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+else
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require 'stringtree'
+require 'ostruct'