rogdl 0.1.0

data/lib/rogdl.rb

@@ -0,0 +1,14 @@
+require 'lib/node'
+require 'lib/parser'
+require 'lib/schema'
+require 'lib/writer'
+require 'lib/nil'
+require 'lib/string'
+require 'lib/array'
+require 'lib/hash'
+require 'lib/fixnum'
+require 'lib/symbol'
+
+module Rogdl
+  VERSION = '0.1.0'
+end

data/lib/schema.rb

@@ -0,0 +1,140 @@
+module Rogdl
+  class Schema
+    
+    ExactlyOne = '{1}'
+    OneOrMore = '{1..n}'
+    ZeroOrOne = '{0..1}'
+    ZeroOrMore = '{0..n}'
+    
+    Rules = [ExactlyOne, OneOrMore, ZeroOrOne, ZeroOrMore]
+
+  
+    
+    def initialize(aSchema)
+      @schema = aSchema
+    end
+    
+    def validate(aNode)
+      messages = []
+      if @schema.gname != aNode.gname
+        return ["Expecting '#{@schema.gname}', but found '#{aNode.gname}'"]
+      end
+      
+      val(aNode, @schema, messages)
+      return messages
+    end
+
+    private
+    def val(aNode, schemaNode, messages)
+    
+      schemaNode.each do |schemaChild|
+        
+        if !Rules.include?(schemaChild.gname)
+#          puts schemaChild.gname + schemaChild.gvalue
+
+          if schemaChild.gvalue == OneOrMore
+            if aNode.find_all_named(schemaChild.gname).length < 1
+              messages << "Found node named '#{aNode.gname}' that should have one or more children named: '#{schemaChild.gname}'"
+            end
+          elsif schemaChild.gvalue == ExactlyOne
+            if aNode.find_all_named(schemaChild.gname).length != 1
+              messages << "Found node named '#{aNode.gname}' that should have exactly one child named: '#{schemaChild.gname}'"
+            end
+          elsif schemaChild.gvalue == ZeroOrOne
+            if aNode.find_all_named(schemaChild.gname).length > 1
+              messages << "Found node named '#{aNode.gname}' that should have zero or one child named: '#{schemaChild.gname}'"
+            end
+          elsif schemaChild.gvalue == ZeroOrMore
+            # purposely left blank
+          else
+            throw "Invalid rule: ''#{schemaChild.gvalue}'"
+          end
+          
+          
+          aNode.find_all_named(schemaChild.gname).each do |aNodeChild|
+            val(aNodeChild, schemaChild, messages)
+          end
+          
+        end
+      end
+      
+    end # val
+
+#    def val(aNode, schemaNode, messages)
+#    
+#      if schemaNode.gname != aNode.gname
+#        messages << "Expecting '#{schemaNode.gname}', but found '#{aNode.gname}'"
+#        return
+#      end
+#    
+#      puts schemaNode.gvalue
+#      if schemaNode.gvalue == ExactlyOne
+#        if !aNode.gparent.nil?
+#          siblings = aNode.gparent.find_all_named(schemaNode.gname)
+#          if siblings.length != 1
+#            messages << "Found node named '#{gparent.gname}' that should have exactly one child named: '#{aNode.gname}'"
+#          end
+#        end
+#      elsif schemaNode.gvalue == OneOrMore
+#        if !aNode.gparent.nil?
+#          siblings = aNode.gparent.find_all_named(schemaNode.gname)
+#          if siblings.length < 1
+#            messages << "Found node named '#{gparent.gname}' that should have one or more children named: '#{aNode.gname}'"
+#          end
+#        end
+#      end
+#
+#      schemaNode.each do |schemaChild|
+#        
+#        if !Rules.include?(schemaChild.gname)
+#        puts schemaChild.gname
+#          aNode.find_all_named(schemaChild.gname).each do |aNodeChild|
+#            val(aNodeChild, schemaChild, messages)
+#          end
+#        end
+#      end
+#      
+#    end # val
+    
+#    def val(aNode, messages)
+#      schemaNode = @schema[aNode.gname]
+#      
+#      
+#      
+#      return if schemaNode.nil?
+#      schemaNode.entries.each do |rule|
+#        if rule.gname == ExactlyOne
+#          rule.entries.each do |expected|
+#            if aNode.find_all_named(expected.gname).length != 1
+#              messages << "Found node named '#{aNode.gname}' that should have exactly one child named: '#{expected.gname}'"
+#            end
+#          end
+#        elsif rule.gname == OneOrMore
+#          rule.entries.each do |expected|
+#            if aNode.find_all_named(expected.gname).length == 0
+#              messages << "Found node named '#{aNode.gname}' missing expected child named: '#{expected.gname}'"
+#            end
+#          end
+#        elsif rule.gname == ZeroOrOne
+#          rule.entries.each do |expected|
+#            if aNode.find_all_named(expected.gname).length > 1
+#              messages << "Found node named '#{aNode.gname}' having too many children named: '#{expected.gname}'"
+#            end
+#          end
+#        elsif rule.gname == ZeroOrMore        
+#          #purposely left blank
+#        elsif rule.gname == ExactlyOneChild
+#          if aNode.glength != 1
+#            messages << "Found node named '#{aNode.gname}' that should have exactly one child"
+#          end
+#        end
+#
+#      end # schemaNode.entries.each
+#      
+#      aNode.entries.each {|child| val(child, messages)}      
+#      
+#    end # val
+    
+    
+  end
+end

data/lib/string.rb

@@ -0,0 +1,38 @@
+require 'lib/rogdl'
+
+class String
+
+  def camel_case
+    str = upper_camel_case
+    return str[0,1].downcase + str[1, str.length]
+  end
+  
+  def upper_camel_case
+    str = self
+    str.gsub!(/[^a-zA-Z_\- ]/," ")
+    str = " " + str.split.join(" ")
+    str.gsub!(/ (.)/) { $1.upcase }
+    
+    str.gsub!(/[^a-zA-Z_\- ]/,"_")
+    str = "_" + str.split.join("_")
+    str.gsub!(/_(.)/) { $1.upcase }
+    
+    return str
+  end
+  
+  def pluralize
+#  TODO: replace with call to Inflector.pluralize
+    return self + 's' if self[length-1, length] != 's'
+    return self + 'es' if self[length-1, length] == 's'
+  end
+  
+  def to_b
+    self == 'true'
+  end
+  
+  def to_n
+    return Rogdl::Node.new(self)
+  end
+
+
+end

data/lib/symbol.rb

@@ -0,0 +1,9 @@
+require 'lib/rogdl'
+
+class Symbol
+
+  def to_n
+    return Rogdl::Node.new(":#{self.to_s}")
+  end
+
+end

data/lib/writer.rb

@@ -0,0 +1,117 @@
+require 'lib/node'
+require 'erb'
+require 'find'
+
+module Rogdl
+
+  class Writer
+  
+    
+    def templates
+      @templates ||= {}
+    end
+    
+    def write(nodeArray)
+      nodes = to_node_array(nodeArray)
+      a = []
+      nodes.each do |node|
+        raise "Writer::write: cannot find template" unless !templates[node.gname].nil?
+        node.assign(self)
+        a << node.render
+      end
+      return a
+    end
+    
+    def write_to_files(nodeArray, namingProc)
+      nodes = to_node_array(nodeArray)
+      output_array = write(nodes)
+      throw 'Illegal state: lengths do not match' if output_array.length != nodes.length
+      
+      0..output_array.length.times do |index|
+        filename = namingProc.call(nodes[index])
+        f = File.new(filename, 'w+')
+        f << output_array[index]
+        f.close
+      end
+      
+    end
+    
+    def load_templates(dir)
+      excludes = ["CVS",".svn"]
+      Find.find(dir) do |path|
+        if FileTest.directory?(path)
+          if excludes.include?(File.basename(path))
+            Find.prune       # Don't look any further into this directory.
+          else
+            next
+          end
+        end
+
+        if File.extname(path) == '.rhtml'
+          file = File.new(path)
+          s = ''
+          file.each_line {|line| s << line }
+          templates[File.basename(path).split('.').first] = s
+        end
+      end
+      return self
+    end # load_templates
+    
+    private
+    def to_node_array(node_or_array)
+      if node_or_array.is_a?(Node)
+        return [node_or_array]
+      elsif node_or_array.is_a?(Array) && node_or_array.all? {|node| node.is_a?(Node)}
+        return node_or_array
+      else
+        raise "nodes must be a Node or an Array of Node"
+      end
+    end
+
+  
+  end
+  
+  class Node
+
+    def assign(pwriter)
+      @@writer = pwriter
+    end
+    
+    def render(template_name=gname)
+      template = @@writer.templates[template_name]
+      throw "no template defined for #{template_name}" if template.nil?
+      return ERB.new(template).result(self.context)
+    end
+    
+    def render_child_named(aName)
+      return self[aName].render
+    end
+
+    def render_children
+      s = ""
+      self.each {|child| s << child.render}
+      return s
+    end
+
+    def render_children_named(aName)
+      if aName.is_a?(String)
+        s = ""
+        self.find_all_named(aName).each {|child| s << child.render}
+        return s
+      elsif aName.is_a?(Array)
+        s = ""
+        self.each {|child| s << child.render if aName.include?(child.gname)}
+        return s
+      else
+        throw 'aName must be a String or Array'
+      end
+    end
+
+    def context
+      binding
+    end
+    
+  end
+
+  
+end

data/test/test_array.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'lib/rogdl'
+
+class TestArray < Test::Unit::TestCase
+  include Rogdl
+
+  def test_empty
+    assert_equal nil, [].to_n
+  end
+  
+  def test_one
+    assert_equal 'a', ['a'].to_n.gname
+  end
+  
+  def test_two
+    assert_equal 'a', ['a','b'].to_n.gname
+    assert_equal 'b', ['a','b'].to_n.b.gname
+  end
+  
+  def test_nest
+    assert_equal 'a', ['a',['b']].to_n.gname
+    assert_equal 'b', ['a',['b']].to_n.b.gname
+    
+    assert_equal 'c', ['a',['b','c']].to_n.b.c.gname
+    assert_equal 'c', ['a',['b','c']].to_n.b.gvalue
+  end
+  
+  
+  
+end

data/test/test_fixnum.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'lib/rogdl'
+
+class TestFixnum < Test::Unit::TestCase
+  include Rogdl
+
+  def test_one
+    assert_equal '1', 1.to_n.gname
+  end
+  
+  
+  
+end

data/test/test_hash.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require 'lib/rogdl'
+
+class TestHash < Test::Unit::TestCase
+  include Rogdl
+
+  def test_empty
+    assert_equal nil, {}.to_n
+  end
+  
+  def test_one
+    assert_equal 'a', {'a'=>'b'}.to_n.gname
+    assert_equal 'b', {'a'=>'b'}.to_n.b.gname
+  end
+  
+  
+  
+  
+end

data/test/test_nil.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'lib/rogdl'
+
+class TestNil < Test::Unit::TestCase
+  include Rogdl
+
+  def test_gvalue
+    assert_equal nil, nil.gvalue
+  end
+
+  def test_to_b
+    assert_equal false, nil.to_b
+  end
+
+  def test_to_n
+    assert_equal nil, nil.to_n
+  end
+  
+  def test_find_all_named
+    assert_equal [], nil.find_all_named('anything')
+  end
+  
+  def test_gkids
+    assert_equal [], nil.gkids('anything')
+  end
+  
+  
+  
+  
+end

data/test/test_node.rb

@@ -0,0 +1,279 @@
+require 'test/unit'
+require 'lib/rogdl'
+
+class TestNode < Test::Unit::TestCase
+  include Rogdl
+
+  def test_initialize
+    parent = Node.new("parent")
+    assert_equal parent, parent
+    assert_equal "parent", parent.gname
+    assert_equal [], parent.entries
+    
+    assert_equal "child", Node.new("parent").add("child")[0].gname
+  end
+
+  def test_add
+    parent = Node.new("parent")
+    assert_equal true, parent.empty?
+    child = Node.new("child")
+    parent.add child
+    assert_equal "child", parent[0].gname
+    assert_equal "child", parent["child"].gname
+    assert_equal "parent", child.gparent.gname
+    
+    parent.add(Node.new("child"))
+    assert_equal "child", parent["child"].gname
+    assert_equal "child", parent.entries[0].gname
+    assert_equal "child", parent.entries[1].gname
+    
+    parent.add(Node.new("sibling"))
+    assert_equal "sibling", parent.entries[2].gname
+  end
+
+  def test_add_string
+    parent = Node.new("parent")
+
+    parent.add('child').add('child')
+    assert_equal "child", parent[0].gname
+    assert_equal "child", parent[1].gname
+  end
+  
+  def test_assign
+    parent = Node.new("parent")
+    parent['child'] = 'c1'
+    assert_equal 'child', parent.child.gname
+    assert_equal 'c1', parent.child.gval
+    assert_equal 'c1', parent['child'].gval
+    
+    parent['child'] = 'c2'
+    assert_equal 'child', parent.child.gname
+    assert_equal 'c1', parent.child.gval
+    assert_equal 'c1', parent['child'].gval
+    
+    assert_equal 2, parent.childzz.length
+    assert_equal 'c2', parent[1].gval
+    
+    assert_equal 'c3', (parent['child']= 'c3')
+  end
+
+  def test_find_all_named
+    parent = Node.new("parent")
+    assert_equal [], parent.find_all_named("child")
+
+    parent.add Node.new("child")
+    assert_equal ["child"], parent.find_all_named("child").collect {|node| node.gname}
+    assert_equal ["child"], parent.find_all_named(["child"]).collect {|node| node.gname}
+    
+    parent.add Node.new("sibling")
+    assert_equal ["child"], parent.find_all_named("child").collect {|node| node.gname}
+    assert_equal ["child", "sibling"], parent.find_all_named(["child", "sibling"]).collect {|node| node.gname}
+    
+    parent.add Node.new("child")
+    assert_equal ["child", "child"], parent.find_all_named("child").collect {|node| node.gname}
+
+  end
+
+  def test_gkids
+    # gkids is an alias for find_all_named
+    parent = Node.new("parent")
+    parent.add Node.new("child")
+    parent.add Node.new("child")
+    assert_equal ["child", "child"], parent.gkids('child').collect {|node| node.gname}
+  end
+
+  def test_empty?
+    parent = Node.new("parent")
+    assert_equal true, parent.empty?
+    
+    parent.add Node.new("sibling")
+    assert_equal false, parent.empty? 
+  end
+
+  def test_brackets
+    parent = Node.new("parent")
+    assert_equal nil, parent["child"]
+    
+    child = Node.new("child")
+    parent.add child
+    assert_equal "child", parent["child"].gname
+    assert_equal "child", parent[0].gname
+  end
+
+  def test_method_missing
+    parent = Node.new("parent")
+    
+    child = Node.new("child")
+    parent.add child
+    assert_equal "child", parent.child.gname
+    assert_equal "child", parent[0].gname
+  end
+
+  def test_methodzz_missing
+    parent = Node.new("parent")
+    assert_equal [], parent.childzz
+    
+    parent.add('child')
+    assert_equal 'child', parent.childzz[0].gname
+    assert_equal 1, parent.childzz.length
+    
+    parent.add('child')
+    assert_equal 'child', parent.childzz[0].gname
+    assert_equal 'child', parent.childzz[1].gname
+    assert_equal 2, parent.childzz.length
+    
+    parent.add('childzz')
+    assert_equal 'childzz', parent.childzz.gname
+    assert_equal 'childzz', parent.childzzzz[0].gname
+  end
+
+  def test_gvalue
+    parent = Node.new("parent")
+    assert_equal nil, parent.gvalue
+    
+    child = Node.new("child")
+    parent.add child
+    assert_equal "child", parent.gvalue
+
+    parent.add Node.new("sibling")
+    assert_equal "child", parent.gvalue
+  end
+
+  def test_gval
+    # gval is an alias for gvalue
+    parent = Node.new("parent")
+    assert_equal nil, parent.gval
+    
+    child = Node.new("child")
+    parent.add child
+    assert_equal "child", parent.gval
+
+    parent.add Node.new("sibling")
+    assert_equal "child", parent.gval
+  end
+
+  def test_gfirst
+    parent = Node.new("parent")
+    
+    child = Node.new("child")
+    parent.add child
+    assert_equal "child", parent.gfirst.gname
+  end
+
+
+
+  def test_comparable
+    assert_equal 0, Node.new("a") <=> Node.new("a")  
+    assert_equal false, Node.new("a") > Node.new("b")  
+    assert_equal true, Node.new("a") < Node.new("b")  
+  end
+  
+  def test_to_xml
+    parent = Node.new("parent")
+    child = Node.new("child")
+    sibling = Node.new("sibling")
+    
+    assert_equal "<parent/>", parent.to_xml
+    
+    parent.add  child
+    assert_equal "<parent>child</parent>", parent.to_xml
+    
+    parent.add sibling
+    assert_equal "<parent><child/><sibling/></parent>", parent.to_xml
+    
+    child.add Node.new("grandchild")
+    assert_equal "<parent><child>grandchild</child><sibling/></parent>", parent.to_xml
+    
+    parent.add('child')
+    assert_equal "<parent><child>grandchild</child><sibling/><child/></parent>", parent.to_xml
+    
+  end
+  
+  def test_eql?
+    a =  Node.new('a')
+    assert_equal true, a.eql?(Node.new('a'))
+    a.add('b')
+    assert_equal false, a.eql?(Node.new('a'))
+    
+    assert_equal true, a.eql?(Node.new('a').add('b'))
+    assert_equal false, a.eql?(Node.new('a').add('b').add('c'))
+  end
+
+  def test_equal_equal
+    a =  Node.new('a')
+    assert_equal true, a == Node.new('a')
+    a.add('b')
+    assert_equal false, a == Node.new('a')
+    
+    assert_equal true, a == Node.new('a').add('b')
+    assert_equal false, a == Node.new('a').add('b').add('c')
+  end
+
+  def test_flatten
+    
+    assert_equal ['a'], Node.new('a').flatten.collect {|n| n.gname}
+    assert_equal ['a', 'b'], Node.new('a').add('b').flatten.collect {|n| n.gname}
+    assert_equal ['a', 'b', 'c'], Node.new('a').add('b').add('c').flatten.collect {|n| n.gname}
+    a =  Node.new('a')
+    a.add('b')
+    a.add('c')
+    assert_equal ['a', 'b', 'c'], a.flatten.collect {|n| n.gname}
+  end
+  
+  def test_subs
+    a = Node.new('a')
+    a.add(':hi')
+    a.subs(:hi, 'hello')
+    assert_equal 'hello', a.gvalue
+    
+    b = Node.new('b')
+    b.add(':hi')
+
+    # subs are to be at class level
+    assert_equal 'hello', b.gvalue
+    
+  end
+  
+  def test_add_others
+    a = Node.new('a')
+    
+    a.add(['b'])
+    a.add(3)
+    a.add({'d'=>'e'})
+    a.add('f')
+    a.add(:g)
+    
+    assert_equal 'b', a.b.gname
+    assert_equal 'b', a[0].gname
+    assert_equal 'a', a[0].gparent.gname
+    
+    assert_equal '3', a['3'].gname
+    assert_equal '3', a[1].gname
+    assert_equal 'a', a[1].gparent.gname
+    
+    assert_equal 'd', a.d.gname
+    assert_equal 'd', a[2].gname
+    assert_equal 'a', a[2].gparent.gname
+
+    assert_equal 'f', a.f.gname
+    assert_equal 'f', a[3].gname
+    assert_equal 'a', a[3].gparent.gname
+    
+    assert_equal ':g', a[':g'].gname
+    assert_equal ':g', a[4].gname
+    assert_equal 'a', a[4].gparent.gname
+
+  end
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+end