ParseTree 1.4.0 → 1.4.1

data/History.txt

@@ -1,3 +1,15 @@
+*** 1.4.1 / 2006-04-10
+
++ 4 minor enhancements:
+	+ parse_tree_show -f output is much cleaner now.
+	+ ParseTree does a much more elegant job of handling different versions.
+	+ ParseTree now has all node names in ParseTree::NODE_NAMES.
+	+ ParseTree now raises exceptions instead of freakin'.
++ 3 bug fixes:
+	+ Used multiruby to test against 1.8.2-4, 1.8 cvs, and 1.9 cvs.
+	+ Fixed incompatibilites introduced in ruby 1.8.4.
+	+ Fixed some incompatibilites introduced in ruby 1.9.x.
+
 *** 1.4.0 / 2005-10-15
 
 + 5 minor enhancements

data/Manifest.txt

@@ -1,5 +1,5 @@
 History.txt
-Makefile
+Rakefile
 Manifest.txt
 ParseTree.gemspec
 README.txt

data/README.txt

@@ -1,4 +1,5 @@
 ParseTree
+    http://rubyforge.org/projects/parsetree/
     http://www.zenspider.com/ZSS/Products/ParseTree/
     support@zenspider.com
 
@@ -36,10 +37,12 @@ becomes:
 + Uses RubyInline, so it just drops in.
 + Includes SexpProcessor and CompositeSexpProcessor.
 	+ Allows you to write very clean filters.
-+ Includes show.rb, which lets you quickly snoop code.
-+ Includes abc.rb, which lets you get abc metrics on code.
++ Includes parse_tree_show, which lets you quickly snoop code.
+	+ echo "1+1" | parse_tree_show -f for quick snippet output.
++ Includes parse_tree_abc, which lets you get abc metrics on code.
 	+ abc metrics = numbers of assignments, branches, and calls.
 	+ whitespace independent metric for method complexity.
++ Includes parse_tree_deps, which shows you basic class level dependencies.
 + Only works on methods in classes/modules, not arbitrary code.
 + Does not work on the core classes, as they are not ruby (yet).
 
@@ -64,6 +67,10 @@ or:
 
   % ./parse_tree_show myfile.rb
 
+or:
+
+  % echo "1+1" | ./parse_tree_show -f
+
 or:
 
   % ./parse_tree_abc myfile.rb
@@ -74,9 +81,8 @@ or:
 
 ** INSTALL:
 
-+ sudo make install
-	+ renames show.rb to parse_tree_show
-	+ renames abc.rb to parse_tree_abc
++ sudo rake install
++ or: sudo gem install ParseTree
 
 ** LICENSE:
 

data/Rakefile

@@ -0,0 +1,80 @@
+# -*- ruby -*-
+
+require 'rbconfig'
+require 'rake/rdoctask'
+
+PREFIX = ENV['PREFIX'] || Config::CONFIG['prefix']
+RUBYLIB = Config::CONFIG['sitelibdir']
+RUBY_DEBUG = ENV['RUBY_DEBUG']
+RUBY_FLAGS = ENV['RUBY_FLAGS'] || "-w -Ilib#{File::PATH_SEPARATOR}bin#{File::PATH_SEPARATOR}../../RubyInline/dev"
+FILTER = ENV['FILTER']
+
+LIB_FILES = %w(composite_sexp_processor.rb parse_tree.rb sexp.rb sexp_processor.rb)
+TEST_FILES = %w(test_sexp_processor.rb)
+BIN_FILES = %w(parse_tree_abc parse_tree_show parse_tree_deps)
+
+task :default => :test
+
+task :test do
+  ruby "#{RUBY_FLAGS} test/test_all.rb #{FILTER}"
+end
+
+task :multi do
+  sh "multiruby #{RUBY_FLAGS} test/test_all.rb #{FILTER}"
+end
+
+# we only install test_sexp_processor.rb to help make ruby_to_c's
+# subclass tests work.
+
+Rake::RDocTask.new(:docs) do |rd|
+  rd.main = "SexpProcessor"
+  rd.rdoc_files.include('./**/*').exclude('something.rb').exclude('test_*')
+  rd.options << '-d'
+  rd.options << '-Ipng'
+end
+
+task :install do
+  [
+   ['lib', LIB_FILES, RUBYLIB, 0444],
+   ['test', TEST_FILES, RUBYLIB, 0444],
+   ['bin', BIN_FILES, File.join(PREFIX, 'bin'), 0555]
+  ].each do |dir, list, dest, mode|
+    Dir.chdir dir do
+      list.each do |f|
+        install f, dest, :mode => mode
+      end
+    end
+  end
+end
+
+task :uninstall do
+  Dir.chdir RUBYLIB do
+    rm_f LIB_FILES
+    rm_f TEST_FILES
+  end
+  Dir.chdir File.join(PREFIX, 'bin') do
+    rm_f BIN_FILES
+  end
+end
+
+task :audit do
+  sh "ZenTest -Ilib#{File::PATH_SEPARATOR}test #{LIB_FILES.collect{|e| File.join('lib', e)}.join(' ')} test/test_all.rb"
+  # test_composite_sexp_processor.rb test_sexp_processor.rb
+end
+
+task :clean do
+  inline_dir = File.expand_path("~/.ruby_inline")
+  rm_rf inline_dir if test ?d, inline_dir
+  %w(diff diff.txt demo.rb *.gem **/*~).each do |pattern|
+    files = Dir[pattern]
+    rm_rf files unless files.empty?
+  end
+end
+
+task :demo do
+  verbose(false){sh "echo 1+1 | ruby #{RUBY_FLAGS} ./bin/parse_tree_show -f"}
+end
+
+task :gem do
+  ruby "ParseTree.gemspec"
+end

data/bin/parse_tree_show

@@ -38,6 +38,9 @@ new_classes = discover_new_classes_from do
 end
 
 result = ParseTree.new.parse_tree(*new_classes)
+
+result = result[0][3][2][1][2..-1] if $f
+
 unless defined? $q then
   pp result
 else

data/lib/parse_tree.rb

@@ -1,6 +1,7 @@
 #!/usr/local/bin/ruby -w
 
-begin require 'rubygems' rescue LoadError end
+begin require 'rubygems'; rescue LoadError; end
+
 require 'inline'
 
 ##
@@ -24,7 +25,7 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.4.0'
+  VERSION = '1.4.1'
 
   ##
   # Initializes a ParseTree instance. Includes newline nodes if
@@ -94,15 +95,87 @@ class ParseTree
     parse_tree_for_meth(klass, method.to_sym, @include_newlines)
   end
 
+  if RUBY_VERSION < "1.8.4" then
+    inline do |builder|
+      builder.add_type_converter("bool", '', '')
+      builder.c_singleton "
+        bool has_alloca() {
+          (void)self;
+          #ifdef C_ALLOCA
+            return Qtrue;
+          #else
+            return Qfalse;
+          #endif
+          }"
+    end
+  else
+    def self.has_alloca
+      true
+    end
+  end
+
+
+  NODE_NAMES = [
+                #  00
+                :method, :fbody, :cfunc, :scope, :block,
+                :if, :case, :when, :opt_n, :while,
+                #  10
+                :until, :iter, :for, :break, :next,
+                :redo, :retry, :begin, :rescue, :resbody,
+                #  20
+                :ensure, :and, :or, :not, :masgn,
+                :lasgn, :dasgn, :dasgn_curr, :gasgn, :iasgn,
+                #  30
+                :cdecl, :cvasgn, :cvdecl, :op_asgn1, :op_asgn2,
+                :op_asgn_and, :op_asgn_or, :call, :fcall, :vcall,
+                #  40
+                :super, :zsuper, :array, :zarray, :hash,
+                :return, :yield, :lvar, :dvar, :gvar,
+                #  50
+                :ivar, :const, :cvar, :nth_ref, :back_ref,
+                :match, :match2, :match3, :lit, :str,
+                #  60
+                :dstr, :xstr, :dxstr, :evstr, :dregx,
+                :dregx_once, :args, :argscat, :argspush, :splat,
+                #  70
+                :to_ary, :svalue, :block_arg, :block_pass, :defn,
+                :defs, :alias, :valias, :undef, :class,
+                #  80
+                :module, :sclass, :colon2, :colon3, :cref,
+                :dot2, :dot3, :flip2, :flip3, :attrset,
+                #  90
+                :self, :nil, :true, :false, :defined,
+                #  95
+                :newline, :postexe, :alloca, :dmethod, :bmethod,
+                # 100
+                :memo, :ifunc, :dsym, :attrasgn,
+                # 104
+                :last
+               ]
+
+  if RUBY_VERSION < "1.8.4" then
+    NODE_NAMES.delete :alloca unless has_alloca
+  end
+
+  if RUBY_VERSION > "1.9" then
+    NODE_NAMES.insert NODE_NAMES.index(:hash), :values
+    NODE_NAMES.insert NODE_NAMES.index(:defined), :errinfo
+    NODE_NAMES.insert NODE_NAMES.index(:last), :prelude, :lambda
+    NODE_NAMES.delete :dmethod
+    NODE_NAMES[128] = NODE_NAMES.delete :newline
+  end
+
   ############################################################
   # END of rdoc methods
   ############################################################
 
   inline do |builder|
+    builder.add_type_converter("bool", '', '')
     builder.add_type_converter("VALUE", '', '')
     builder.add_type_converter("ID *", '', '')
     builder.add_type_converter("NODE *", '(NODE *)', '(VALUE)')
     builder.include '"intern.h"'
+    builder.include '"version.h"'
     builder.include '"node.h"'
     builder.include '"st.h"'
     builder.include '"env.h"'
@@ -129,14 +202,20 @@ class ParseTree
     # builder.add_compile_flags "-Wmissing-prototypes"
     # builder.add_compile_flags "-Wsign-compare"
 
+    def self.if_version(test, version, str)
+      RUBY_VERSION.send(test, version) ? str : ""
+    end
+
     builder.prefix %{
         #define nd_3rd   u3.node
+    }
 
+    builder.prefix %{
         struct METHOD {
           VALUE klass, rklass;
           VALUE recv;
           ID id, oid;
-          #{ RUBY_VERSION <= "1.8.2" ? "" : "int safe_level;" }
+#{if_version :>, "1.8.2", "int safe_level;"}
           NODE *body;
         };
 
@@ -159,51 +238,9 @@ class ParseTree
           struct BLOCK *outer;
           struct BLOCK *prev;
         };
+    } unless RUBY_VERSION >= "1.9"
 
-        static char node_type_string[][60] = {
-	  //  00
-	  "method", "fbody", "cfunc", "scope", "block",
-	  "if", "case", "when", "opt_n", "while",
-	  //  10
-	  "until", "iter", "for", "break", "next",
-	  "redo", "retry", "begin", "rescue", "resbody",
-	  //  20
-	  "ensure", "and", "or", "not", "masgn",
-	  "lasgn", "dasgn", "dasgn_curr", "gasgn", "iasgn",
-	  //  30
-	  "cdecl", "cvasgn", "cvdecl", "op_asgn1", "op_asgn2",
-	  "op_asgn_and", "op_asgn_or", "call", "fcall", "vcall",
-	  //  40
-	  "super", "zsuper", "array", "zarray", "hash",
-	  "return", "yield", "lvar", "dvar", "gvar",
-	  //  50
-	  "ivar", "const", "cvar", "nth_ref", "back_ref",
-	  "match", "match2", "match3", "lit", "str",
-	  //  60
-	  "dstr", "xstr", "dxstr", "evstr", "dregx",
-	  "dregx_once", "args", "argscat", "argspush", "splat",
-	  //  70
-	  "to_ary", "svalue", "block_arg", "block_pass", "defn",
-	  "defs", "alias", "valias", "undef", "class",
-	  //  80
-	  "module", "sclass", "colon2", "colon3", "cref",
-	  "dot2", "dot3", "flip2", "flip3", "attrset",
-	  //  90
-	  "self", "nil", "true", "false", "defined",
-	  //  95
-	  "newline", "postexe",
-#ifdef C_ALLOCA
-	  "alloca",
-#endif
-	  "dmethod", "bmethod",
-	  // 100 / 99
-	  "memo", "ifunc", "dsym", "attrasgn",
-	  // 104 / 103
-	  "last" 
-        };
-  }
-
-    builder.c_raw %q^
+  builder.c_raw %Q@
 static void add_to_parse_tree(VALUE ary,
                               NODE * n,
                               VALUE newlines,
@@ -213,16 +250,21 @@ static void add_to_parse_tree(VALUE ary,
   VALUE old_ary = Qnil;
   VALUE current;
   VALUE node_name;
+  static VALUE node_names = Qnil;
+
+  if (NIL_P(node_names)) {
+    node_names = rb_const_get_at(rb_const_get_at(rb_cObject,rb_intern("ParseTree")),rb_intern("NODE_NAMES"));
+  }
 
   if (!node) return;
 
 again:
 
   if (node) {
-    node_name = ID2SYM(rb_intern(node_type_string[nd_type(node)]));
+    node_name = rb_ary_entry(node_names, nd_type(node));
     if (RTEST(ruby_debug)) {
-      fprintf(stderr, "%15s: %s%s%s\n",
-        node_type_string[nd_type(node)],
+      fprintf(stderr, "%15s: %s%s%s\\n",
+        rb_id2name(SYM2ID(node_name)),
         (RNODE(node)->u1.node != NULL ? "u1 " : "   "),
         (RNODE(node)->u2.node != NULL ? "u2 " : "   "),
         (RNODE(node)->u3.node != NULL ? "u3 " : "   "));
@@ -244,7 +286,6 @@ again_no_block:
         add_to_parse_tree(current, node, newlines, locals);
         break;
       }
-
       contnode = node->nd_next;
 
       // NOTE: this will break the moment there is a block w/in a block
@@ -420,6 +461,7 @@ again_no_block:
     }
     break;
 
+#{if_version :>, "1.9", '#if 0'}
   case NODE_DMETHOD:
     {
       struct METHOD *data;
@@ -428,9 +470,10 @@ again_no_block:
       add_to_parse_tree(current, data->body, newlines, locals);
       break;
     }
+#{if_version :>, "1.9", '#endif'}
 
   case NODE_METHOD:
-    fprintf(stderr, "u1 = %p u2 = %p u3 = %p\n", node->nd_1st, node->nd_2nd, node->nd_3rd);
+    fprintf(stderr, "u1 = %p u2 = %p u3 = %p\\n", node->nd_1st, node->nd_2nd, node->nd_3rd);
     add_to_parse_tree(current, node->nd_3rd, newlines, locals);
     break;
 
@@ -564,12 +607,11 @@ again_no_block:
     add_to_parse_tree(current, node->nd_body, newlines, locals);
     break;
 
-  case NODE_ARGS:
-    if (locals && 
-	(node->nd_cnt || node->nd_opt || node->nd_rest != -1)) {
+  case NODE_ARGS: {
+    long arg_count = (long)node->nd_rest;
+    if (locals && (node->nd_cnt || node->nd_opt || arg_count != -1)) {
       int i;
       NODE *optnode;
-      long arg_count;
 
       for (i = 0; i < node->nd_cnt; i++) {
         // regular arg names
@@ -584,18 +626,19 @@ again_no_block:
 	optnode = optnode->nd_next;
       }
 
-      arg_count = node->nd_rest;
       if (arg_count > 0) {
         // *arg name
-        VALUE sym = rb_str_intern(rb_str_plus(rb_str_new2("*"), rb_str_new2(rb_id2name(locals[node->nd_rest + 1]))));
+        VALUE sym = rb_str_intern(rb_str_plus(rb_str_new2("*"), rb_str_new2(rb_id2name(locals[i + 3]))));
         rb_ary_push(current, sym);
+      } else if (arg_count == 0) {
+        // nothing to do in this case, empty list
       } else if (arg_count == -1) {
         // nothing to do in this case, handled above
       } else if (arg_count == -2) {
         // nothing to do in this case, no name == no use
       } else {
-        puts("not a clue what this arg value is");
-        exit(1);
+        rb_raise(rb_eArgError,
+                 "not a clue what this arg value is: %ld", arg_count);
       }
 
       optnode = node->nd_opt;
@@ -604,7 +647,7 @@ again_no_block:
 	add_to_parse_tree(current, node->nd_opt, newlines, locals);
       }
     }
-    break;
+  }  break;
 	
   case NODE_LVAR:
   case NODE_DVAR:
@@ -676,7 +719,7 @@ again_no_block:
     add_to_parse_tree(current, node->nd_3rd, newlines, locals);
     break;
 
-  case NODE_DSYM:               // :"#{foo}" u1 u2 u3
+  case NODE_DSYM:               // :"\#\{foo}" u1 u2 u3
     add_to_parse_tree(current, node->nd_3rd, newlines, locals);
     break;
 
@@ -702,11 +745,11 @@ again_no_block:
   // case NODE_LMASK:
   // case NODE_LSHIFT:
   default:
-    rb_warn("Unhandled node #%d type '%s'", nd_type(node), node_type_string[nd_type(node)]);
+    rb_warn("Unhandled node #%d type '%s'", nd_type(node), rb_id2name(SYM2ID(rb_ary_entry(node_names, nd_type(node)))));
     if (RNODE(node)->u1.node != NULL) rb_warning("unhandled u1 value");
     if (RNODE(node)->u2.node != NULL) rb_warning("unhandled u2 value");
     if (RNODE(node)->u3.node != NULL) rb_warning("unhandled u3 value");
-    if (RTEST(ruby_debug)) fprintf(stderr, "u1 = %p u2 = %p u3 = %p\n", node->nd_1st, node->nd_2nd, node->nd_3rd);
+    if (RTEST(ruby_debug)) fprintf(stderr, "u1 = %p u2 = %p u3 = %p\\n", node->nd_1st, node->nd_2nd, node->nd_3rd);
     rb_ary_push(current, INT2FIX(-99));
     rb_ary_push(current, INT2FIX(nd_type(node)));
     break;
@@ -722,9 +765,9 @@ again_no_block:
       goto again_no_block;
   }
 }
-^ # end of add_to_parse_tree block
+@ # end of add_to_parse_tree block
 
-    builder.c %q{
+    builder.c %Q{
 static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines) {
   VALUE n;
   NODE *node = NULL;
@@ -734,6 +777,11 @@ static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines) {
   (void) self; // quell warnings
   (void) argc; // quell warnings
 
+  VALUE version = rb_const_get_at(rb_cObject,rb_intern("RUBY_VERSION"));
+  if (strcmp(StringValuePtr(version), #{RUBY_VERSION.inspect})) {
+    rb_fatal("bad version, %s != #{RUBY_VERSION}\\n", StringValuePtr(version));
+  }
+
   id = rb_to_id(method);
   if (st_lookup(RCLASS(klass)->m_tbl, id, &n)) {
     node = (NODE*)n;

data/lib/sexp_processor.rb

@@ -133,7 +133,6 @@ class SexpProcessor
   # SexpProcessor
 
   def initialize
-    @collection = []
     @default_method = nil
     @warn_on_default = true
     @auto_shift_type = false

data/test/something.rb

@@ -202,8 +202,8 @@ class Something
   
   def self.dmethod_maker
     define_method :dmethod_added, self.method(:bmethod_maker)
-  end
+  end if RUBY_VERSION < "1.9"
   
   bmethod_maker
-  dmethod_maker
+  dmethod_maker if RUBY_VERSION < "1.9"
 end

data/test/test_parse_tree.rb

@@ -1,5 +1,12 @@
 #!/usr/local/bin/ruby -w
 
+dir = File.expand_path "~/.ruby_inline"
+if test ?d, dir then
+  require 'fileutils'
+  puts "nuking #{dir}"
+  FileUtils.rm_r dir
+end
+
 require 'test/unit'
 require 'parse_tree'
 require 'test/something'
@@ -308,7 +315,7 @@ class TestParseTree < Test::Unit::TestCase
     [:iter,
      [:fcall, :define_method, [:array, [:lit, :bmethod_added]]],
      [:dasgn_curr, :x],
-     [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]]
+     [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]] if RUBY_VERSION < "1.9"
 
   @@attrasgn = [:defn,
     :attrasgn,

metadata

@@ -1,10 +1,10 @@
-!ruby/object:Gem::Specification 
-rubygems_version: 0.8.11.1
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11.6
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
-date: 2005-10-17 00:00:00 -07:00
+  version: 1.4.1
+date: 2006-04-10 00:00:00 -07:00
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
 - lib
@@ -26,11 +26,12 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Ryan Davis
 files: 
 - History.txt
-- Makefile
+- Rakefile
 - Manifest.txt
 - README.txt
 - bin/parse_tree_abc

data/Makefile

@@ -1,57 +0,0 @@
-RUBY?=ruby
-RUBY_DEBUG?=
-RUBY_FLAGS?=-w -Ilib:bin:../../RubyInline/dev
-RUBY_LIB?=$(shell $(RUBY) -rrbconfig -e 'include Config; print CONFIG["sitelibdir"]')
-PREFIX?=/usr/local
-FILTER?=
-
-LIB_FILES= \
-	composite_sexp_processor.rb \
-	parse_tree.rb \
-	sexp.rb \
-	sexp_processor.rb \
-	$(END)
-
-TEST_FILES= \
-	test_sexp_processor.rb \
-	$(END)
-
-BIN_FILES= \
-	parse_tree_abc \
-	parse_tree_show \
-	parse_tree_deps \
-	$(END)
-
-all test: FORCE
-	$(RUBY) $(RUBY_DEBUG) $(RUBY_FLAGS) test/test_all.rb $(FILTER)
-
-# we only install test_sexp_processor.rb to help make ruby_to_c's
-# subclass tests work.
-
-docs:
-	rdoc -d -I png --main SexpProcessor -x test_\* -x something.rb
-
-install:
-	cd lib  && install -m 0444 $(LIB_FILES)  $(RUBY_LIB)
-	cd test && install -m 0444 $(TEST_FILES) $(RUBY_LIB)
-	cd bin  && install -m 0555 $(BIN_FILES)  $(PREFIX)/bin
-
-uninstall:
-	cd $(RUBY_LIB)   && rm -f $(LIB_FILES) $(TEST_FILES)
-	cd $(PREFIX)/bin && rm -f $(BIN_FILES)
-
-audit:
-	ZenTest -I=lib:test $(addprefix lib/,$(LIB_FILES)) test/test_all.rb
-# test_composite_sexp_processor.rb test_sexp_processor.rb
-
-clean:
-	-find . -name \*~ | xargs rm
-	-rm -fr diff diff.txt *.gem doc $$HOME/.ruby_inline
-
-demo:
-	echo 1+1 | $(RUBY) $(RUBY_FLAGS) ./bin/parse_tree_show -f
-
-gem:
-	ruby ParseTree.gemspec
-
-FORCE: