rockit 0.7.1 → 0.7.2

data/lib/rockit/tree/visitor.rb

@@ -1,12 +0,0 @@
-require 'util/visitor'
-require 'rockit/tree/base'
-
-module Rockit::Tree
-  class Base
-    include Visitable
-    
-    def accept_visitor(visitor)
-      visitor.visit_me_and_my_children(self, self.children)
-    end
-  end
-end

data/lib/util/array_alternatives.rb

@@ -1,20 +0,0 @@
-# Collect alternatives to an array by pushing them onto an internal
-# instance variable @__alternatives. We can then assemble all the alternatives
-# (including self) into an Array. This is used for specifying alternative
-# RightHandSides in a Rule in a Grammar.
-class Array
-  def __alternatives
-    @__alternatives ||= Array.new
-  end
-
-  def /(other)
-    self.__alternatives << other
-    self
-  end
-
-  def assemble_alternatives
-    alternatives = self.__alternatives
-    alternatives.unshift self
-    alternatives
-  end
-end

data/lib/util/enter_leave_visitor.rb

@@ -1,69 +0,0 @@
-require 'util/visitor'
-
-# An EnterLeaveVisitor is a Visitor that visits objects both on the way down
-# and on the way up when traversing an object structure/hierarchy.
-# It will first call enter_X(x) if available, then visit_X(x) if avilable
-# then traverse down into children objects and then call leave_X(x) if
-# available.
-# Objects use visit_all to indicate structure. The first argument to visit_all
-# is a parent object and the rest are children objects.
-# NOTE! If they simply call visit the leave method will never be called but
-# the enter and visit methods will.
-module EnterLeaveVisitor
-  include Visitor
-
-  def visit(obj)
-    visit_me_then_children(obj)
-  end
-
-  def enter(obj)
-    method = _enter_method(obj)
-    self.send(method, obj) if method
-  end
-
-  def leave(obj)
-    method = _leave_method(obj)
-    self.send(method, obj) if method
-  end
-
-  # Each children should be an array with children
-  def visit_me_then_children(parent, *children)
-    enter_method, visit_method, leave_method = _evl_methods(parent)
-    self.send(enter_method, parent) if enter_method
-    self.send(visit_method, parent) if visit_method
-    children.each {|cs| cs.each {|c| c.accept_visitor(self)}}
-    self.send(leave_method, parent) if leave_method
-  end
-
-  def _evl_methods(obj)
-    obj.class.ancestors.map {|c| _evl_methods_for_class(c)}.compact.first
-  end
-
-  def _evl_methods_for_class(klass)
-    # Memoized so not dynamic, maybe we should clear cache when a method is
-    # added?
-    (@_memoized_methods ||= Hash.new)[klass] ||= _methodnames_from_class(klass)
-  end
-
-  def _methodname_from_classname(klassName, prefix)
-    name = prefix + klassName
-    self.class.instance_methods.include?(name) ? name : nil
-  end
-
-  def _methodnames_from_class(klass)
-    class_name = klass.inspect.split("::").last
-    l = ["enter_", "visit_", "leave_"].map do |prefix| 
-      _methodname_from_classname(class_name, prefix)
-    end
-    # Return nil unless we found at least one method to visit
-    (l.compact.length > 0) ? l : nil
-  end
-end
-
-module EnterLeaveVisitable
-  include Visitable
-end
-
-class Object
-  include EnterLeaveVisitable
-end

data/lib/util/graphviz_dot.rb

@@ -1,182 +0,0 @@
-class DotGraphPrinter
-  attr_accessor :orientation, :size, :color
-
-  # The following can be set to blocks of code that gives a default
-  # value for the node shapes, node labels and link labels, respectively.
-  attr_accessor :node_shaper, :node_labeler, :link_labeler
-
-  # A node shaper maps each node to a string describing its shape.
-  # Valid shapes are: 
-  #   "ellipse"   (default)
-  #   "box"
-  #   "circle"
-  #   "plaintext" (no outline)
-  #   "doublecircle"
-  #   "diamond"
-  # Not yet supported or untested once are:
-  #   "polygon", "record", "epsf"
-  @@default_node_shaper = proc{|n| "box"}
-
-  @@default_node_labeler = proc{|n| 
-    if Symbol===n
-      n.id2name 
-    elsif String===n
-      n
-    else
-      n.inspect
-    end
-  }
-
-  @@default_link_labeler = proc{|info| info ? info.inspect : nil}
-
-  # links is either array of 
-  #                   arrays [fromNode, toNode [, infoOnLink]], or
-  #                   objects with attributes :from, :to, :info
-  # nodes is array of node objects
-  # All nodes used in the links are used as nodes even if they are not 
-  # in the "nodes" parameters.
-  def initialize(links = [], nodes = [])
-    @links, @nodes = links, add_nodes_in_links(links, nodes)
-    @node_attributes, @edge_attributes = Hash.new, Hash.new
-    set_default_values
-  end
-
-  def set_default_values
-    @color = "black"
-    @size = "9,11"
-    @orientation = "portrait"
-    @node_shaper = @@default_node_shaper
-    @node_labeler = @@default_node_labeler
-    @link_labeler = @@default_link_labeler
-  end
-
-  def write_to_file(filename, fileType = "ps")
-    dotfile = temp_filename(filename)
-    File.open(dotfile, "w") {|f| f.write to_dot_specification}
-    system "dot -T#{fileType} -o #{filename} #{dotfile}"
-    File.delete(dotfile)
-  end
-
-  def set_edge_attributes(anEdge, aHash)
-    # TODO check if attributes are valid dot edge attributes
-    edge = find_edge(anEdge)
-    set_attributes(edge, @edge_attributes, true, aHash)
-  end
-
-  def set_node_attributes(aNode, aHash)
-    # TODO check if attributes are valid dot node attributes
-    set_attributes(aNode, @node_attributes, true, aHash)
-  end
-
-  def to_dot_specification
-    set_edge_labels(@links)
-    set_node_labels_and_shape(@nodes)
-    "digraph G {\n" +
-      graph_parameters_to_dot_specification +
-      @nodes.uniq.map {|n| format_node(n)}.join(";\n") + ";\n" +
-      @links.uniq.map {|l| format_link(l)}.join(";\n") + ";\n" +
-      "}"
-  end
-
-  protected
-
-  def find_edge(anEdge)
-    @links.each do |link|
-      return link if source_and_dest(link) == source_and_dest(anEdge)
-    end
-  end
-
-  def set_attributes(key, hash, override, newAttributeHash)
-    h = hash[key] || Hash.new
-    newAttributeHash = all_keys_to_s(newAttributeHash) 
-    newAttributeHash.each do |k, value|
-      h[k] = value unless h[k] and !override
-    end
-    hash[key] = h
-  end
-
-  def graph_parameters_to_dot_specification
-    "graph [\n" + 
-      (self.size ? "  size = #{@size.inspect},\n" : "") +
-      (self.orientation ? "  orientation = #{@orientation},\n" : "") +
-      (self.color ? "  color = #{@color}\n" : "") +
-      "]\n"
-  end
-
-  def each_node_in_links(links)
-    links.each do |l|
-      src, dest = source_and_dest(l)
-      yield src
-      yield dest
-    end
-  end
-
-  def add_nodes_in_links(links, nodes)
-    new_nodes = []
-    each_node_in_links(links) {|node| new_nodes.push node}
-    (nodes + new_nodes).uniq
-  end
-
-  def all_keys_to_s(aHash)
-    # MAYBE reuse existing hash?
-    Hash[*(aHash.map{|p| p[0] = p[0].to_s; p}.flatten)]
-  end
-
-  def set_edge_labels(edges)
-    edges.each do |edge|
-      src, dest, info = get_link_data(edge)
-      if info
-	label = @link_labeler.call(info)
-	set_attributes(edge, @edge_attributes, false, :label =>label) if label 
-      end
-    end
-  end
-
-  def set_node_labels_and_shape(nodes)
-    nodes.each do |node|
-      set_attributes(node, @node_attributes, false,
-		     :label => @node_labeler.call(node).inspect,
-		     :shape => @node_shaper.call(node).inspect)
-    end
-  end
-
-  def get_link_data(link)
-    begin
-      return link.from, link.to, link.info
-    rescue Exception
-      return link[0], link[1], link[2]
-    end
-  end
-  
-  def source_and_dest(link)
-    get_link_data(link)[0,2]
-  end
-
-  def format_attributes(attributes)
-    return "" unless attributes
-    strings = attributes.map {|a, v| "#{a}=#{v}"}
-    strings.length > 0 ? (" [" + strings.join(", ") + "]") : ("")
-  end
-
-  def mangle_node_name(node)
-    "n" + node.hash.abs.inspect
-  end
-
-  def format_link(link)
-    from, to, info = get_link_data(link)
-    mangle_node_name(from) + " -> " + mangle_node_name(to) + 
-      format_attributes(@edge_attributes[link])
-  end
-
-  def format_node(node)
-    mangle_node_name(node) + format_attributes(@node_attributes[node])
-  end
-
-  def temp_filename(base = "tmp")
-    tmpfile = base + rand(100000).inspect
-    while test(?f, tmpfile)
-      tmpfile = base + rand(100000).inspect
-    end
-    tmpfile
-  end
-end

data/lib/util/string_location.rb

@@ -1,42 +0,0 @@
-# A class for calculating locations (line, column) in a string based
-# on an offset.
-class StringLocations
-  def initialize(string)
-    @string, @string_length = string, string.length
-    @line_lengths = @string.split(/\n/).map {|l| l.length}
-    @start_pos_of_line = [0]
-    @line_lengths.each do |l|
-      @start_pos_of_line << @start_pos_of_line.last + l + 1
-    end
-  end
-
-  def location(offset)
-    l = line(offset)
-    return l, column(offset, l)
-  end
-
-  def column(offset, l = nil)
-    l ||= line(offset)
-    offset - @start_pos_of_line[l-1]
-  end
-
-  def line(offset)
-    if offset >= @string_length
-      raise "#{offset} is larger than the string size #{@string_length}"
-    end
-    line_index(offset) + 1
-  end
-
-  # Find the index to the line where the given offset can be found. Assumes
-  # the start_pos_of_line array has been extended so that offset is covered.
-  def line_index(offset)
-    index = nil
-    for index in (0...(@start_pos_of_line.length))
-      if @start_pos_of_line[index] <= offset && 
-	  @start_pos_of_line[index+1] > offset
-	break
-      end
-    end
-    index
-  end
-end

data/lib/util/visitor.rb

@@ -1,49 +0,0 @@
-module Visitor
-  def visit(obj)
-    method = _visitor_method(obj)
-    self.send(method, obj) if method
-  end
-
-  def visit_me_and_my_children(me, children)
-    visit(me)
-    children.each {|c| c.accept_visitor(self)}
-  end
-
-  def visit_me_then_children(obj, *children)
-    visit(obj)
-    children.each {|cs| cs.each {|c| c.accept_visitor(self)}}
-  end
-
-  # Find the visit_X method to use based on the inheritance tree. First try
-  # the class name then traverse the ancestors list.
-  def _visitor_method(obj)
-    obj.class.ancestors.map {|c| _visitor_method_for_class(c)}.compact.first
-  end
-
-  def _visitor_method_for_class(klass)
-    _visitor_methods[klass] ||= _methodname_from_class(klass)
-  end
-  
-  def _visitor_methods
-    @_visitor_methods ||= Hash.new
-  end
-
-  def _methodname_from_class(klass)
-    name = "visit_" + klass.inspect.split("::").last
-    self.class.instance_methods.include?(name) ? name : nil
-  end
-
-  def visit_each(ary)
-    ary.each {|e| e.accept_visitor(self)}
-  end
-end
-
-module Visitable
-  def accept_visitor(visitor)
-    visitor.visit(self)
-  end
-end
-
-class Object
-  include Visitable
-end

data/lib/util/visitor_combinators.rb

@@ -1,14 +0,0 @@
-require 'util/visitor'
-
-# Sequentially apply visitors
-class SequenceVisitor
-  include Visitor
-
-  def initialize(*visitors)
-    @visitors = visitors
-  end
-
-  def visit(obj)
-    @visitors.each {|v| obj.accept_visitor(v)}
-  end
-end

data/tests/acceptance/rockit/dparser/atest_any_operator.rb

@@ -1,33 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestAnyOperator < Test::Unit::TestCase
-  AnyTestGrammar = Rockit::DParser::Grammar.new do
-    start :S, [["a", any("b", "c"), any(:D, :E), ast(:S, 0, 1, 2)]]
-    ("d".."e").map {|s| term(s.upcase.intern, s)}
-  end
-
-  Parser = AnyTestGrammar.new_parser
-
-  def test_01
-    ast = Parser.parse "abd"
-    assert_equal("a", ast[0])
-    assert_equal("b", ast[1])
-    assert_equal("d", ast[2])
-
-    ast = Parser.parse "abe"
-    assert_equal("a", ast[0])
-    assert_equal("b", ast[1])
-    assert_equal("e", ast[2])
-
-    ast = Parser.parse "acd"
-    assert_equal("a", ast[0])
-    assert_equal("c", ast[1])
-    assert_equal("d", ast[2])
-
-    ast = Parser.parse "ace"
-    assert_equal("a", ast[0])
-    assert_equal("c", ast[1])
-    assert_equal("e", ast[2])
-  end
-end

data/tests/acceptance/rockit/dparser/atest_arithmetic_grammar.rb

@@ -1,30 +0,0 @@
-require 'test/unit'
-require 'rockit/dparser'
-
-class ATestArithmeticGrammar < Test::Unit::TestCase
-  ArithmeticTestGrammar = Rockit::DParser::Grammar.new do
-    start :Expr, [
-      [:Digit, "+", :Digit, ast(:Add, 0, 2)],
-      [:Digit, "*", :Digit, ast(:Mult, 0, 2)],
-    ]
-    term :Digit, /[0-9]+/
-  end
-
-  def test_03_use_parser
-    parser = ArithmeticTestGrammar.new_parser
-
-    ast = parser.parse "12+34"
-    assert_equal("Add", ast.name)
-    assert_kind_of(parser.astclass_of_name(:Add), ast)
-    assert_equal(2, ast.num_children)
-    assert_equal("12", ast[0])
-    assert_equal("34", ast[1])
-
-    ast = parser.parse "567*980"
-    assert_equal("Mult", ast.name)
-    assert_kind_of(parser.astclass_of_name(:Mult), ast)
-    assert_equal(2, ast.num_children)
-    assert_equal("567", ast[0])
-    assert_equal("980", ast[1])
-  end
-end