aniero-tire_swing 0.0.2 → 0.0.3

data/Manifest.txt

@@ -4,25 +4,31 @@ README.txt
 Rakefile
 examples/simple_assignment.rb
 lib/tire_swing.rb
+lib/tire_swing/error.rb
 lib/tire_swing/metaid.rb
 lib/tire_swing/node.rb
 lib/tire_swing/node_creator.rb
 lib/tire_swing/node_definition.rb
+lib/tire_swing/parser_extension.rb
 lib/tire_swing/visitor.rb
 lib/tire_swing/visitor_definition.rb
+spec/error_spec.rb
 spec/fixtures/assignments.txt
 spec/fixtures/ey00-s00348.xen
 spec/grammars/assignments.rb
 spec/grammars/assignments.treetop
 spec/grammars/dot_xen.rb
 spec/grammars/dot_xen.treetop
+spec/grammars/lists.rb
 spec/grammars/magic.rb
 spec/integration/assignments_spec.rb
 spec/integration/dot_xen_spec.rb
+spec/integration/lists_spec.rb
 spec/integration/magic_spec.rb
 spec/node_creator_spec.rb
 spec/node_definition_spec.rb
 spec/node_spec.rb
+spec/parser_extension_spec.rb
 spec/spec_helper.rb
 spec/tire_swing_spec.rb
 spec/visitor_definition_spec.rb

data/README.txt

@@ -17,10 +17,10 @@ Given a treetop grammar:
 
   grammar SimpleAssignment
     rule assignment
-      lhs:variable space* "=" space* rhs:variable <create_node(:assignment)>
+      lhs:variable space* "=" space* rhs:variable <node(:assignment)>
     end
     rule variable
-      [a-z]+ <create_node(:variable)>
+      [a-z]+ <node(:variable)>
     end
     rule space
       [ ]+
@@ -36,10 +36,14 @@ You can use TireSwing to define nodes for the grammar:
     node :variable, :value => :text_value
   end
 
-When you parse the grammar and call .build, it will return an AST using the nodes you defined, auto-building everything
+And use TireSwing to extend the Treetop-provided parser with a helper method or two:
+
+  TireSwing.parses_grammar(SimpleAssignment)
+
+When you parse the grammar using the helper, it will return an AST using the nodes you defined, auto-building everything
 for you:
 
-  ast = Parser.parse("foo = bar").build
+  ast = SimpleAssignment.ast("foo = bar")
 
   ast.class #=> SimpleAssignment::Assignment
   ast.lhs.class #=> SimpleAssignment::Variable

data/examples/simple_assignment.rb

@@ -4,10 +4,10 @@ Treetop.load_from_string <<-GRAMMAR
 module SimpleAssignment
   grammar Grammar
     rule assignment
-      lhs:variable space* "=" space* rhs:variable <AST.create_node(:assignment)>
+      lhs:variable space* "=" space* rhs:variable <node(:assignment)>
     end
     rule variable
-      [a-z]+ <AST.create_node(:variable)>
+      [a-z]+ <node(:variable)>
     end
     rule space
       [ ]+
@@ -37,17 +37,14 @@ module SimpleAssignment
     end
   end
 
-  class Parser < ::Treetop::Runtime::CompiledParser
-    include Grammar
-    def self.parse(io)
-      new.parse(io).build
-    end
-  end
+  # Set up the parser helper, pointing to the grammar and the AST
+  # This defines GrammarParser.ast on the Treetop-provided GrammarParser.
+  TireSwing.parses_grammar(Grammar, AST)
 
 end
 
 require "pp"
-ast = SimpleAssignment::Parser.parse("foo=bar")
+ast = SimpleAssignment::GrammarParser.ast("foo=bar")
 puts "----- AST -----"
 pp ast
 puts "\n----- visitor output -----"

data/lib/tire_swing.rb

@@ -1,7 +1,7 @@
 module TireSwing
 
   # :stopdoc:
-  VERSION = '0.0.2'
+  VERSION = "0.0.3"
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/lib/tire_swing/error.rb

@@ -0,0 +1,10 @@
+module TireSwing
+  class ParseError < StandardError
+    attr_reader :parser
+    def initialize(message, parser)
+      @parser = parser
+      super(message)
+    end
+    # TODO add in pretty error formatting, given the parser and the message
+  end
+end

data/lib/tire_swing/node.rb

@@ -51,21 +51,40 @@ module TireSwing
     # Auto-builds this node using the provided parsed node and the defined attributes and mapped attributes.
     def build_from_parsed_node(parsed_node)
       attributes.each do |attrib|
-        if value = mapping(attrib)
-          if value.kind_of?(Proc)
-            value = value.call(parsed_node)
+        if handler = mapping(attrib)
+          if handler.kind_of?(Proc)
+            value = handler.call(parsed_node)
           else
-            value = parsed_node.send(mapping(attrib))
+            if parsed_node.respond_to?(handler)
+              value = parsed_node.send(handler)
+            else
+              value = parsed_node.text_value.send(handler)
+            end
           end
         else
           value = parsed_node.send(attrib)
         end
-        value = value.map { |val| val.respond_to?(:build) ? val.build : val } if value.kind_of?(Array)
-        value = value.build if value.respond_to?(:build)
+
+        value = if value.kind_of?(Array)
+          value.map { |val| extract_value(val) }
+        else
+          extract_value(value)
+        end
+
         send("#{attrib}=", value)
       end
     end
 
+    def extract_value(value)
+      if value.respond_to?(:build)
+        value.build
+      elsif value.kind_of?(Treetop::Runtime::SyntaxNode)
+        value.text_value
+      else
+        value
+      end
+    end
+
     def attributes
       self.class.attributes
     end

data/lib/tire_swing/node_creator.rb

@@ -1,11 +1,12 @@
 module TireSwing
   class NodeCreator
 
-    # Creates a node creator for the given node class. This is meant to act as a stand-in for the treetop
-    # syntax node class.
+    # Creates a node creator for the given node type and class. This is meant to act as a stand-in for the treetop
+    # syntax node class. The node_name, although somewhat redundant, is used for filtering later on
+    # (see: array_of)
     #
-    def initialize(node_class)
-      @node_class = node_class
+    def initialize(node_name, node_class)
+      @node_name, @node_class = node_name, node_class
     end
 
     # Returns a new treetop syntax node to act as a standin for a normal syntax node. Before returning the node, 
@@ -16,11 +17,18 @@ module TireSwing
     def new(*args)
       parsed_node = Treetop::Runtime::SyntaxNode.new(*args)
 
-      node_class = @node_class # local scope for the block below
+      node_name, node_class = @node_name, @node_class # local scope for the block below
+
+      # so the node knows how to build itself:
       parsed_node.meta_def :build do
         node_class.new(self)
       end
 
+      # so the node can be filtered based on what kind of AST node it will build
+      parsed_node.meta_def :node_to_build do
+        node_name
+      end
+
       parsed_node
     end
 

data/lib/tire_swing/node_definition.rb

@@ -17,11 +17,29 @@ module TireSwing::NodeDefinition
     # You can define the grammar as
     #
     #   rule variable
-    #     [a-z]+ <create_node(:variable)>
+    #     [a-z]+ <node(:variable)>
     #   end
     #
+    # Also note that you can specify alternate namespaces:
+    #
+    #   module AST
+    #     node :variable
+    #   end
+    #
+    #   <AST.create_node(:variable)>
+    #
+    # When you're using the parser extension:
+    #
+    #   TireSwing.parses_grammar(Grammar, AST)
+    #
+    # you can use
+    #
+    #   <node(...)>
+    #
+    # Which is an instance method wrapper for the create_node class method.
+    #
     def create_node(name)
-      TireSwing::NodeCreator.new(const_get(name.to_s.camelize))
+      TireSwing::NodeCreator.new(name, const_get(name.to_s.camelize))
     end
 
     # Define a node.
@@ -53,18 +71,31 @@ module TireSwing::NodeDefinition
     # The second method takes a treetop syntax node and auto-builds the node using the syntax node as a basis.
     # The auto-build functionality uses the attribute names and mapped attributes in the following way:
     #
-    # * Simple attributes: calls the method by that name on the syntax node
-    # * Mapped attributes: if the attribute value is a symbol or a string, it calls that method on the syntax node.
-    #   If the attribute value is a lambda, it yields the syntax node to the lambda.
+    # * Simple attributes: calls the method by that name on the syntax node, e.g.
+    #
+    #   node :assignment, :lhs, :rhs
+    #
+    # * Mapped attributes:
+    #   * symbol/string - call that method on *either* the node, if it responds, or on its text value (e.g. #to_i)
     #
-    # If the value (or array of values) returned by one of these methods is another syntax node, the auto-build code
-    # will call the build method on each syntax node or array item (assuming each syntax node has a build method,
-    # usually auto-defined using create_node). Any value not responding to the build method is left alone.
+    #     node :number, :value => :to_i # calls to_i on the number node's text value
+    #
+    #   * lambda - yields the parsed node to the lambda
+    #
+    #   Whatever the value (or array of values) is returned by the mapped call will then be built. Any item returned
+    #   that responds to the build method will have it called. If there's any bare syntax nodes left over, they are
+    #   converted into their text value, and anything else will be returned as-is (numbers, strings, etc.)
+    #
+    #   Note that you can use the array_of and extract helpers defined below to define lambdas for doing more advanced
+    #   filtering on the node and it's children.
     #
     # Simple example:
     #
     #   rule assignment
-    #     variable:lhs "=" variable:rhs <create_node(:assignment)>
+    #     variable:lhs "=" variable:rhs <node(:assignment)>
+    #   end
+    #   rule variable
+    #     [a-z]+
     #   end
     #
     #   node :assignment, :lhs, :rhs
@@ -84,22 +115,85 @@ module TireSwing::NodeDefinition
       klass.class_eval &blk if block_given?
     end
 
+    # Returns a lambda to select only child nodes of the given kind. This is best used for rules that can return
+    # arrays of different kind of nodes, some of which you want to ignore, e.g.:
+    #
+    #   rule assignments
+    #     assignment* <node(:assignments)>
+    #   end
+    #
+    #   node :assignments, :assignments => array_of(:assignment)
+    #
+    # When parsed, this will give you a recursive set of nodes:
+    #
+    #   [assignment, [assignment, [assignment]]]
+    #
+    # If you specify that the array is recursive, it will retrieve all nested child nodes, no matter how deep, which
+    # provide the kind of node you want.
+    #
+    # If you provide a block, the filtered result will be yielded to the block and returned as the final result.
+    #
+    def array_of(kind, recursive = false, &blk)
+      lambda do |node|
+        result = NodeFilters.filter(node, kind, recursive)
+        blk ? result.map(&blk) : result
+      end
+    end
+
+    # Returns a lambda which takes a node and calls node_name on each in turn if possible, returning the result.
+    # This is useful for nested rules, such as:
+    #
+    #   rule assignments
+    #     (assignment [\n])+
+    #   end
+    #
+    # This is a subtle difference from array_of. The rule given here provides a syntax node with multiple elements,
+    # each one corresponding to the grouping, not to an individual child node -- that is, it's a list of
+    # [[assignment node, newline node], [assignment, newline], ...] instead of being a flattened list of
+    # [assignment, newline, assignment, newline, ...].
+    #
+    # To extract these:
+    #
+    #   node :assignments, :assignments => extract(:assignment)
+    #
+    # Which will extract just the assignments out of those "nested children", and then do what you expect from there.
+    #
+    def extract(node_name)
+      lambda do |node|
+        results = []
+        results << node.send(node_name) if node.respond_to?(node_name)
+
+        results.push *node.elements.select { |elem| elem.respond_to?(node_name) }.map { |elem| elem.send(node_name) }
+
+        results
+      end
+    end
+
   end
 
-  # Include this module to get access to the node and create_node methods.
-  # A good place to include this is in a separate AST module, e.g.
+  module NodeFilters
+
+    def self.filter(node, kind, recursive)
+      nodes = []
+      children = node.respond_to?(:elements) ? (node.elements || []) : []
+      if recursive
+        nodes << node if node.respond_to?(:node_to_build) && node.node_to_build == kind
+        children.each { |child| nodes.push *filter(child, kind, true) }
+      else
+        nodes = ([node] + children).select { |n| n.respond_to?(:node_to_build) && n.node_to_build == kind }
+      end
+      nodes
+    end
+
+  end
+
+  # Include this module to get access to the node and create_node class methods.
   #
   #   module AST
   #     include NodeDefinition
   #     node :foo
   #   end
   #
-  # And then in your grammar:
-  #
-  #   rule foo
-  #     "foo" <AST.create_node(:foo)>
-  #   end
-  #
   def self.included(base)
     base.extend ModuleMethods
   end

data/lib/tire_swing/parser_extension.rb

@@ -0,0 +1,33 @@
+module TireSwing
+
+  module ParserExtension
+
+    def ast(io)
+      parser = new
+      result = parser.parse(io)
+      if result
+        result.build
+      else
+        raise TireSwing::ParseError.new(parser.failure_reason, parser)
+      end
+    end
+
+  end
+
+  # Extends the treetop-provided grammar parser with a .ast class method for simple parsing and building of
+  # an AST defined by TireSwing. Takes the grammar module as an argument.
+  #
+  # Additionally, this defines a #node method on the grammar to delegate to the class or the AST to create
+  # new nodes, e.g. <node(:variable)> instead of <AST.create_node(:variable)>
+  #
+  # You can specify an alternate module which contains the AST if desired.
+  def self.parses_grammar(grammar, ast=nil)
+    parser = (grammar.to_s + "Parser").constantize
+    ast ||= grammar
+    parser.module_eval do
+      extend ParserExtension
+      define_method(:node) { |*args| ast.create_node(*args) }
+    end
+  end
+
+end

data/spec/error_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe TireSwing::ParseError do
+
+  describe ".new" do
+    it "takes a message and a parser instance" do
+      TireSwing::ParseError.new("message", "parser").should be_an_instance_of(TireSwing::ParseError)
+    end
+  end
+
+  it "has a message" do
+    e = TireSwing::ParseError.new("message", "parser")
+    e.message.should == "message"
+  end
+
+  it "has a parser" do
+    e = TireSwing::ParseError.new("message", "parser")
+    e.parser.should == "parser"
+  end
+
+end

data/spec/grammars/assignments.rb

@@ -28,6 +28,9 @@ module AssignmentsLanguage
     end
   end
 
+  # This uses an external eval method to build the TireSwing AST manually. Don't do this, but it's here for
+  # an example.
+
   class Parser < ::Treetop::Runtime::CompiledParser
     include Grammar
     def self.parse(io)

data/spec/grammars/assignments.treetop

@@ -1,4 +1,5 @@
 # This demonstrates a grammar using inline evals to use Treetop to build an external TireSwing-based AST.
+# Don't do this, this takes away a good bit of the magic.
 module AssignmentsLanguage
   grammar Grammar
 

data/spec/grammars/lists.rb

@@ -0,0 +1,36 @@
+# More magic: handle recursive rules
+
+Treetop.load_from_string <<-GRAMMAR
+
+module Lists
+  grammar Grammar
+    rule lists
+      (list [\n])+ <node(:lists)>
+    end
+    
+    rule list
+      "[" whitespace* number ("," whitespace* number)* "]" <node(:list)>
+    end
+
+    rule number
+      [1-9] [0-9]* <node(:number)>
+    end
+
+    rule whitespace
+      [ ]
+    end
+  end
+end
+
+GRAMMAR
+
+module Lists
+  module AST
+    include TireSwing::NodeDefinition
+    node :lists, :elements, :lists => extract(:list)
+    node :list, :elements, :numbers => array_of(:number, true) { |num| num.text_value.to_i }
+    node :number # placeholder
+  end
+
+  TireSwing.parses_grammar(Grammar, AST)
+end

data/spec/grammars/magic.rb

@@ -5,19 +5,19 @@ Treetop.load_from_string <<-GRAMMAR
 module MagicAssignments
   grammar Grammar
     rule assignments
-      ( blank_line / assignment )* <AST.create_node(:assignments)>
+      ( blank_line / assignment )* <node(:assignments)>
     end
     rule assignment
-      lhs:variable whitespace* "=" whitespace* rhs:variable [\\n] <AST.create_node(:assignment)>
+      lhs:variable whitespace* "=" whitespace* rhs:variable [\\n] <node(:assignment)>
     end
     rule variable
-      [a-z]+ <AST.create_node(:variable)>
+      [a-z]+
     end
     rule whitespace
       [ ]
     end
     rule blank_line
-      whitespace* [\\n] <AST.create_node(:blank_line)>
+      whitespace* [\\n]
     end
   end
 end
@@ -28,11 +28,8 @@ module MagicAssignments
   module AST
     include TireSwing::NodeDefinition
 
-    node :assignments, :assignments => :elements
     node :assignment, :lhs, :rhs
-    node :blank_line
-    node :variable, :value => :text_value
-
+    node :assignments, :assignments => array_of(:assignment)
   end
 
   include TireSwing::VisitorDefinition
@@ -44,20 +41,11 @@ module MagicAssignments
       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
+      hash[assignment.lhs] = assignment.rhs
     end
   end
 
-  class Parser < ::Treetop::Runtime::CompiledParser
-    include Grammar
-    def self.parse(io)
-      new.parse(io).build
-    end
-  end
+  TireSwing.parses_grammar(Grammar, AST)
 
 end
 

data/spec/integration/lists_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+require TireSwing.path(%w(spec grammars lists))
+
+describe Lists::GrammarParser do
+  describe ".ast" do
+    before(:each) do
+      @input = <<-EOD
+[1, 2, 3]
+[4, 5]
+[6, 7,8,9,10]
+      EOD
+      @result = Lists::GrammarParser.ast(@input)
+    end
+
+    it "returns an AST" do
+      @result.should be_an_instance_of(Lists::AST::Lists)
+    end
+
+    it "has an array of lists" do
+      @result.should have(3).lists
+    end
+
+    it "has lists with numbers" do
+      @result.lists.first.should have(3).numbers
+      @result.lists.first.numbers.should == [1, 2, 3]
+    end
+
+  end
+end

data/spec/integration/magic_spec.rb

@@ -2,25 +2,25 @@ require File.join(File.dirname(__FILE__), %w[.. spec_helper])
 
 require TireSwing.path(%w(spec grammars magic))
 
-describe MagicAssignments::Parser do
-  describe ".parse" do
+describe MagicAssignments::GrammarParser do
+  describe ".ast" do
     before(:each) do
       @input = File.read(TireSwing.path(%w(spec fixtures assignments.txt)))
-      @result = MagicAssignments::Parser.parse(@input)
+      @result = MagicAssignments::GrammarParser.ast(@input)
     end
 
     it "returns an AST" do
       @result.should be_an_instance_of(MagicAssignments::AST::Assignments)
     end
 
-    it "has the right number of nodes" do
-      @result.should have(7).assignments
+    it "has the right number of assignments" do
+      @result.should have(3).assignments
     end
 
     it "has an assignment with correct values" do
       @result.assignments.first.should be_an_instance_of(MagicAssignments::AST::Assignment)
-      @result.assignments.first.lhs.value.should == "foo"
-      @result.assignments.first.rhs.value.should == "bar"
+      @result.assignments.first.lhs.should == "foo"
+      @result.assignments.first.rhs.should == "bar"
     end
 
   end
@@ -29,7 +29,7 @@ end
 describe MagicAssignments::HashVisitor do
   describe ".visit" do
     it "returns a hash representation of the assignments" do
-      ast = MagicAssignments::Parser.parse(File.read(TireSwing.path(%w(spec fixtures assignments.txt))))
+      ast = MagicAssignments::GrammarParser.ast(File.read(TireSwing.path(%w(spec fixtures assignments.txt))))
       MagicAssignments::HashVisitor.visit(ast).should == {
         "foo" => "bar",
         "baz" => "blech",
@@ -37,4 +37,4 @@ describe MagicAssignments::HashVisitor do
       }
     end
   end
-end
+end

data/spec/node_creator_spec.rb

@@ -11,14 +11,14 @@ describe TireSwing::NodeCreator do
 
   describe "#initialize" do
 
-    it "takes a class as an argument" do
-      nc = TireSwing::NodeCreator.new(SomeNode)
+    it "takes a node name and a node class as arguments" do
+      nc = TireSwing::NodeCreator.new(:some_node, SomeNode)
     end
   end
 
   describe "#new" do
     before(:each) do
-      @nc = TireSwing::NodeCreator.new(SomeNode)
+      @nc = TireSwing::NodeCreator.new(:some_node, SomeNode)
     end
 
     it "takes parameters as if it were a treetop syntax node" do
@@ -35,6 +35,11 @@ describe TireSwing::NodeCreator do
       node.methods.should include("build")
     end
 
+    it "defines a node_to_build method on the syntax node that returns the kind of ast node it's going to build" do
+      node = @nc.new("what", 0..3)
+      node.node_to_build.should == :some_node
+    end
+
     it "creates an instance of the defined class when build is called on the resulting syntax node" do
       node = @nc.new("what", 0..3)
       mock_node = mock("node")

data/spec/node_definition_spec.rb

@@ -5,6 +5,14 @@ describe TireSwing::NodeDefinition do
     include TireSwing::NodeDefinition
   end
 
+  before(:all) do
+    TestNodes.class_eval { node :foo_node }
+  end
+
+  after(:all) do
+    TestNodes.send(:remove_const, "FooNode")
+  end
+
   it "adds a node method when included" do
     TestNodes.methods.should include("node")
   end
@@ -34,12 +42,6 @@ describe TireSwing::NodeDefinition do
   end
 
   describe ".create_node" do
-    before(:all) do
-      TestNodes.class_eval { node :foo_node }
-    end
-    after(:all) do
-      TestNodes.send(:remove_const, "FooNode")
-    end
 
     it "takes a node name as an argument" do
       TestNodes.create_node(:foo_node)
@@ -49,12 +51,84 @@ describe TireSwing::NodeDefinition do
       TestNodes.create_node(:foo_node).should be_an_instance_of(TireSwing::NodeCreator)
     end
 
-    it "instantiates the node creator with the class corresponding to the node name" do
+    it "instantiates the node creator for the given node name" do
       obj = Object.new
-      TireSwing::NodeCreator.should_receive(:new).with(TestNodes::FooNode).and_return(obj)
+      TireSwing::NodeCreator.should_receive(:new).with(:foo_node, TestNodes::FooNode).and_return(obj)
       TestNodes.create_node(:foo_node).should == obj
     end
 
   end
 
+  describe ".array_of" do
+
+    it "returns a lambda" do
+      TestNodes.array_of(:foo_node).should be_an_instance_of(Proc)
+    end
+
+    it "returns a lambda that filters a node's elements for nodes that will build the given node type" do
+      a, b = mock_syntax_node("a", :node_to_build => :foo_node), mock_syntax_node("b", :node_to_build => :foo_node)
+      node = mock_syntax_node("node", :elements => [1, 2, a, 3, b])
+      TestNodes.array_of(:foo_node).call(node).should == [a, b]
+    end
+
+    it "will return the node itself if it provides the given node type" do
+      node = mock_syntax_node("node", :node_to_build => :foo)
+      TestNodes.array_of(:foo).call(node).should == [node]
+    end
+
+    it "does not filter recursively by default" do
+      b = mock_syntax_node("b", :elements => ["stuff", "whatever"], :node_to_build => :foo)
+      a = mock_syntax_node("a", :elements => ["jkl", b], :node_to_build => :foo)
+      top = mock_syntax_node("top", :elements => ["asdf", a], :node_to_build => :foo)
+      TestNodes.array_of(:foo).call(top).should == [top, a]
+    end
+
+    describe "with the recursive flag" do
+      it "returns a lambda that filters recursively for the right kind of child" do
+        b = mock_syntax_node("b", :elements => ["stuff", "whatever"], :node_to_build => :foo)
+        a = mock_syntax_node("a", :elements => ["jkl", b], :node_to_build => :foo)
+        top = mock_syntax_node("top", :elements => ["asdf", a], :node_to_build => :foo)
+        TestNodes.array_of(:foo, true).call(top).should == [top, a, b]
+      end
+    end
+
+    describe "with a block provided" do
+      it "yields the filtered results to the block" do
+        a = mock_syntax_node("a", :node_to_build => :foo_node, :x => 1)
+        b = mock_syntax_node("b", :node_to_build => :foo_node, :x => 2)
+        node = mock_syntax_node("node", :elements => [1, 2, a, 3, b])
+        yielded = []
+        array_of = TestNodes.array_of(:foo_node) { |node| yielded << node; node.x }
+        array_of.call(node).should == [1, 2]
+        yielded.should == [a, b]
+      end
+    end
+
+  end
+
+  describe ".extract" do
+
+    it "returns a lambda" do
+      TestNodes.extract(:thing).should be_an_instance_of(Proc)
+    end
+
+    it "extracts all nodes by calling the given node name wherever it applies" do
+      q = mock_syntax_node("q")
+      a = mock_syntax_node("a", :value => q)
+      b = mock_syntax_node("b")
+      c = mock_syntax_node("c", :value => "c")
+      node = mock_syntax_node("node", :elements => [a, b, c])
+      TestNodes.extract(:value).call(node).should == [q, "c"]
+    end
+
+    it "will extract the given node as well as the nested children " do
+      a = mock_syntax_node("a", :value => "a")
+      b = mock_syntax_node("b")
+      c = mock_syntax_node("c", :value => "c")
+      node = mock_syntax_node("node", :value => "foo", :elements => [a, b, c])
+      TestNodes.extract(:value).call(node).should == ["foo", "a", "c"]
+    end
+
+  end
+
 end

data/spec/node_spec.rb

@@ -87,44 +87,55 @@ describe TireSwing::Node do
 
     describe "with an instance of Treetop::Runtime::SyntaxNode" do
       before(:each) do
-        @child = mock_syntax_node :build => "child value"
-        @top = mock_syntax_node :child => @child, :data => "data"
+        @child = mock_syntax_node("child")
+        @top = mock_syntax_node("top")
       end
 
-      it "sets the named values by calling build on the named child node" do
-        @top.should_receive(:child).and_return(@child)
-        @child.should_receive(:build).and_return("child value")
-        n = @node.new(@top)
-        n.child.should == "child value"
+      describe "for a node with a single attribute as a named method" do
+        it "retrieves the value for the attribute by calling the named method" do
+          @node = TireSwing::Node.create(:foo => :a_method)
+          @top.should_receive(:a_method).and_return("asdf")
+          @node.new(@top).foo.should == "asdf"
+        end
       end
 
-      it "calls the specified method directly for hash values" do
-        @top.should_receive(:data).and_return do
-          puts "called from #{caller.detect {|c| c !~ /rspec/}}"
-          "foo"
+      describe "for a node with an attribute naming a child syntax node" do
+        it "retrieves the value by calling build on the child" do
+          @top.should_receive(:child).and_return(@child)
+          @node = TireSwing::Node.create(:foo => :child)
+          @child.should_receive(:build).and_return("child value")
+          @node.new(@top).foo.should == "child value"
         end
-        n = @node.new(@top)
-        n.value.should == "foo"
-      end
 
-      it "calls build on each element of a referenced node value if that value is an array" do
-        @top.should_receive(:child).and_return([@child, @child])
-        @child.should_receive(:build).exactly(2).times.and_return("one", "two")
-        n = @node.new(@top)
-        n.child.should == %w(one two)
-      end
+        it "calls text_value on the child if the child doesn't have a build method" do
+          @top.should_receive(:child).and_return(@child)
+          @node = TireSwing::Node.create(:foo => :child)
+          @child.should_receive(:text_value).and_return("child value")
+          @node.new(@top).foo.should == "child value"
+        end
+
+        it "retrieves the value of each item in an array if the named attribute returns one" do
+          @child.should_receive(:build).and_return("child")
+          @top.should_receive(:children).and_return(["foo", 1, @child])
+          TireSwing::Node.create(:foo => :children).new(@top).foo.should == ["foo", 1, "child"]
+        end
 
-      it "only calls build on elements of an array if they respond to that method" do
-        @top.should_receive(:child).and_return([@child, "blah"])
-        @node.new(@top).child.should == ["child value", "blah"]
       end
 
-      it "yields the syntax node instance if a mapped attribute is a lambda" do
-        @node = TireSwing::Node.create(:value => lambda { |x| @x = x })
-        @node.new(@top)
+      it "yields the syntax node instance if a named attribute is a lambda" do
+        @node = TireSwing::Node.create(:value => lambda { |x| @x = x; "asdf" })
+        @node.new(@top).value.should == "asdf"
         @x.should == @top
       end
 
+      describe "for a node with an attribute as a method to call on the text value" do
+        it "calls that method on the text value, not the parsed node" do
+          node = TireSwing::Node.create(:value => :to_i)
+          @top.should_receive(:text_value).and_return("1234")
+          node.new(@top).value.should == 1234
+        end
+      end
+
     end
   end
 

data/spec/parser_extension_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe TireSwing::ParserExtension do
+
+  it "defines a parses_grammar method on TireSwing" do
+    TireSwing.should respond_to(:parses_grammar)
+  end
+
+  describe "when given a grammar" do
+    module Foo; end
+    class FooParser; end
+    module AST; end
+
+    it "extends the parser for that grammar with the ParserExtension module, defining an ast method" do
+      TireSwing.parses_grammar(Foo)
+      FooParser.should respond_to(:ast)
+    end
+
+    it "defines a node method on the parser that delegates to the grammar" do
+      TireSwing.parses_grammar(Foo)
+      Foo.should_receive(:create_node).with("a", "b", "c")
+      FooParser.new.node("a", "b", "c")
+    end
+
+    it "defines a create_node method on the parser that delegates to the given AST, if provided" do
+      TireSwing.parses_grammar(Foo, AST)
+      AST.should_receive(:create_node).with("a", "b", "c")
+      FooParser.new.node("a", "b", "c")
+    end
+
+  end
+
+  describe "#ast" do
+    before(:all) do
+
+      Treetop.load_from_string <<-GRAMMAR
+module TestGramma
+  grammar Grammar
+    rule letters
+      letter* <node(:letters)>
+    end
+    rule letter
+      value:[a-z] [\n]? <node(:letter)>
+    end
+  end
+end
+      GRAMMAR
+
+      module ::TestGramma
+        module AST
+          include TireSwing::NodeDefinition
+          node :letters, :letters => array_of(:letter)
+          node :letter, :value
+        end
+        TireSwing.parses_grammar(Grammar, AST)
+      end
+
+    end
+
+    after(:all) do
+      Object.send(:remove_const, "TestGramma")
+    end
+
+    it "takes an AST and returns the built AST" do
+      asdf = TestGramma::GrammarParser.ast("asdf")
+      asdf.should be_an_instance_of ::TestGramma::AST::Letters
+      asdf.should have(4).letters
+      asdf.letters.map { |l| l.value }.should == %w(a s d f)
+    end
+
+    describe "with invalid input" do
+
+      it "raises an exception" do
+        lambda { parse }.should raise_error(TireSwing::ParseError)
+      end
+
+      def parse
+        TestGramma::GrammarParser.ast("as3f")
+      end
+    end
+
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -11,8 +11,8 @@ Spec::Runner.configure do |config|
   # config.mock_with :rr
 
   # borrowed from rspec_on_rails' mock_model
-  def mock_syntax_node(stubs={})
-    m = mock "mock syntax node", stubs
+  def mock_syntax_node(name, stubs={})
+    m = mock "mock syntax node (#{name})", stubs
     m.send(:__mock_proxy).instance_eval do
       def @target.is_a?(other)
         Treetop::Runtime::SyntaxNode.ancestors.include?(other)

data/tire_swing.gemspec

@@ -1,14 +1,14 @@
 Gem::Specification.new do |s|
   s.name = %q{tire_swing}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nathan Witmer"]
-  s.date = %q{2008-07-17}
+  s.date = %q{2008-08-11}
   s.description = %q{Simple node and visitor definitions for Treetop grammars.}
   s.email = %q{nwitmer at gmail dot com}
   s.extra_rdoc_files = ["History.txt", "README.txt", "spec/fixtures/assignments.txt"]
-  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "examples/simple_assignment.rb", "lib/tire_swing.rb", "lib/tire_swing/metaid.rb", "lib/tire_swing/node.rb", "lib/tire_swing/node_creator.rb", "lib/tire_swing/node_definition.rb", "lib/tire_swing/visitor.rb", "lib/tire_swing/visitor_definition.rb", "spec/fixtures/assignments.txt", "spec/fixtures/ey00-s00348.xen", "spec/grammars/assignments.rb", "spec/grammars/assignments.treetop", "spec/grammars/dot_xen.rb", "spec/grammars/dot_xen.treetop", "spec/grammars/magic.rb", "spec/integration/assignments_spec.rb", "spec/integration/dot_xen_spec.rb", "spec/integration/magic_spec.rb", "spec/node_creator_spec.rb", "spec/node_definition_spec.rb", "spec/node_spec.rb", "spec/spec_helper.rb", "spec/tire_swing_spec.rb", "spec/visitor_definition_spec.rb", "spec/visitor_spec.rb", "tasks/ann.rake", "tasks/bones.rake", "tasks/gem.rake", "tasks/git.rake", "tasks/manifest.rake", "tasks/notes.rake", "tasks/post_load.rake", "tasks/rdoc.rake", "tasks/rubyforge.rake", "tasks/setup.rb", "tasks/spec.rake", "tasks/svn.rake", "tasks/test.rake", "tire_swing.gemspec"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "examples/simple_assignment.rb", "lib/tire_swing.rb", "lib/tire_swing/error.rb", "lib/tire_swing/metaid.rb", "lib/tire_swing/node.rb", "lib/tire_swing/node_creator.rb", "lib/tire_swing/node_definition.rb", "lib/tire_swing/parser_extension.rb", "lib/tire_swing/visitor.rb", "lib/tire_swing/visitor_definition.rb", "spec/error_spec.rb", "spec/fixtures/assignments.txt", "spec/fixtures/ey00-s00348.xen", "spec/grammars/assignments.rb", "spec/grammars/assignments.treetop", "spec/grammars/dot_xen.rb", "spec/grammars/dot_xen.treetop", "spec/grammars/lists.rb", "spec/grammars/magic.rb", "spec/integration/assignments_spec.rb", "spec/integration/dot_xen_spec.rb", "spec/integration/lists_spec.rb", "spec/integration/magic_spec.rb", "spec/node_creator_spec.rb", "spec/node_definition_spec.rb", "spec/node_spec.rb", "spec/parser_extension_spec.rb", "spec/spec_helper.rb", "spec/tire_swing_spec.rb", "spec/visitor_definition_spec.rb", "spec/visitor_spec.rb", "tasks/ann.rake", "tasks/bones.rake", "tasks/gem.rake", "tasks/git.rake", "tasks/manifest.rake", "tasks/notes.rake", "tasks/post_load.rake", "tasks/rdoc.rake", "tasks/rubyforge.rake", "tasks/setup.rb", "tasks/spec.rake", "tasks/svn.rake", "tasks/test.rake", "tire_swing.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/aniero/tire_swing}
   s.rdoc_options = ["--main", "README.txt"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aniero-tire_swing
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Nathan Witmer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-17 00:00:00 -07:00
+date: 2008-08-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -56,25 +56,31 @@ files:
 - Rakefile
 - examples/simple_assignment.rb
 - lib/tire_swing.rb
+- lib/tire_swing/error.rb
 - lib/tire_swing/metaid.rb
 - lib/tire_swing/node.rb
 - lib/tire_swing/node_creator.rb
 - lib/tire_swing/node_definition.rb
+- lib/tire_swing/parser_extension.rb
 - lib/tire_swing/visitor.rb
 - lib/tire_swing/visitor_definition.rb
+- spec/error_spec.rb
 - spec/fixtures/assignments.txt
 - spec/fixtures/ey00-s00348.xen
 - spec/grammars/assignments.rb
 - spec/grammars/assignments.treetop
 - spec/grammars/dot_xen.rb
 - spec/grammars/dot_xen.treetop
+- spec/grammars/lists.rb
 - spec/grammars/magic.rb
 - spec/integration/assignments_spec.rb
 - spec/integration/dot_xen_spec.rb
+- spec/integration/lists_spec.rb
 - spec/integration/magic_spec.rb
 - spec/node_creator_spec.rb
 - spec/node_definition_spec.rb
 - spec/node_spec.rb
+- spec/parser_extension_spec.rb
 - spec/spec_helper.rb
 - spec/tire_swing_spec.rb
 - spec/visitor_definition_spec.rb