rockit 0.7.1 → 0.7.2

data/lib/rockit/prettyprint/box.rb

@@ -1,60 +0,0 @@
-# A Formatting Language similar to BOX described in
-#  [vandenbrand1996a] and [dejonge2003a]
-#
-module Rockit
-  module PrettyPrint
-    module Box
-      # An element of the Box language
-      class Term
-      end
-
-      # H formats its elements horizontally with a given number of spaces
-      # in between.
-      class H < Term
-	attr_reader :num_hdelims, :elements
-
-	def initialize(numHorizontalDelims = 1, *elements)
-	  @num_hdelims = numHdelims
-	  @elements = elements
-	end
-      end
-
-      # H formats its elements horizontally with a given number of spaces
-      # in between.
-      class V < Term
-	attr_reader :elements
-
-	def initialize(*elements)
-	  @elements = elements
-	end
-      end
-
-      # Epsilon is a H operator with no spaces in between
-      class Epsilon < H
-	def initialize(*elements)
-	  super(0, *elements)
-	end
-      end
-    end
-  end
-end
-
-require 'rockit/prettyprint/text_renderer'
-
-# We must do the def's below after requiring the text_renderer
-# since there is a circular dependency between the definitions.
-module Rockit
-  module PrettyPrint
-    module Box
-      class Term
-	def render
-	  render_on(Box::TextRenderer.new)
-	end
-
-	def render_on(renderer)
-	  renderer.render(self)
-	end
-      end
-    end
-  end
-end

data/lib/rockit/prettyprint/renderer.rb

@@ -1,41 +0,0 @@
-# Renderers for Box
-#
-module Rockit
-  module PrettyPrint
-    module Box
-      class Renderer
-	def reset_buffer
-	  @buffer = ""
-	end
-
-	def string_buffer
-	  @buffer
-	end
-
-	def render(boxTree)
-	  reset_buffer
-	  render_term(boxTree)
-	  string_buffer
-	end
-
-	def <<(string)
-	  @buffer << string
-	end
-
-	def render_term(boxTree)
-	  raise NotImplementedError
-	end
-
-	def render_hdelim(num)
-	  render_term(horizontal_delim * num)
-	end
-      end
-    end
-  end
-end
-
-class String
-  def render_as_text(renderer)
-    renderer << self
-  end
-end

data/lib/rockit/prettyprint/text_renderer.rb

@@ -1,47 +0,0 @@
-# Basic Text Renderer for Box
-#
-require 'rockit/prettyprint/renderer'
-
-module Rockit
-  module PrettyPrint
-    module Box
-      class TextRenderer < Renderer
-        attr_reader :max_horizontal
-        attr_reader :horizontal_delim, :vertical_delim
-        
-        def initialize(maxHorizontal = 80, horizontalDelim = " ",
-                       verticalDelim = "\n")
-          @max_horizontal = maxHorizontal
-          @horizontal_delim = horizontalDelim
-          @vertical_delim = verticalDelim
-        end
-
-	def render_term(term)
-	  # Instead of fiddling with visitors we simply add a uniquely named
-	  # method render_as_text to each Box term we support.
-	  term.render_as_text(self)
-	end
-      end
-
-      class H < Term
-	def render_as_text(renderer)
-	  elements[0..-2].each do |e|
-	    renderer.render_term(e)
-	    renderer.render_hdelim(num_spaces)
-	  end
-	  renderer.render_term(elements[-1])
-	end
-      end
-
-      class V < Term
-	def render_as_text(renderer)
-	  elements[0..-2].each do |e|
-	    renderer.render_term(e)
-	    renderer << "\n"
-	  end
-	  renderer.render_term(elements[-1])
-	end
-      end
-    end
-  end
-end

data/lib/rockit/tree/base.rb

@@ -1,223 +0,0 @@
-require 'pp'
-
-# Make sure Rockit module exists if we are loaded separetely from rest
-# of Rockit
-module Rockit; end 
-
-# Rockit::Tree defines a superclass for syntax trees. The trees has methods
-# for easily creating and pattern matching trees.
-module Rockit::Tree
-  class Base
-    include Enumerable
-    
-    def self.new_tree_class(name, children_names = [])
-      name_as_str = name.to_s
-      unless name_as_str =~ /^[A-Z]/
-	raise NameError, "identifier #{name} needs to be constant"
-      end
-      unless constants.include?(name_as_str)
-	s = <<-EOC
-        class #{name_as_str} < #{self.inspect}
-	    #{child_accessor_codes(children_names)}
-	end
-	EOC
-	class_eval s
-      end
-      class_eval "#{name_as_str}"
-    end
-
-    def self.child_accessor_codes(children_names)
-      i, s = 0, ""
-      while i < children_names.length
-	s += child_accessor_code(children_names[i], i)
-	i += 1
-      end
-      s
-    end
-
-    def self.child_accessor_code(children_name, index)
-      name = children_name.to_s
-      s = <<-EOC
-        def #{name}
-          @children[#{index}]
-        end
-	def #{name}=(newValue)
-	  @children[#{index}] = newValue
-        end
-      EOC
-    end
-
-    def self.[](*children)
-      new(*children)
-    end
-
-    attr_reader :children
-
-    def initialize(*children)
-      @children = children
-    end
-
-    def [](index)
-      self.children[index]
-    end
-
-    def num_children
-      self.children.length
-    end
-
-    def ==(other)
-      self.class == other.class && self.children == other.children
-    end
-
-    def inspect
-      class_name + "[" +
-        self.children.map {|c| c.inspect}.join(", ") + 
-        "]"
-    end
-
-    def class_name
-      self.class.inspect.split("::").last
-    end
-
-    def each_child
-      children.each {|c| yield(c)}
-    end
-
-    alias each each_child
-
-    # Depth-first traversal of (sub)trees in tree
-    def each_tree(&block)
-      block.call(self)
-      self.children.each do |c|
-	if Base === c
-	  c.each_tree(&block)
-	else
-	  block.call(c)
-	end
-      end
-    end
-
-    # Assuming klass is a subclass of Base
-    def each_tree_of_class(klass, recursive = false, &block)
-      cs = self.children
-      if self.kind_of?(klass)
-	block.call(self)
-	cs = [] unless recursive
-      end
-      cs.each do |c|
-	if Base === c
-	  c.each_tree_of_class(klass, recursive, &block)
-	elsif Array === c
-	  c.each {|ac| 
-	    ac.each_tree_of_class(klass, recursive, &block) if Base === ac
-	  }
-	end
-      end
-    end
-
-    def match_tree(tree, matches = Hash.new)
-      if self.class == tree.class && 
-	  self.num_children == tree.num_children
-        self.each_with_index do |child, i|
-	  unless child.match_tree(tree[i], matches)
-	    matches = nil
-	    break
-	  end
-        end
-	matches
-      else
-        nil
-      end
-    end
-
-    def =~(patternTree)
-      pattern = patternTree.upcase_symbols_to_pattern_vars
-      pattern.match_tree(self)
-    end
-
-    def select_trees_of_class(klass, recursive = false)
-      ary = []
-      each_tree_of_class(klass, recursive) {|t| ary << t}
-      ary
-    end
-
-    # Return all subtrees in tree which match the pattern self.
-    def all_matching_trees(tree)
-      # Only the subtrees with a root node of the right type are candidates
-      candidates = tree.select_trees_of_class(self.class, true)
-      pattern = self.upcase_symbols_to_pattern_vars
-      candidates.map do |t| 
-	res = pattern.match_tree(t)
-	res ? [res, t] : nil
-      end.compact
-    end
-  
-    # Representing a variable in a patternTree
-    class PatternVar
-      attr_reader :name
-
-      def initialize(name)
-	@name = name
-      end
-
-      # A variable match anything and the binding is noted in the matches
-      # hash.
-      def match_tree(tree, matches = Hash.new)
-	matches[@name] = tree
-	matches
-      end
-
-      def inspect
-	"Var_" + @name.to_s
-      end
-
-      # No need to def upcase_symbols_to_pattern_vars here since it
-      # inherits the one defined for Object below
-    end
-
-    # Convert upper case symbols to pattern variables 
-    def upcase_symbols_to_pattern_vars    
-      new_children = Array.new
-      self.each {|child| new_children << child.upcase_symbols_to_pattern_vars}
-      self.class.new(*new_children)
-    end
-
-    def pretty_print(pp)
-      pp.text class_name
-      pp.group(1, '[', ']') do 
-	pp.breakable ""
-	pp.seplist(self.children) {|c| pp.pp c}
-      end
-    end
-
-    # The nodes in a tree are not linked upwards by default but by calling
-    # the set_parents method on the root the parent attribute on each subtree
-    # is set and can then be accessed.
-    attr_accessor :parent
-
-    def set_parents(parent = nil)
-      self.parent = parent
-      each_child {|c| c.set_parents(self) if c.kind_of?(Base)}
-    end
-  end
-end
-
-class Object
-  def match_tree(tree, matches = Hash.new)
-    self == tree
-  end
-  
-  def upcase_symbols_to_pattern_vars
-    self
-  end
-end
-
-class Symbol
-  def upcase_symbols_to_pattern_vars
-    if self.to_s =~ /^[A-Z]/
-      Rockit::Tree::Base::PatternVar.new(self)
-    else
-      self
-    end
-  end
-end

data/lib/rockit/tree/enter_leave_visitor.rb

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

data/lib/rockit/tree/graphviz.rb

@@ -1,69 +0,0 @@
-require 'rockit/tree/base'
-
-class Object
-  def to_graphviz_node_label; inspect; end
-  def to_graphviz_printer(printer); printer; end
-end
-
-class Array
-  def to_graphviz_node_label; "[]"; end
-  def to_graphviz_printer(printer)
-    label = printer.unique(self)
-    each do |child|
-      printer.add(label, child)
-      child.to_graphviz_printer(printer)
-    end
-    printer
-  end
-end
-
-class DotPrinter
-  def initialize
-    @links = []
-    @counts = Hash.new(0)
-  end
-
-  def unique(obj)
-    num = (@counts[obj.class] += 1)
-    obj.to_graphviz_node_label + " (#{num})"
-  end
-
-  def add(from, to)
-    @links << [from.to_graphviz_node_label, to.to_graphviz_node_label]
-  end
-
-  def to_dot_file
-    "digraph {" +
-      @links.uniq.map {|from, to| "#{from.inspect} -> #{to.inspect};"}.join("\n") +
-      "}"
-  end
-
-  def write_to_file(filename, format = "ps")
-    tmpfilename = "temp" + Time.now.strftime("%M%S_") + rand(1e10).inspect
-    File.open(tmpfilename, "w") do |fh|
-      fh.write self.to_dot_file
-      system "dot -T#{format} #{tmpfilename} > #{filename}"
-    end
-    # File.delete(tmpfilename)
-  end
-end
-
-module Rockit::Tree
-  class Base
-    def to_graphviz_printer(printer = DotPrinter.new)
-      children.each do |child|
-	printer.add(self, child)
-	child.to_graphviz_printer(printer)
-      end
-      printer
-    end
-
-    def to_graphviz_node_label
-      class_name_as_string
-    end
-
-    def class_name_as_string
-      self.class.inspect.split("::").last
-    end
-  end
-end