aniero-treehouse 0.0.2

data/lib/treehouse/visitor.rb

@@ -0,0 +1,49 @@
+module Treehouse
+
+  # Represents a visitor for an AST. See Treehouse::VisitorDefinition more more information.
+  #
+  class Visitor
+
+    class << self
+
+      # Describe a visitor block for a given node type. If no block is given, an empty lambda is used.
+      # The block always takes at least one argument, an instance of the node you're visiting, as well
+      # as any additional arguments if desired.
+      #
+      def visits(*constants, &blk)
+        constants.each do |constant|
+          nodes[constant] = (blk || lambda {})
+        end
+      end
+
+      # Visit the given node using the visitor mapping defined with .visits.
+      # This finds the block to call for the given node and calls it with the node and additional arguments, if any.
+      #
+      # Raises an exception if no visitor is found for the given node.
+      #
+      def visit(node, *args)
+        block = visitor_for(node)
+        if args.empty?
+          block.call(node)
+        else
+          block.call(node, *args)
+        end
+      end
+
+      protected
+
+      # Node class / lambda mapping
+      def nodes
+        @nodes ||= {}
+      end
+
+      # Look up a visitor block for this node
+      def visitor_for(node)
+        nodes[node.class] or raise "could not find visitor definition for #{node.class}: #{node.inspect}"
+      end
+
+    end
+
+  end
+
+end

data/lib/treehouse/visitor_definition.rb

@@ -0,0 +1,49 @@
+require Treehouse.libpath(%w(treehouse visitor))
+
+module Treehouse::VisitorDefinition
+
+  module ModuleMethods
+
+    # Define a visitor class with the given name.
+    #
+    #   visitor :string_visitor
+    #
+    # Creates StringVisitor in the local scope.
+    #
+    # This method takes a block, which is evaluated in the context of the new visitor class. Since the visitor
+    # class is a subclass of Treehouse::Visitor, you have node visitor definition methods available.
+    # (See Treehouse::Visitor)
+    #
+    # Given an AST built with
+    #
+    #   node :assignment, :lhs, :rhs
+    #   node :variable, :value
+    #
+    # Define a visitor:
+    #
+    #   visitor :hash_visitor do
+    #     visits Assignment do |assignment|
+    #       hash = {}
+    #       hash[ visit(assignment.lhs) ] = visit(assignment.rhs) # visitors are entirely external to the AST
+    #     end
+    #     visits Variable do |var|
+    #       var.value
+    #     end
+    #   end
+    #
+    # And call it:
+    #
+    #   HashVisitor.visit( assignment_node )
+    #
+    def visitor(name, &blk)
+      klass = Class.new(Treehouse::Visitor)
+      const_set name.to_s.camelize, klass
+      klass.class_eval &blk if block_given?
+    end
+  end
+
+  def self.included(base)
+    base.extend ModuleMethods
+  end
+
+end

data/spec/fixtures/assignments.txt

@@ -0,0 +1,7 @@
+foo=bar
+
+baz   =     blech
+
+      
+no =     way
+

data/spec/fixtures/ey00-s00348.xen

@@ -0,0 +1,14 @@
+#  -*- mode: python; -*-
+kernel = '/boot/vmlinuz-2.6.18-xenU'
+memory = 712
+maxmem = 4096
+name = 'ey00-s00348'
+vif = [ 'bridge=xenbr0' ]
+disk = [
+        'phy:/dev/ey00-data4/root-s00348,sda1,w',
+        'phy:/dev/ey00-data4/swap-s00348,sda2,w',
+        'phy:/dev/ey00-data4/gfs-00218,sdb1,w!',
+       ]
+root = "/dev/sda1 ro"
+vcpus = 1
+cpu_cap = 100

data/spec/grammars/assignments.rb

@@ -0,0 +1,38 @@
+Treetop.load(File.join(File.dirname(__FILE__), "assignments.treetop"))
+
+module AssignmentsLanguage
+  module Grammar
+    include Treehouse::NodeDefinition
+
+    node :assignments, :assignments
+    node :assignment, :lhs, :rhs
+    node :blank_line
+    node :variable, :value
+
+  end
+
+  include Treehouse::VisitorDefinition
+
+  visitor :string_visitor do
+    visits Grammar::Assignments do |assignments|
+      assignments.assignments.map { |child| visit(child) }.compact.join("")
+    end
+    visits Grammar::Assignment do |assignment|
+      visit(assignment.lhs) + " = " + visit(assignment.rhs) + "\n"
+    end
+    visits Grammar::BlankLine do
+      nil
+    end
+    visits Grammar::Variable do |variable|
+      variable.value
+    end
+  end
+
+  class Parser < ::Treetop::Runtime::CompiledParser
+    include Grammar
+    def self.parse(io)
+      new.parse(io).eval
+    end
+  end
+
+end

data/spec/grammars/assignments.treetop

@@ -0,0 +1,42 @@
+# This demonstrates a grammar using inline evals to use Treetop to build an external Treehouse-based AST.
+module AssignmentsLanguage
+  grammar Grammar
+
+    rule assignments
+      ( blank_line / assignment )* {
+        def eval
+          Assignments.new :assignments => elements.map {|child| child.eval}
+        end
+      }
+    end
+
+    rule assignment
+      lhs:variable whitespace* "=" whitespace* rhs:variable {
+        def eval
+          Assignment.new(:lhs => lhs.eval, :rhs => rhs.eval)
+        end
+      }
+    end
+
+    rule variable
+      [a-z]+ {
+        def eval
+          Variable.new( :value => text_value)
+        end
+      }
+    end
+
+    rule whitespace
+      [ \t]
+    end
+
+    rule blank_line
+      whitespace* [\n] {
+        def eval
+          BlankLine.new
+        end
+      }
+    end
+
+  end
+end

data/spec/grammars/dot_xen.rb

@@ -0,0 +1,122 @@
+Treetop.load(File.join(File.dirname(__FILE__), "dot_xen.treetop"))
+
+module DotXen
+  module AST
+    include Treehouse::NodeDefinition
+
+    node :config_file, :disks, :vars, :comments
+    node :assignment, :lhs, :rhs
+    node :array_assignment, :lhs, :rhs
+
+    node :array_list, :values
+
+    node :literal_number, :value
+    node :literal_string, :value
+    node :single_quoted_string, :value
+    node :double_quoted_string, :value
+
+    node :comment, :text
+
+    node :disk, :volume, :device, :mode do
+
+      # scan the variable list for disk definitions
+      def self.build(variables)
+        disks = variables.detect { |var| var.lhs.value == "disk" }
+        unless disks.nil?
+          variables.delete(disks)
+          disks.rhs.values.map do |disk|
+            volume, device, mode = disk.value.split(/,/)
+            new(:volume => volume, :device => device, :mode => mode)
+          end
+        end
+      end
+    end
+
+  end
+
+  include Treehouse::VisitorDefinition
+
+  visitor :hash_visitor do
+    visits(AST::ConfigFile) do |config_file|
+      hash = {:comments => [], :vars => {}, :disks => []}
+      config_file.comments.each { |comment| visit(comment, hash) }
+      config_file.vars.each { |var| visit(var, hash) }
+      config_file.disks.each { |disk| visit(disk, hash) }
+      hash
+    end
+
+    visits AST::Assignment do |assignment, hash|
+      hash[:vars][visit(assignment.lhs)] = visit(assignment.rhs)
+    end
+
+    visits AST::ArrayAssignment do |array, hash|
+      hash[:vars][visit(array.lhs)] = visit(array.rhs)
+    end
+
+    visits AST::ArrayList do |list|
+      list.values.map { |value| visit(value) }
+    end
+
+    visits AST::Comment do |comment, hash|
+      hash[:comments] << comment.text
+    end
+
+    visits AST::Disk do |disk, hash|
+      hash[:disks] << [disk.volume, disk.device, disk.mode].join(",")
+    end
+
+    visits AST::LiteralString, AST::LiteralNumber, AST::SingleQuotedString, AST::DoubleQuotedString do |literal|
+      literal.value
+    end
+  end
+
+  visitor :string_visitor do
+    visits(AST::ConfigFile) do |config_file|
+      strings = []
+      config_file.comments.each { |comment| visit(comment, strings) }
+      config_file.vars.each { |var| visit(var, strings) }
+      if config_file.disks
+        strings << "disk = [\n"
+        strings << config_file.disks.map { |disk| "  " + visit(disk) }.join(",\n")
+        strings << "\n]\n"
+      end
+      strings.flatten.join("")
+    end
+
+    visits AST::Assignment, AST::ArrayAssignment do |assignment, strings|
+      strings << [visit(assignment.lhs), " = ", visit(assignment.rhs), "\n"]
+    end
+
+    visits AST::ArrayList do |list|
+      ["[ ", list.values.map { |value| visit(value) }.join(",\n"), " ]"]
+    end
+
+    visits AST::Comment do |comment, strings|
+      strings << "# #{comment.text}\n"
+    end
+
+    visits AST::Disk do |disk|
+      "\"" + [disk.volume, disk.device, disk.mode].join(",") + "\""
+    end
+
+    visits AST::LiteralString, AST::LiteralNumber do |literal|
+      literal.value
+    end
+
+    visits AST::SingleQuotedString do |literal|
+      "'" + literal.value + "'"
+    end
+
+    visits AST::DoubleQuotedString do |literal|
+      '"' + literal.value + '"'
+    end
+  end
+
+  class Parser < ::Treetop::Runtime::CompiledParser
+    include Grammar
+    def self.parse(io)
+      new.parse(io).eval
+    end
+  end
+
+end

data/spec/grammars/dot_xen.treetop

@@ -0,0 +1,100 @@
+module DotXen
+  grammar Grammar
+    rule config_file
+      (comment / blank_line / assignment)* {
+        def eval
+          env = {:vars => [], :comments => []}
+          elements.each { |e| e.eval(env) }
+          env[:disks] = AST::Disk.build(env[:vars])
+          AST::ConfigFile.new(env)
+        end
+      }
+    end
+
+    rule assignment
+      space_no_newline* lhs:variable space_no_newline* '=' space_no_newline* rhs:variable space* comment* {
+        def eval(env={})
+          env[:vars] << AST::Assignment.new(:lhs => lhs.eval, :rhs => rhs.eval)
+        end
+      }
+      /
+      space_no_newline* lhs:variable space_no_newline* '=' space_no_newline* '[' space* rhs:array_list space* ']' space* comment* {
+        def eval(env={})
+          env[:vars] << AST::ArrayAssignment.new(:lhs => lhs.eval, :rhs => rhs.eval)
+        end
+      }
+    end
+
+    rule array_list
+      space* value:(variable/comment) ','? space* remains:(space* var:array_list space* ','?)* {
+        def eval(env={})
+          AST::ArrayList.new :values => [[value.eval] + remains.elements.map { |vars| vars.var.eval.values }].flatten
+        end
+      }
+    end
+
+    rule variable
+      space_no_newline* value:number space* comment* {
+        def eval(env={})
+          value.eval
+        end
+      }
+      /
+      space_no_newline* value:string space* comment* {
+        def eval(env={})
+          value.eval
+        end
+      }
+    end
+
+    rule number
+      [0-9]+ {
+        def eval(env={})
+          AST::LiteralNumber.new(:value => text_value.to_i)
+        end
+      }
+    end
+
+    rule string
+      ([A-Za-z_-])+ {
+        def eval(env={})
+          AST::LiteralString.new(:value => text_value)
+        end
+      } /
+      '"' (!'"' . / '\"')* '"' {
+        def eval(env={})
+          AST::DoubleQuotedString.new(:value => elements[1].text_value)
+        end
+      } /
+      "'" (!"'" .)* "'" {
+        def eval(env={})
+          AST::SingleQuotedString.new(:value => elements[1].text_value)
+        end
+      }
+    end
+
+    rule comment
+      space_no_newline* [!\#] value:([^\n])* "\n" space* {
+        def eval(env={})
+          env[:comments] << AST::Comment.new(:text => value.text_value)
+        end
+      }
+    end
+
+    rule blank_line
+      "\n"
+    end
+
+    rule non_space_char
+      ![ \n] .
+    end
+
+    rule space_no_newline
+      [ \t]
+    end
+
+    rule space
+      space_no_newline / "\n"
+    end
+  end
+end

data/spec/grammars/magic.rb

@@ -0,0 +1,63 @@
+# This demonstrates a grammar making full use of Treehouse's magic nodes to build an AST.
+
+Treetop.load_from_string <<-GRAMMAR
+
+module MagicAssignments
+  grammar Grammar
+    rule assignments
+      ( blank_line / assignment )* <AST.create_node(:assignments)>
+    end
+    rule assignment
+      lhs:variable whitespace* "=" whitespace* rhs:variable [\\n] <AST.create_node(:assignment)>
+    end
+    rule variable
+      [a-z]+ <AST.create_node(:variable)>
+    end
+    rule whitespace
+      [ ]
+    end
+    rule blank_line
+      whitespace* [\\n] <AST.create_node(:blank_line)>
+    end
+  end
+end
+
+GRAMMAR
+
+module MagicAssignments
+  module AST
+    include Treehouse::NodeDefinition
+
+    node :assignments, :assignments => :elements
+    node :assignment, :lhs, :rhs
+    node :blank_line
+    node :variable, :value => :text_value
+
+  end
+
+  include Treehouse::VisitorDefinition
+
+  visitor :hash_visitor do
+    visits AST::Assignments do |assignments|
+      hash = {}
+      assignments.assignments.each { |child| visit(child, hash) }
+      hash
+    end
+    visits AST::Assignment do |assignment, hash|
+      hash[visit(assignment.lhs)] = visit(assignment.rhs)
+    end
+    visits AST::BlankLine
+    visits AST::Variable do |variable|
+      variable.value
+    end
+  end
+
+  class Parser < ::Treetop::Runtime::CompiledParser
+    include Grammar
+    def self.parse(io)
+      new.parse(io).build
+    end
+  end
+
+end
+