antlr3 1.2.3

data/lib/antlr3/test/call-stack.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby
+
+unless defined? Call
+  
+Call = Struct.new(:file, :line, :method)
+class Call
+  
+  def self.parse(call_string)
+    parts = call_string.split(':', 3)
+    file = parts.shift
+    line = parts.shift.to_i
+    if parts.empty?
+        return Call.new(file, line)
+    else
+        mstring = parts.shift
+        match = mstring.match(/`(.+)'/)
+        method = match ? match[1] : nil
+        return Call.new(file, line, method)
+    end
+  end
+  
+  def self.convert_backtrace( trace )
+    trace.map { |c| parse c }
+  end
+  
+  def irb?
+    self.file == '(irb)'
+  end
+  
+  def e_switch?
+    self.file == '-e'
+  end
+  
+  def to_s
+    string = '%s:%i' % [file, line]
+    method and string << ":in `%s'" % method
+    return(string)
+  end
+  
+  def inspect
+    to_s.inspect
+  end
+end
+
+module Kernel
+  def call_stack(depth = 1)
+    Call.convert_backtrace(caller(depth + 1))
+  end
+end
+
+class Exception
+  def backtrace!
+    Call.convert_backtrace(backtrace)
+  end
+end
+
+end # unless defined? Call

data/lib/antlr3/test/config.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+=begin      ::about::
+author:     Kyle Yetter <kcy5b@yahoo.com>
+created on: October 11, 2009
+=end
+
+module ANTLR3
+module Test
+
+require 'rbconfig'
+path_sep = RbConfig::CONFIG['PATH_SEPARATOR']
+
+
+
+exec_path = ENV['PATH'].split(path_sep)
+
+
+
+
+end
+end

data/lib/antlr3/test/core-extensions.rb

@@ -0,0 +1,269 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+class String
+  def /(subpath)
+    File.join(self, subpath.to_s)
+  end
+
+  def here_indent(chr = '| ')
+    dup.here_indent!(chr)
+  end
+
+  def here_indent!(chr = '| ')
+    chr = Regexp.escape(chr)
+    exp = Regexp.new("^ *#{chr}")
+    self.gsub!(exp,'')
+    return self
+  end
+
+  def here_flow(chr = '| ')
+    dup.here_flow!(chr)
+  end
+
+  def here_flow!(chr = '| ')
+    here_indent!(chr).gsub!(/\n\s+/,' ')
+    return(self)
+  end
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  #  CREDIT: Gavin Sinclair
+  #  CREDIT: Trans
+
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+
+  # Outdent just indents a negative number of spaces.
+  #
+  #  CREDIT: Noah Gibbs
+
+  def outdent(n)
+    indent(-n)
+  end
+  
+  # Returns the shortest length of leading whitespace for all non-blank lines
+  #
+  #   n = %Q(
+  #     a = 3
+  #       b = 4
+  #   ).level_of_indent  #=> 2
+  #
+  #   CREDIT: Kyle Yetter
+  def level_of_indent
+    self.scan(/^ *(?=\S)/).map { |space| space.length }.min || 0
+  end
+  
+  def fixed_indent(n)
+    self.outdent(self.level_of_indent).indent(n)
+  end
+  
+  # Provides a margin controlled string.
+  #
+  #   x = %Q{
+  #         | This
+  #         |   is
+  #         |     margin controlled!
+  #         }.margin
+  #
+  #
+  #   NOTE: This may still need a bit of tweaking.
+  #
+  #  CREDIT: Trans
+
+  def margin(n=0)
+    #d = /\A.*\n\s*(.)/.match( self )[1]
+    #d = /\A\s*(.)/.match( self)[1] unless d
+    d = ((/\A.*\n\s*(.)/.match(self)) ||
+        (/\A\s*(.)/.match(self)))[1]
+    return '' unless d
+    if n == 0
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
+    else
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * n)
+    end
+  end
+
+  # Expands tabs to +n+ spaces.  Non-destructive.  If +n+ is 0, then tabs are
+  # simply removed.  Raises an exception if +n+ is negative.
+  #
+  # Thanks to GGaramuno for a more efficient algorithm.  Very nice.
+  #
+  #  CREDIT: Gavin Sinclair
+  #  CREDIT: Noah Gibbs
+  #  CREDIT: GGaramuno
+
+  def expand_tabs(n=8)
+    n = n.to_int
+    raise ArgumentError, "n must be >= 0" if n < 0
+    return gsub(/\t/, "") if n == 0
+    return gsub(/\t/, " ") if n == 1
+    str = self.dup
+    while
+      str.gsub!(/^([^\t\n]*)(\t+)/) { |f|
+        val = ( n * $2.size - ($1.size % n) )
+        $1 << (' ' * val)
+      }
+    end
+    str
+  end
+
+
+  # The reverse of +camelcase+. Makes an underscored of a camelcase string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "SnakeCase".snakecase           #=> "snake_case"
+  #   "Snake-Case".snakecase          #=> "snake_case"
+  #   "SnakeCase::Errors".underscore  #=> "snake_case/errors"
+
+  def snakecase
+    gsub(/::/, '/').  # NOT SO SURE ABOUT THIS -T
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+end
+
+
+class Module
+  # Returns the module's container module.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Example::Demo.modspace   #=> Example
+  #
+  # See also Module#basename.
+  #
+  #   CREDIT: Trans
+
+  def modspace
+    space = name[ 0...(name.rindex( '::' ) || 0)]
+    space.empty? ? Object : eval(space)
+  end
+end
+
+module Kernel
+  autoload :Tempfile, 'tempfile'
+  
+  def screen_width(out=STDERR)
+    default_width = ENV['COLUMNS'] || 80
+    tiocgwinsz = 0x5413
+    data = [0, 0, 0, 0].pack("SSSS")
+    if out.ioctl(tiocgwinsz, data) >= 0 then
+      rows, cols, xpixels, ypixels = data.unpack("SSSS")
+      if cols >= 0 then cols else default_width end
+    else
+      default_width
+    end
+  rescue Exception => e
+    default_width rescue (raise e)
+  end
+end
+
+
+class File
+  
+  # Given some target path string, and an optional reference path
+  # (Dir.pwd by default), this method returns a string containing
+  # the relative path of the target path from the reference path
+  # 
+  # Examples:
+  #    File.relative_path('rel/path')   # => './rel/path'
+  #    File.relative_path('/some/abs/path', '/some')  # => './abs/path'
+  #    File.relative_path('/some/file.txt', '/some/abs/path')  # => '../../file.txt'
+  def self.relative_path(target, reference = Dir.pwd)
+    pair = [target, reference].map! do |path|
+      File.expand_path(path.to_s).split(File::Separator).tap do |list|
+        if list.empty? then list << String.new(File::Separator)
+        elsif list.first.empty? then list.first.replace(File::Separator)
+        end
+      end
+    end
+
+    target_list, reference_list = pair
+    while target_list.first == reference_list.first
+      target_list.shift
+      reference_list.shift or break
+    end
+    
+    relative_list = Array.new(reference_list.length, '..')
+    relative_list.empty? and relative_list << '.'
+    relative_list.concat(target_list).compact!
+    return relative_list.join(File::Separator)
+  end
+  
+end
+
+class Dir
+  defined?(DOTS) or DOTS = %w(. ..).freeze
+  def self.children(directory)
+    entries = Dir.entries(directory) - DOTS
+    entries.map! do |entry|
+      File.join(directory, entry)
+    end
+  end
+  
+  def self.mkpath(path)
+    $VERBOSE and $stderr.puts("INFO: Dir.mkpath(%p)" % path)
+    test(?d, path) and return(path)
+    parent = File.dirname(path)
+    test(?d, parent) or mkpath(parent)
+    Dir.mkdir(path)
+    return(path)
+  end
+  
+end
+
+class Array
+
+  # Pad an array with a given <tt>value</tt> upto a given <tt>length</tt>.
+  #
+  #   [0,1,2].pad(6,"a")  #=> [0,1,2,"a","a","a"]
+  #
+  # If <tt>length</tt> is a negative number padding will be added
+  # to the beginning of the array.
+  #
+  #   [0,1,2].pad(-6,"a")  #=> ["a","a","a",0,1,2]
+  #
+  #  CREDIT: Richard Laugesen
+
+  def pad(len, val=nil)
+    return dup if self.size >= len.abs
+    if len < 0
+      Array.new((len+size).abs,val) + self
+    else
+      self + Array.new(len-size,val)
+    end
+  end
+
+  # Like #pad but changes the array in place.
+  #
+  #    a = [0,1,2]
+  #    a.pad!(6,"x")
+  #    a  #=> [0,1,2,"x","x","x"]
+  #
+  #  CREDIT: Richard Laugesen
+
+  def pad!(len, val=nil)
+    return self if self.size >= len.abs
+    if len < 0
+      replace Array.new((len+size).abs,val) + self
+    else
+      concat Array.new(len-size,val)
+    end
+  end
+
+end

data/lib/antlr3/test/diff.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module ANTLR3
+module Test
+module Diff
+  module_function
+  
+  # trim common head and tail elements of the two lists
+  def width
+    screen_width - 20
+  end
+  
+  def column_width
+    width / 2 - 1
+  end
+  
+  def segment(list_a, list_b)
+    # trim leading common elements
+    common_head = 0
+    list_a.zip(list_b) do |a, b|
+      a == b ? (common_head += 1) : break
+    end
+    head = list_a[0...common_head]
+    list_a = list_a[common_head..-1].reverse!
+    list_b = list_b[common_head..-1].reverse!
+    
+    
+    common_tail = 0
+    list_a.zip(list_b) { |a,b| a == b ? (common_tail += 1) : break }
+    tail = list_a[0...common_tail].reverse!
+    list_a = list_a[common_tail..-1].reverse!
+    list_b = list_b[common_tail..-1].reverse!
+    
+    return [head, tail, list_a, list_b]
+  end
+
+  def max(a,b)
+    case a <=> b
+    when -1 then b
+    else a
+    end
+  end
+  
+  def colorize(text, color)
+    lines = text.split("\n")
+    escape = 
+      case color
+      when :white then "\e[37m"
+      when :magenta then "\e[35m"
+      when :yellow then "\e[33m"
+      when :green then "\e[32m"
+      when :black then "\e[30m"
+      when :red then "\e[31m"
+      when :cyan then "\e[36m"
+      when :blue then "\e[34m"
+      end
+    lines.map! { |ln| escape + ln << "\e[\0m" }.join("\n")
+  end
+  
+  def display_shared(item)
+    colorize(pair(item, item), :green)
+  end
+  def display_addition(item)
+    colorize(pair(nil, item), :magenta)
+  end
+  def display_subtraction(item)
+    colorize(pair(item, nil), :red)
+  end
+  def wrapped_inspect(list)
+    width = column_width
+    list = list.map { |i| i.inspect }
+    list[-1] << ' ]'
+    
+    lines, line, joint = [], '[ ', ''
+    
+    add_line = proc do |l|
+      lines << l.ljust(width)
+      '  '
+    end
+    
+    for item in list
+      line << joint
+      leftover = width - line.length
+      if item.length > leftover
+        i = item.rindex(/\s+/, leftover - 1) || leftover
+        if 
+          line = add_line[line << item[0, i]]
+          item = item[i..-1]
+        else
+          
+        end
+      end
+      line << item
+      
+      d = item.length + 2
+      if line.length + d > width
+        line << ','
+        lines << line
+        line, joint = '  ', ''
+      else
+        joint = ", "
+      end
+    end
+    lines << line
+    
+    lines.join("\n")
+  end
+
+  def pair(x, y)
+    x = x ? wrapped_inspect(x).split("\n") : []
+    y = y ? wrapped_inspect(y).split("\n") : []
+    line_count = max(x.length, y.length)
+    x.pad!(line_count, '')
+    y.pad!(line_count, '')
+    
+    x.zip(y).map! { |pair| pair.map! { |i| i.ljust(column_width) }.join(' ') }.join("\n")
+  end
+
+  def compute_lcs(list_a, list_b)
+    m, n = list_a.length, list_b.length
+    lcs_matrix = Array.new(m + 1) do |row|
+      Array.new(n + 1, 0)
+    end
+    m.times do |i| n.times do |j|
+      if list_a[i] == list_b[j] then lcs_matrix[i+1][j+1] = lcs_matrix[i][j] + 1
+      else lcs_matrix[i+1][j+1] = max(lcs_matrix[i+1][j], lcs_matrix[i][j+1])
+      end
+    end end
+    return lcs_matrix
+  end
+
+  def partial_diff(out, a, b, lcs, i = a.length, j = b.length)
+    if i > 0 and j > 0 and a[i-1] == b[j-1]
+      partial_diff(out, a, b, lcs, i-1, j-1)
+      out << display_shared(a[i-1])
+    else
+      if j > 0 and i.zero? || lcs[i][j-1] >= lcs[i-1][j]
+        partial_diff(out,a,b,lcs,i,j-1)
+        out << display_addition(b[j-1])
+      elsif i > 0 and j.zero? || lcs[i][j-1] < lcs[i-1][j]
+        partial_diff(out, a,b,lcs,i-1,j)
+        out << display_subtraction(a[i-1])
+      end
+    end
+    return out
+  end
+  
+  def diff(a, b, options = {})
+    head, tail, a, b = segment(a, b)
+    lcs = compute_lcs(a,b)
+    out = []
+    out << %w(Expected Got).map! { |w| w.ljust(column_width) }.join(' ')
+    head.each do |item|
+      out << display_shared(item)
+    end
+    partial_diff(out, a, b, lcs)
+    tail.each do |item|
+      out << display_shared(item)
+    end
+    out.join("\n")
+  end
+end
+end
+end