ParseTree 3.0.2-x86-mingw32 → 3.0.3-x86-mingw32

data/History.txt

@@ -1,3 +1,12 @@
+=== 3.0.3 / 2009-01-20
+
+* 4 bug fixes:
+
+  * Added gauntlet_parsetree.rb. Bug finding/fixing much faster & easier now.
+  * Fixed alias tests for r2r. Added masgn and heredoc tests.
+  * Fixed conflicting flags (-u vs -r).
+  * Unwrap RHS from array IF it is only a splat node.
+
 === 3.0.2 / 2008-11-04
 
 * 1 minor enhancement:

data/Manifest.txt

@@ -8,6 +8,7 @@ bin/parse_tree_audit
 bin/parse_tree_deps
 bin/parse_tree_show
 demo/printer.rb
+lib/gauntlet_parsetree.rb
 lib/parse_tree.rb
 lib/parse_tree_extensions.rb
 lib/unified_ruby.rb

data/bin/parse_tree_show

@@ -13,7 +13,7 @@ $s ||= false
 $U ||= false
 $n = $n.intern if $n
 
-$u ||= ! $U
+$u ||= ! ($U || $r)
 
 if $h then
   puts "usage: #{File.basename $0} [options] [file...]"

data/lib/gauntlet_parsetree.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/ruby -ws
+
+$f ||= false
+
+$:.unshift "../../ruby_parser/dev/lib"
+$:.unshift "../../ParseTree/dev/lib"
+
+require 'rubygems'
+require 'parse_tree'
+require 'ruby_parser'
+
+require 'gauntlet'
+
+class ParseTreeGauntlet < Gauntlet
+  def initialize
+    super
+
+    self.data = Hash.new { |h,k| h[k] = {} }
+    old_data = load_yaml data_file
+    self.data.merge! old_data
+  end
+
+  def should_skip? name
+    if $f then
+      if Hash === data[name] then
+        ! data[name].empty?
+      else
+        data[name]
+      end
+    else
+      data[name] == true # yes, == true on purpose
+    end
+  end
+
+  def diff_pp o1, o2
+    require 'pp'
+
+    File.open("/tmp/a.#{$$}", "w") do |f|
+      PP.pp o1, f
+    end
+
+    File.open("/tmp/b.#{$$}", "w") do |f|
+      PP.pp o2, f
+    end
+
+    `diff -u /tmp/a.#{$$} /tmp/b.#{$$}`
+  ensure
+    File.unlink "/tmp/a.#{$$}" rescue nil
+    File.unlink "/tmp/b.#{$$}" rescue nil
+  end
+
+  def broke name, file, msg
+    warn "bad"
+    self.data[name][file] = msg
+    self.dirty = true
+  end
+
+  def process path, name
+    begin
+      $stderr.print "  #{path}: "
+      rp = RubyParser.new
+      pt = ParseTree.new
+
+      old_ruby = File.read(path)
+
+      begin
+        pt_sexp = pt.process old_ruby
+      rescue SyntaxError => e
+        warn "unparsable pt"
+        self.data[name][path] = :unparsable_pt
+        self.dirty = true
+        return
+      end
+
+      begin
+        rp_sexp = rp.process old_ruby
+      rescue Racc::ParseError => e
+        broke name, path, e.message
+        return
+      end
+
+      if rp_sexp != pt_sexp then
+        broke name, path, diff_pp(rp_sexp, pt_sexp)
+        return
+      end
+
+      self.data[name][path] = true
+      self.dirty = true
+
+      warn "good"
+    rescue Interrupt
+      puts "User cancelled"
+      exit 1
+    rescue Exception => e
+      broke name, path, "    UNKNOWN ERROR: #{e}: #{e.message.strip}"
+    end
+  end
+
+  def run name
+    warn name
+    Dir["**/*.rb"].sort.each do |path|
+      next if path =~ /gemspec.rb/ # HACK
+      result = data[name][path]
+      next if result == true || Symbol === result
+      process path, name
+    end
+
+    if (self.data[name].empty? or
+        self.data[name].values.all? { |v| v == true }) then
+      warn "  ALL GOOD!"
+      self.data[name] = true
+      self.dirty = true
+    end
+  end
+end
+
+filter = ARGV.shift
+filter = Regexp.new filter if filter
+
+gauntlet = ParseTreeGauntlet.new
+gauntlet.run_the_gauntlet filter

data/lib/parse_tree.rb

@@ -43,7 +43,7 @@ end
 
 class RawParseTree
 
-  VERSION = '3.0.2'
+  VERSION = '3.0.3'
 
   ##
   # Front end translation method.

data/lib/unified_ruby.rb

@@ -236,6 +236,10 @@ module UnifiedRuby
       lhs << lhs_splat
     end
 
+    # unwrap RHS from array IF it is only a splat node
+    rhs = rhs.last if rhs && # TODO: rhs.structure =~ s(:array, s(:splat))
+      rhs.size == 2 && rhs.structure.flatten.first(2) == [:array, :splat]
+
     s(t, lhs, rhs).compact
   end
 

data/test/pt_testcase.rb

@@ -213,8 +213,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
             "RawParseTree" => [:class, :X, nil,
                                [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
             "ParseTree"    => s(:class, :X, nil,
-                                s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))),
-            "Ruby2Ruby"    => "class X\n  alias_method :y, :x\nend")
+                                s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))))
 
   add_tests("alias_ugh",
             "Ruby"         => "class X\n  alias y x\nend",
@@ -222,7 +221,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
             "ParseTree"    => s(:class, :X, nil,
                                 s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))),
-            "Ruby2Ruby"    => "class X\n  alias_method :y, :x\nend")
+            "Ruby2Ruby"    => "class X\n  alias :y :x\nend")
 
   add_tests("and",
             "Ruby"         => "(a and b)",
@@ -3093,7 +3092,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                       s(:lit, 2),
                                       s(:lit, 3))))))
 
-  add_tests("masgn_splat",
+  add_tests("masgn_splat_lhs",
             "Ruby"         => "a, b, *c = d, e, f, g",
             "RawParseTree" => [:masgn,
                                [:array, [:lasgn, :a], [:lasgn, :b]],
@@ -3112,6 +3111,35 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                   s(:call, nil, :f, s(:arglist)),
                                   s(:call, nil, :g, s(:arglist)))))
 
+  add_tests("masgn_splat_rhs_1",
+            "Ruby"         => "a, b = *c",
+            "RawParseTree" => [:masgn,
+                               [:array, [:lasgn, :a], [:lasgn, :b]],
+                               nil,
+                               [:splat, [:vcall, :c]]],
+            "ParseTree"    => s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :a),
+                                  s(:lasgn, :b)),
+                                s(:splat, s(:call, nil, :c, s(:arglist)))))
+
+  add_tests("masgn_splat_rhs_n",
+            "Ruby"         => "a, b = c, d, *e",
+            "RawParseTree" => [:masgn,
+                               [:array, [:lasgn, :a], [:lasgn, :b]],
+                               nil,
+                               [:argscat,
+                                [:array, [:vcall, :c], [:vcall, :d]],
+                                [:vcall, :e]]],
+            "ParseTree"    => s(:masgn,
+                                s(:array,
+                                  s(:lasgn, :a),
+                                  s(:lasgn, :b)),
+                                s(:array,
+                                  s(:call, nil, :c, s(:arglist)),
+                                  s(:call, nil, :d, s(:arglist)),
+                                  s(:splat, s(:call, nil, :e, s(:arglist))))))
+
   add_tests("masgn_splat_no_name_to_ary",
             "Ruby"         => "a, b, * = c",
             "RawParseTree" => [:masgn,
@@ -3901,6 +3929,12 @@ class ParseTreeTestCase < Test::Unit::TestCase
                                       s(:arglist, s(:str, "  second\n")))))),
             "Ruby2Ruby"    => "a = (a + ((\"  first\\n\" + b) + \"  second\\n\"))")
 
+  add_tests("str_heredoc_empty", # yes... tarded
+            "Ruby"         => "<<'EOM'\nEOM",
+            "RawParseTree" => [:str, ""],
+            "ParseTree"    => s(:str, ""),
+            "Ruby2Ruby"    => '""')
+
   add_tests("str_heredoc_indent",
             "Ruby"         => "<<-EOM\n  blah\nblah\n\n  EOM",
             "RawParseTree" => [:str, "  blah\nblah\n\n"],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 3.0.2
+  version: 3.0.3
 platform: x86-mingw32
 authors: 
 - Ryan Davis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-05 00:00:00 -03:00
+date: 2009-01-20 00:00:00 -02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -67,6 +67,7 @@ files:
 - bin/parse_tree_deps
 - bin/parse_tree_show
 - demo/printer.rb
+- lib/gauntlet_parsetree.rb
 - lib/parse_tree.rb
 - lib/parse_tree_extensions.rb
 - lib/unified_ruby.rb
@@ -103,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: parsetree
-rubygems_version: 1.3.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers