rattler 0.3.0 → 0.4.0

data/lib/rattler/util/graphviz/digraph_builder.rb

@@ -0,0 +1,71 @@
+#
+# = rattler/util/graphviz/digraph_builder.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+begin
+  require 'graphviz'
+rescue LoadError => e
+  abort "I need the ruby-graphviz gem and GraphViz installed and in the PATH.\n"
+end
+
+require 'rattler/util/graphviz'
+
+module Rattler::Util::GraphViz
+  #
+  # +DigraphBuilder+ is used to build GraphViz objects representing trees of
+  # nodes.
+  #
+  # @author Jason Arhart
+  #
+  class DigraphBuilder
+
+    # Return a new +GraphViz+ digraph object representing +root+.
+    #
+    # @return a new +GraphViz+ digraph object representing +root+
+    def self.digraph(root, name='G')
+      self.new(root, name).digraph
+    end
+
+    # Create a new digraph builder for +root+.
+    def initialize(root, name='G')
+      @root = root
+      @g = ::GraphViz.digraph(name)
+      @nodes = {}
+      @node_serial = 0
+      @node_builder = NodeBuilder.new
+    end
+
+    # @return a new +GraphViz+ digraph object representing the root object
+    def digraph
+      @digraph ||= begin
+        node(@root)
+        @g
+      end
+    end
+
+    # Return a <tt>GraphViz::Node</tt> object for +o+. Multiple requests with
+    # the same object return the same node object.
+    #
+    # @return a <tt>GraphViz::Node</tt> object for +o+
+    def node(o)
+      @nodes.fetch(o.object_id) do
+        new_node = @g.add_node new_node_name, @node_builder.node_options(o)
+        @nodes[o.object_id] = new_node
+        @node_builder.each_child_of(o) {|_| new_node << node(_) }
+        new_node
+      end
+    end
+
+    private
+
+    def new_node_name
+      name = "n#{@node_serial}"
+      @node_serial += 1
+      name
+    end
+
+  end
+end

data/lib/rattler/util/graphviz/node_builder.rb

@@ -0,0 +1,84 @@
+#
+# = rattler/util/graphviz/node_builder.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/util/graphviz'
+
+module Rattler::Util::GraphViz
+  #
+  # +NodeBuilder+ is used by +DigraphBuilder+ to build nodes for a GraphViz
+  # digraph object representing a tree of nodes.
+  #
+  # @author Jason Arhart
+  #
+  class NodeBuilder
+
+    # Yield any children of +o+ that should be represented as separate nodes in
+    # the graph.
+    def each_child_of(o)
+      o.each {|_| yield _ } if array_like? o and not record_like? o
+    end
+
+    # Return the options for a node representing +o+.
+    # @return the options for a node representing +o+.
+    def node_options(o)
+      { :shape => node_shape(o), :label => node_label(o) }
+    end
+
+    # Return the shape option for a node representing +o+.
+    # @return the shape option for a node representing +o+.
+    def node_shape(o)
+      case o
+      when Hash, Array
+        'circle'
+      when String, Numeric, Symbol
+        'plaintext'
+      else
+        'Mrecord'
+      end
+    end
+
+    # Return the label option for a node representing +o+.
+    # @return the label option for a node representing +o+.
+    def node_label(o)
+      if o.is_a? ::Rattler::Util::Node
+        record_label(o, o.attrs)
+      elsif record_like? o
+        record_label(o, o)
+      elsif array_like? o
+        type_label(o)
+      else
+        o.inspect
+      end
+    end
+
+    def type_label(o)
+      case o
+      when Hash then '\\{\\}'
+      when Array then '\\[\\]'
+      else o.respond_to?(:name) ? o.name : o.class.name
+      end
+    end
+
+    def array_like?(o)
+      o.respond_to? :each and
+      not o.respond_to? :to_str
+    end
+
+    def record_like?(o)
+      o.respond_to? :each_pair and
+      o.none? {|k, v| array_like? v or record_like? v }
+    end
+
+    def record_label(o, h)
+      '{' + ([type_label(o)] + hash_content_labels(h)).join('|') + '}'
+    end
+
+    def hash_content_labels(h)
+      h.map {|pair| '{' + pair.map {|_| _.inspect }.join('|') + '}' }
+    end
+
+  end
+end

data/lib/rattler/util/node.rb

@@ -16,7 +16,7 @@ module Rattler::Util
   #
   class Node
     include Enumerable
-    
+
     # Create a +Node+ object.
     #
     # @return [Node]
@@ -32,7 +32,7 @@ module Rattler::Util
     def self.[](*args)
       self.new(*args)
     end
-    
+
     # Create a +Node+ object.
     #
     # @overload initialize()
@@ -47,7 +47,7 @@ module Rattler::Util
       @attrs = args.last.respond_to?(:to_hash) ? args.pop : {}
       @__children__ = args
     end
-    
+
     # Return an array of the node's children
     #
     # @return [Array] the node's children
@@ -62,7 +62,7 @@ module Rattler::Util
         []
       end
     end
-    
+
     # Return the node's child at +index+, or the first/only child if no index
     # is given.
     #
@@ -72,14 +72,14 @@ module Rattler::Util
     def child(index = 0)
       children[index]
     end
-    
+
     # Return a the node's attributes.
     #
     # @return [Hash] the node's attributes
     def attrs
       @attrs ||= {}
     end
-    
+
     # Return the node's name, which is the node's +name+ attribute if it has
     # one, otherwise the name of the node's class.
     #
@@ -87,21 +87,35 @@ module Rattler::Util
     def name
       attrs.fetch(:name, self.class.name)
     end
-    
+
     # Call _block_ once for each child, passing that child as an argument.
     #
     # @yield [child]
     def each # :yield: child
-      children.each { |_| yield _ }
+      block_given? ? children.each { |_| yield _ } : children.each
+    end
+
+    def with_children(new_children)
+      self.class.new(new_children, attrs)
+    end
+
+    alias_method :with_child, :with_children
+
+    def with_attrs(new_attrs)
+      self.with_attrs!(attrs.merge new_attrs)
+    end
+
+    def with_attrs!(new_attrs)
+      self.class.new(children, new_attrs)
     end
-    
+
     # Return +true+ if the node has no children.
     #
     # @return [Boolean] +true+ if the node has no children
     def empty?
       children.empty?
     end
-    
+
     # Access the node's children as if the node were an array of its children.
     #
     # @overload [](index)
@@ -122,7 +136,7 @@ module Rattler::Util
     def [](*args)
       children[*args]
     end
-    
+
     # Return +true+ if the node is equal to +other+. Normally this means
     # +other+ is an instance of the same class or a subclass and has equal
     # children and attributes.
@@ -133,7 +147,7 @@ module Rattler::Util
       other.can_equal?(self) and
       self.same_contents?(other)
     end
-    
+
     # Return +true+ if the node has the same value as +other+, i.e. +other+
     # is an instance of the same class and has equal children and attributes.
     #
@@ -142,28 +156,28 @@ module Rattler::Util
       self.class == other.class and
       self.same_contents?(other)
     end
-    
+
     # Allow attributes to be accessed as methods.
     def method_missing(symbol, *args)
-      (args.empty? and @attrs.has_key?(symbol)) ? @attrs[symbol] : super
+      (args.empty? and attrs.has_key?(symbol)) ? attrs[symbol] : super
     end
-    
+
     # @private
     def respond_to?(symbol) #:nodoc:
       super || @attrs.has_key?(symbol)
     end
-    
+
     # @private
     def can_equal?(other) #:nodoc:
       self.class == other.class
     end
-    
+
     # @private
     def same_contents?(other) #:nodoc:
       self.children == other.children and
       self.attrs == other.attrs
     end
-    
+
     # @private
     def inspect #:nodoc:
       "#{self.class}[" +
@@ -171,6 +185,10 @@ module Rattler::Util
         attrs.map {|k, v| k.inspect + '=>' + v.inspect}).join(',') +
       ']'
     end
-    
+
+    def to_graphviz
+      Rattler::Util::GraphViz.digraph(self)
+    end
+
   end
 end

data/lib/rattler/util/parser_spec_helper.rb

@@ -12,17 +12,17 @@ module Rattler::Util
   # for parsers.
   #
   # @example
-  # 
+  #
   #   require 'rattler/grammar/grammar_parser'
   #   require 'rattler/util/parser_spec_helper'
-  #   
+  #
   #   describe Rattler::Grammar::GrammarParser do
   #     include Rattler::Util::ParserSpecHelper
-  #     
+  #
   #     describe '#match(:var_name)' do
   #       it 'recognizes variable names' do
-  #         parsing(' fooBar ').as(:var_name).should result_in('fooBar').at(7)
-  #         parsing(' FooBar ').as(:var_name).should fail.with_message('variable name expected')
+  #         matching(' fooBar ').as(:var_name).should result_in('fooBar').at(7)
+  #         matching(' FooBar ').as(:var_name).should fail.with_message('variable name expected')
   #       end
   #     end
   #   end
@@ -30,39 +30,58 @@ module Rattler::Util
   # @author Jason Arhart
   #
   module ParserSpecHelper
-    
+
     # Return a parse result to be matched using #result_in or #fail
-    # 
-    #   parsing(source).as(rule_name)
-    #   parsing(source).as(rule_name).from(pos)
+    #
+    #   parsing(source)
+    #   parsing(source).from(pos)
     #
     def parsing(source)
-      Parsing.new(described_class.new(source))
+      Parsing.new(parser(source))
+    end
+
+    # Return a match result to be matched using #result_in or #fail
+    #
+    #   matching(source).as(rule_name)
+    #   matching(source).as(rule_name).from(pos)
+    #
+    def matching(source)
+      Matching.new(parser(source))
+    end
+
+    def parser(source)
+      (self.respond_to?(:parser_class) ? parser_class : described_class).new(source)
     end
-    
+
     # Expect parse to succeed.
-    # 
-    #   parsing(source).as(rule_name).should result_in(result)
     #
-    # Passes if parsing _source_ with _parser_class_ succeeds returning
-    # _result_.
+    #   parsing(source).should result_in(result)
+    #
+    # Passes if parsing _source_ succeeds returning _result_.
     #
-    #   parsing(source).as(rule_name).should result_in(result).at(pos)
+    #   parsing(source).should result_in(result).at(pos)
     #
-    # Passes if parsing _source_ with _parser_class_ succeeds returning
+    # Passes if parsing _source_ succeeds returning
     # _result_ with the parse position at _pos_.
     #
     # @return [Matcher]
     RSpec::Matchers.define :result_in do |expected|
       match do |target|
-        (target.result == expected) &&
-        (!@expected_pos || (target.pos == @expected_pos))
+        (target.result == expected) and
+        (not @expected_pos or
+          target.pos == @expected_pos) and
+        (not @expected_bindings or
+          @expected_bindings.all?{|k, v| target.scope[k] == v })
       end
-      
+
       chain :at do |pos|
         @expected_pos = pos
       end
-      
+
+      chain :with_scope do |bindings|
+        @expected_bindings = bindings
+      end
+
       failure_message_for_should do |target|
         if target.result != expected
           <<-MESSAGE
@@ -79,15 +98,15 @@ MESSAGE
         end
       end
     end
-    
+
     # Expect parse to fail.
     #
     #   parsing(source).as(rule_name).should fail
-    # 
+    #
     # Passes if parsing _source_ with _parser_class_ fails.
-    # 
+    #
     #   parsing(source).as(rule_name).should fail.at(pos)
-    # 
+    #
     # Passes if parsing _source_ with _parser_class_ fails with the parse
     # position at _pos_
     #
@@ -98,15 +117,15 @@ MESSAGE
         (!@expected_message || (target.failure.message == @expected_message)) &&
         (!@expected_pos || (target.failure.pos == @expected_pos))
       end
-      
+
       chain :with_message do |message|
         @expected_message = message
       end
-      
+
       chain :at do |pos|
         @expected_pos = pos
       end
-      
+
       failure_message_for_should do |target|
         if target.result
           "expected parse to fail but got #{target.result.inspect}"
@@ -125,7 +144,7 @@ MESSAGE
         end
       end
     end
-    
+
     # @private
     class Parsing #:nodoc:
       def initialize(parser)
@@ -136,12 +155,8 @@ MESSAGE
         @parser.pos = pos
         self
       end
-      def as(rule_name)
-        @rule_name = rule_name
-        self
-      end
       def result
-        @result ||= @parser.match(@rule_name)
+        @result ||= @parser.parse
       end
       def pos
         @parser.pos
@@ -150,6 +165,17 @@ MESSAGE
         @parser.failure
       end
     end
-    
+
+    # @private
+    class Matching < Parsing #:nodoc:
+      def as(rule_name)
+        @rule_name = rule_name
+        self
+      end
+      def result
+        @result ||= @parser.match(@rule_name)
+      end
+    end
+
   end
 end