rogdl 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1.0 / 2007-08-20
+
+* 1 major enhancement
+  * Birthday!
+

data/README.txt

@@ -0,0 +1,51 @@
+rogdl
+    by Ben Hidalgo
+    http://rogdl.rubyforge.org/
+
+== DESCRIPTION:
+  
+Rogdl is designed to make using the Ordered Graph Data Language (OGDL) simple and easy within Ruby. It contains a parser, some utilities and classes to support OGDL files.
+
+== FEATURES/PROBLEMS:
+  
+OGDL Parsing.  A bridge to ERB.  XML file generation.  Schema definition and validation of OGDL documents.  Fully OGDL syntax not yet supported (but most is.)  Simple OGDL writer not yet written (haven't needed it yet).
+
+== SYNOPSIS:
+
+clouds = Parser.parse_file("./rspec/clouds.ogdl")
+families = clouds.find_all_named('family')
+writer = Writer.new.load_templates('./rspec')
+writer.write_to_files(families, proc {|family| "./rspec/samples/html/#{family.name.gvalue}.htm"})
+
+== REQUIREMENTS:
+
+erb
+
+== INSTALL:
+
+sudo gem install rogdl
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/array.rb

@@ -0,0 +1,18 @@
+require 'lib/rogdl'
+
+class Array
+
+  
+  def to_n
+    first = nil
+    self.entries.each do |entry|
+      if first.nil?
+        first = entry.to_n 
+      else
+        first.add(entry.to_n)
+      end
+    end
+    return first
+  end
+
+end

data/lib/fixnum.rb

@@ -0,0 +1,10 @@
+require 'lib/rogdl'
+
+class Fixnum
+
+  
+  def to_n
+    return Rogdl::Node.new(self.to_s)
+  end
+
+end

data/lib/hash.rb

@@ -0,0 +1,10 @@
+require 'lib/rogdl'
+
+class Hash
+
+  
+  def to_n
+    return self.to_a.to_n
+  end
+
+end

data/lib/nil.rb

@@ -0,0 +1,21 @@
+class NilClass
+
+  def gvalue
+    nil
+  end
+  
+  def to_b
+    false
+  end
+  
+  def to_n
+    nil
+  end
+  
+  def find_all_named(aName)
+    []
+  end
+  alias gkids find_all_named
+
+  
+end

data/lib/node.rb

@@ -0,0 +1,139 @@
+module Rogdl
+  class Node
+    include Enumerable
+    include Comparable
+    
+    attr_accessor :gname, :gparent
+    
+    def initialize(aName)
+      self.gname = aName
+    end
+    
+    def subs(key,value)
+      @@subs ||= {}
+      @@subs[key] = value
+    end
+    
+    def each
+      children.each {|element| yield(element)}
+    end
+    
+    def empty?
+      children.empty?
+    end
+    
+    def glength
+      children.length
+    end
+    
+    def gvalue
+      if empty?
+        return nil
+      else
+        val = gfirst.gname
+        return val unless val[0,1] == ':'
+        return @@subs[val[1, val.length].to_sym]
+      end
+    end
+    alias gval gvalue
+
+    def gfirst
+      return children.first      
+    end
+    
+    
+    def [](aName)
+      if aName.is_a?(String)
+        children.each do |node|
+          return node if node.gname == aName
+        end
+        return nil
+      elsif aName.is_a?(Fixnum)
+        return children[aName]
+      else
+        throw "aName must be a String or Fixnum"
+      end
+    end
+
+    def []=(arg1, arg2)
+      a1 = arg1.to_n
+      a1.add arg2.to_n
+      add(a1)
+    end
+
+    def method_missing(keyword, *args)
+      word = keyword.to_s
+      if word.reverse[0,2] == 'zz'
+        return self["#{keyword}"] unless self["#{keyword}"].nil?
+        return find_all_named(word[0, word.length-2])
+      else
+        return self["#{keyword}"]
+      end
+      
+    end
+    
+    def find_all_named(aName)
+      if aName.is_a?(String)
+        find_all {|node| node.gname == aName}
+      elsif aName.is_a?(Array)
+        find_all {|node| aName.include?(node.gname)}
+      else
+        throw 'aName must be a String or Array'
+      end
+      
+    end
+    alias gkids find_all_named
+
+    def <=>(anOther)
+      self.gname <=> anOther.gname
+    end
+    
+    def add(aNode)
+      node = aNode.to_n
+      children << node
+      node.gparent = self
+      return self
+    end
+    
+    def to_n
+      self
+    end
+
+    def to_xml
+      return "<#{@gname}/>" if empty?
+      s = "<#{@gname}>"
+      if glength == 1 && gfirst.glength == 0
+        s += gvalue
+      else
+        children.each {|node| s += node.to_xml}
+      end
+      s += "</#{@gname}>"
+      return s
+    end
+    
+    
+    
+    def eql?(bNode)
+      return self.flatten.collect {|n| n.gname} == bNode.flatten.collect {|n| n.gname}
+    end
+    
+    def ==(bNode)
+      return false if bNode.nil?
+      return self.eql?(bNode)
+    end
+    
+    def flatten
+      me = []
+      me << self
+      self.each {|n| me << n.flatten}
+      return me.flatten
+    end
+    
+    private
+    
+    def children
+      @children ||= []
+    end
+
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,398 @@
+require 'lib/node'
+module Rogdl
+
+  
+    InLine = :in_line
+    InPhrase = :in_phrase
+    InClause = :in_clause
+    InSQString = :in_sq_string
+    InDQString = :in_dq_string
+    InString = :in_string
+    InEscape = :in_escape
+    InWhitespace = :in_whitespace
+    InComment = :in_comment
+    Indent = :indent
+    
+    SchemaString = '#schema://'
+  
+    class Parser
+      attr_accessor :state, :spaces, :lines, :prev_state, :escape, :indenting, :line_count
+      
+      
+      
+      
+      def initialize
+        @spaces = 0
+        @lines = [[]]
+        @prev_state = nil
+        @escape = false
+        @state = InLine
+        @indenting = true
+        @line_count = 0
+      end
+      
+      def Parser.parse_file(filename)
+        file = File.new(filename)
+        contents = ""
+        file.each_byte do |ch|
+          contents << ch
+        end
+        first_line = contents.split("\n").first
+        schema = nil
+        if first_line[0, SchemaString.length] == SchemaString
+          schema = Schema.new(Parser.parse_file(first_line[SchemaString.length, first_line.length]))
+        end
+        node = Parser.parse(contents)
+        if !schema.nil?
+          messages = schema.validate(node);
+          if messages.length > 0 
+            puts filename + ' does not match the supplied schema'
+            puts messages
+          end
+        end
+        return node
+      end
+      
+      def Parser.parse(text)
+        p = Parser.new
+        p.translate(text)
+        return p.convert
+      end
+      
+      def append(char)
+        @lines.last.last << char
+        @indenting = false
+      end
+      
+      def add_line
+        @lines << []
+        @indenting = true
+      end
+      
+      def indent
+        @lines.last << nil
+      end
+      
+      def to_s
+        @lines.to_s
+      end
+      
+      def changeto(state)
+        @state = state
+      end
+      
+      def complain(message)
+        raise message + "  line count: #{@line_count}"
+      end
+      
+      def translate(string)
+        string.length.times {|i| read(string[i,1])}
+      end
+      
+      def capture(state)
+        @prev_state = state
+      end
+      
+#      def end_string
+#        @lines.last << ''
+#      end
+      
+      def begin_string
+        @lines.last << ''
+      end
+
+      
+      def read(char)
+        case
+          when self.state == InLine
+            read_line(char)
+            
+          when self.state == InString
+            read_string(char)
+            
+          when self.state == InSQString
+            read_sq_string(char)
+
+          when self.state == InDQString
+            read_dq_string(char)
+
+          when self.state == InPhrase
+            read_phrase(char)
+
+          when self.state == InComment
+            read_comment(char)
+
+          else
+            complain "unexpected state #{@state}"
+        end #switch state
+      end # read
+      
+      def read_line(char)
+          case
+            when char == "'" # Single Quotes
+              complain 'invalid indentation ' if @spaces != 0
+              begin_string
+              capture(InLine)
+              changeto(InSQString)
+
+            when char == '"' # Double Quotes
+              complain 'invalid indentation ' if @spaces != 0
+              begin_string
+              capture(InLine)
+              changeto(InDQString)
+            
+            when char == ' ' # Whitespace
+              if @indenting
+                @spaces += 1
+                if @spaces == 4
+                  @spaces = 0
+                  indent
+                end
+              else
+                # ignore in line whitespace
+              end
+            
+            when char == '#' # Comment
+              changeto(InComment)
+            
+            when char == "\t" # Tab
+              complain "invalid number of white spaces" if @spaces != 0
+              indent
+              
+            when char == "\n" # New Line
+              add_line
+              @line_count += 1
+              @spaces = 0
+
+            when char == "(" # Open parentheses
+              count = 0
+              @lines.last.each {|n| count += 1 if n.nil?}
+              add_line
+              indent
+              count.times {indent}
+              changeto(InPhrase)
+
+            when char == ")" # Close parentheses
+              complain "close parentheses is unexpected"
+
+            when char == "," # Comma
+              complain "comma is unexpected"
+
+            else             # Normal Character
+              complain "invalid indentation parsing character: #{char}" if @spaces != 0
+              begin_string
+              capture(InLine)
+              changeto(InString)
+              read(char)
+              
+          end # switch
+          
+      end # read_line
+      
+      def read_phrase(char)
+      
+          case
+            when char == "'" # Single Quotes
+              capture(InPhrase)
+              changeto(InSQString)
+              begin_string
+
+            when char == '"' # Double Quotes
+              capture(InPhrase)
+              changeto(InDQString)
+              begin_string
+            
+            when char == ' ' # Whitespace
+              # ignore whitespace
+            
+            when char == '#' # Comment
+              complain "unexpected comment '#' in phrase"
+            
+            when char == "\t" # Tab
+              # ignore Tab
+              
+            when char == "\n" # New Line
+#              complain "unexpected new line character in phrase"
+#              add_line
+              changeto(InLine)
+              read(char)
+
+            when char == "(" # Open parentheses
+              complain "Invalid open parentheses"
+
+            when char == ")" # Close parentheses
+              changeto(InLine)
+
+            when char == "," # Comma
+              count = 0
+              @lines.last.each {|n| count += 1 if n.nil?}
+              add_line              
+              count.times {indent}
+
+            else             # Normal Character
+              capture(InPhrase)
+              changeto(InString)
+              begin_string
+              read(char)
+              
+          end # switch
+          
+      end # read_phrase
+ 
+      def read_string(char)
+          case
+            when char == "'" # Single Quotes
+              complain "single quotes not allowed inside of Node name"
+              
+            when char == '"' # Double Quotes
+              complain "double quotes not allowed inside of Node name"
+              
+            when char == ' ' # Whitespace
+              changeto(@prev_state)
+              
+            when char == '#' # Comment
+              complain "double quotes not allowed inside of Node name"
+              
+            when char == '\\' # Escape
+              complain "escape is not allowed inside of Node name"
+
+            when char == "\t" # Tab
+              complain "tabs not allowed inside of Node name"
+              
+            when char == "\n" # New Line
+              changeto(InLine)
+              add_line
+              @line_count += 1
+
+            when char == "," # Comma
+              complain "unexpected comma" unless @prev_state == InPhrase
+              changeto(InPhrase)
+              read(char)
+
+            when char == ")" # Close parentheses
+              changeto(@prev_state)
+
+            else             # Normal Character
+              append(char)
+          end # switch
+          
+      end # read_string
+
+      
+      
+      def read_sq_string(char)
+        case
+          when char == "'" # Single Quotes
+            if @escape
+              append(char)
+              @escape = false
+            else
+              changeto(@prev_state)
+            end
+            
+          when char == '\\' # Escape
+            @escape = true
+
+          when char == "\n" # New Line
+            complain "new line is unexpected"
+            
+          else             # Normal Character
+            append(char)
+            @escape = false
+        end # switch
+          
+      end # read_sq_string
+      
+      def read_dq_string(char)
+        case
+          when char == '"' # Double Quotes
+            if @escape
+              append(char)
+              @escape = false
+            else
+              changeto(@prev_state)
+            end
+            
+          when char == '\\' # Escape
+            @escape = true
+
+          when char == "\n" # New Line
+            complain "new line is unexpected"
+            
+          else             # Normal Character
+            append(char)
+            @escape = false
+        end # switch
+          
+      end # read_sq_string
+      
+      
+      
+      def read_comment(char)
+          case
+            when char == "\n" # New Line
+              add_line
+              changeto(InLine)
+            else
+              # ignore characters
+              
+          end # switch
+          
+      end # read_line
+      
+      
+      def convert
+        
+        nodes = convert_nodes
+        
+        nodes.each_with_index do |line, i|
+          first_in_line = nil
+          line.each_with_index do |node, j|
+            
+            if !node.nil?
+              
+              if first_in_line.nil?
+                first_in_line = node
+                #find parent here
+
+                nodes[0..i].reverse.each do |array|
+
+                  if !array[j-1].nil? && i != 0
+                    array[j-1].add(node)
+                    break
+                  end
+                
+                end
+
+              else
+                first_in_line.add(node)
+              end
+            end
+          end
+        end
+#        puts parent.flatten.collect {|n| n.gname}
+        return nodes[0][0]
+      end
+      
+      def convert_nodes
+        
+        nodes = []
+        
+        @lines.each_with_index do |line, i|
+          if line != []
+            temp = []
+            nodes << temp
+            
+            line.each_with_index do |name, j|
+              temp[j] = Node.new(name) unless name.nil?
+            end
+          end
+        end
+        return nodes
+      end
+
+      
+    end # class Parser
+  
+  
+end # module Rogdl