ParseTree 1.1.0

data/History.txt

@@ -0,0 +1,15 @@
+*** 1.1.0 / 2004-11-12
+
++ 2 minor enhancement
+	+ Added SexpProcessor and CompositeSexpProcessor
+	+ Allowed show.rb to read from standard input.
++ 3 bug fixes
+	+ Fixed makefile issues for BSD's make - so dumb.
+	+ Added super as a call in abc.rb's metrics
+	+ Commented out a compiler flag to work with GCC 2.95.
+
+
+*** 1.0.0 / 2004-11-06
+
++ 1 major enhancement
+	+ Birthday!

data/Makefile

@@ -0,0 +1,25 @@
+RUBY?=ruby
+RUBY_FLAGS?=-w -I.
+RUBY_LIB?=$(shell $(RUBY) -rrbconfig -e 'include Config; print CONFIG["sitelibdir"]')
+PREFIX?=/usr/local
+
+all test:
+	$(RUBY) $(RUBY_FLAGS) test_all.rb
+
+# we only install test_sexp_processor.rb to help make ruby_to_c's
+# subclass tests work.
+
+install:
+	cp -f parse_tree.rb test_sexp_processor.rb sexp_processor.rb composite_sexp_processor.rb $(RUBY_LIB)
+	cp -f parse_tree_show $(PREFIX)/bin
+	cp -f parse_tree_abc $(PREFIX)/bin
+	chmod 444 $(RUBY_LIB)/parse_tree.rb $(RUBY_LIB)/sexp_processor.rb $(RUBY_LIB)/composite_sexp_processor.rb $(RUBY_LIB)/test_sexp_processor.rb
+	chmod 555 $(PREFIX)/bin/parse_tree_show $(PREFIX)/bin/parse_tree_abc
+
+uninstall:
+	rm -f $(RUBY_LIB)/parse_tree.rb $(RUBY_LIB)/sexp_processor.rb $(RUBY_LIB)/composite_sexp_processor.rb $(RUBY_LIB)/test_sexp_processor.rb
+	rm -f $(PREFIX)/bin/parse_tree_show $(PREFIX)/bin/parse_tree_abc
+
+clean:
+	-rm *~ diff.txt
+	-rm -r $$HOME/.ruby_inline

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Makefile
+Manifest.txt
+README.txt
+composite_sexp_processor.rb
+parse_tree.rb
+parse_tree_abc
+parse_tree_show
+sexp_processor.rb
+something.rb
+test_all.rb
+test_composite_sexp_processor.rb
+test_parse_tree.rb
+test_sexp_processor.rb

data/README.txt

@@ -0,0 +1,104 @@
+ParseTree
+    http://www.zenspider.com/ZSS/Products/ParseTree/
+    support@zenspider.com
+
+** DESCRIPTION:
+
+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. 
+
+As an example:
+
+  def conditional1(arg1)
+    if arg1 == 0 then
+      return 1
+    end
+    return 0
+  end
+
+becomes:
+
+  [:defn,
+    "conditional1",
+    [:scope,
+     [:block,
+      [:args, "arg1"],
+      [:if,
+       [:call, [:lvar, "arg1"], "==", [:array, [:lit, 0]]],
+       [:return, [:lit, 1]],
+       nil],
+      [:return, [:lit, 0]]]]]
+
+** FEATURES/PROBLEMS:
+  
++ 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.
+	+ abc metrics = numbers of assignments, branches, and calls.
+	+ whitespace independent metric for method complexity.
++ Only works on methods in classes/modules, not arbitrary code.
++ Does not work on the core classes, as they are not ruby (yet).
+
+** SYNOPSYS:
+
+  sexp_array = ParseTree.new.parse_tree(klass)
+
+or:
+
+  class MyProcessor < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+    def process_lit(exp)
+      val = exp.shift
+      return val
+    end
+  end
+
+or:
+
+  % ./parse_tree_show myfile.rb
+
+or:
+
+  % ./parse_tree_abc myfile.rb
+
+** REQUIREMENTS:
+
++ RubyInline 3 or better.
+
+** INSTALL:
+
++ sudo make install
+	+ renames show.rb to parse_tree_show
+	+ renames abc.rb to parse_tree_abc
+
+** LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2001-2004 Ryan Davis, Zen Spider Software
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/composite_sexp_processor.rb

@@ -0,0 +1,24 @@
+require 'sexp_processor'
+
+class CompositeSexpProcessor < SexpProcessor
+
+  attr_reader :processors
+
+  def initialize(*processors)
+    super
+    @processors = []
+  end
+
+  def <<(processor)
+    raise ArgumentError, "Can only add sexp processors" unless
+      SexpProcessor === processor
+    @processors << processor
+  end
+
+  def process(exp)
+    @processors.each do |processor|
+      exp = processor.process(exp)
+    end
+    exp
+  end
+end

data/parse_tree.rb

@@ -0,0 +1,545 @@
+#!/usr/local/bin/ruby -w
+
+begin
+  require 'rubygems'
+  require_gem 'RubyInline'
+rescue LoadError
+  require 'inline'
+end
+
+class ParseTree
+
+  VERSION = '1.1.0'
+
+  inline do |builder|
+    builder.add_type_converter("VALUE", '', '')
+    builder.add_type_converter("NODE *", '(NODE *)', '(VALUE)')
+    builder.include '"intern.h"'
+    builder.include '"node.h"'
+    builder.include '"st.h"'
+    builder.add_compile_flags "-Wall"
+    builder.add_compile_flags "-W"
+    builder.add_compile_flags "-Wpointer-arith"
+    builder.add_compile_flags "-Wcast-qual"
+    builder.add_compile_flags "-Wcast-align"
+    builder.add_compile_flags "-Wwrite-strings"
+    builder.add_compile_flags "-Wmissing-noreturn"
+    builder.add_compile_flags "-Werror"
+    # NOTE: this flag doesn't work w/ gcc 2.95.x - the FreeBSD default
+    # builder.add_compile_flags "-Wno-strict-aliasing"
+    # ruby.h screws these up hardcore:
+    # builder.add_compile_flags "-Wundef"
+    # builder.add_compile_flags "-Wconversion"
+    # builder.add_compile_flags "-Wstrict-prototypes"
+    # builder.add_compile_flags "-Wmissing-prototypes"
+    # builder.add_compile_flags "-Wsign-compare", 
+
+    builder.prefix %q{
+        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^
+// FIX!!!
+static ID *dump_local_tbl;
+
+static void add_to_parse_tree(VALUE ary, NODE * n) {
+  NODE * volatile node = n;
+  NODE * volatile contnode = NULL;
+  VALUE old_ary = Qnil;
+  VALUE current;
+  VALUE node_name;
+
+  if (!node) return;
+
+again:
+
+  if (node) {
+    node_name = ID2SYM(rb_intern(node_type_string[nd_type(node)]));
+  } else {
+    node_name = ID2SYM(rb_intern("ICKY"));
+  }
+
+  current = rb_ary_new();
+  rb_ary_push(ary, current);
+  rb_ary_push(current, node_name);
+
+again_no_block:
+
+    switch (nd_type(node)) {
+
+    case NODE_BLOCK:
+      if (contnode) {
+        add_to_parse_tree(current, node);
+        break;
+      }
+
+      contnode = node->nd_next;
+
+      // NOTE: this will break the moment there is a block w/in a block
+      old_ary = ary;
+      ary = current;
+      node = node->nd_head;
+      goto again;
+      break;
+
+    case NODE_FBODY:
+    case NODE_DEFINED:
+      add_to_parse_tree(current, node->nd_head);
+      break;
+
+    case NODE_COLON2:
+      add_to_parse_tree(current, node->nd_head);
+      rb_ary_push(current, rb_str_new2(rb_id2name(node->nd_mid)));
+      break;
+
+    case NODE_BEGIN:
+      node = node->nd_body;
+      goto again;
+
+    case NODE_MATCH2:
+    case NODE_MATCH3:
+      add_to_parse_tree(current, node->nd_recv);
+      add_to_parse_tree(current, node->nd_value);
+      break;
+
+    case NODE_OPT_N:
+      add_to_parse_tree(current, node->nd_body);
+      break;
+
+    case NODE_IF:
+      add_to_parse_tree(current, node->nd_cond);
+      if (node->nd_body) {
+        add_to_parse_tree(current, node->nd_body);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
+      if (node->nd_else) {
+        add_to_parse_tree(current, node->nd_else);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
+      break;
+
+  case NODE_CASE:
+    add_to_parse_tree(current, node->nd_head);          /* expr */
+    node = node->nd_body;
+    while (node) {
+      add_to_parse_tree(current, node);
+      if (nd_type(node) == NODE_WHEN) {                 /* when */
+        node = node->nd_next; 
+      } else {
+        break;                                          /* else */
+      }
+      if (! node) {
+        rb_ary_push(current, Qnil);                     /* no else */
+      }
+    }
+    break;
+
+  case NODE_WHEN:
+    add_to_parse_tree(current, node->nd_head);          /* args */
+    if (node->nd_body) {
+      add_to_parse_tree(current, node->nd_body);        /* body */
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    break;
+
+  case NODE_WHILE:
+  case NODE_UNTIL:
+    add_to_parse_tree(current,  node->nd_cond);
+    add_to_parse_tree(current,  node->nd_body); 
+    break;
+
+  case NODE_BLOCK_PASS:
+    add_to_parse_tree(current, node->nd_body);
+    add_to_parse_tree(current, node->nd_iter);
+    break;
+
+  case NODE_ITER:
+  case NODE_FOR:
+    add_to_parse_tree(current, node->nd_iter);
+    if (node->nd_var != (NODE *)-1 && node->nd_var != NULL) {
+      add_to_parse_tree(current, node->nd_var);
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    add_to_parse_tree(current, node->nd_body);
+    break;
+
+  case NODE_BREAK:
+  case NODE_NEXT:
+  case NODE_YIELD:
+    if (node->nd_stts)
+      add_to_parse_tree(current, node->nd_stts);
+    break;
+
+  case NODE_RESCUE:
+    {
+      NODE *resq, *n;
+      int i;
+
+      add_to_parse_tree(current, node->nd_head);
+      resq = node->nd_resq;
+      while (resq) {
+	if (nd_type(resq) == NODE_ARRAY) {
+	  n = resq;
+	  for (i = 0; i < resq->nd_alen; i++) {
+	    add_to_parse_tree(current, n->nd_head);
+	    n = n->nd_next;
+	  }
+	} else {
+	  add_to_parse_tree(current, resq->nd_args);
+	}
+	add_to_parse_tree(current, resq->nd_body);
+	resq = resq->nd_head;
+      }
+      if (node->nd_else) {
+	add_to_parse_tree(current, node->nd_else);
+      }
+    }
+    break;
+	
+  case NODE_ENSURE:
+    add_to_parse_tree(current, node->nd_head);
+    if (node->nd_ensr) {
+      add_to_parse_tree(current, node->nd_ensr);
+    }
+    break;
+
+  case NODE_AND:
+  case NODE_OR:
+    add_to_parse_tree(current, node->nd_1st);
+    add_to_parse_tree(current, node->nd_2nd);
+    break;
+
+  case NODE_NOT:
+    add_to_parse_tree(current, node->nd_body);
+    break;
+
+  case NODE_DOT2:
+  case NODE_DOT3:
+  case NODE_FLIP2:
+  case NODE_FLIP3:
+    add_to_parse_tree(current, node->nd_beg);
+    add_to_parse_tree(current, node->nd_end);
+    break;
+
+  case NODE_RETURN:
+    if (node->nd_stts)
+      add_to_parse_tree(current, node->nd_stts);
+    break;
+
+  case NODE_ARGSCAT:
+  case NODE_ARGSPUSH:
+    add_to_parse_tree(current, node->nd_head);
+    add_to_parse_tree(current, node->nd_body);
+    break;
+
+  case NODE_CALL:
+  case NODE_FCALL:
+  case NODE_VCALL:
+    if (nd_type(node) != NODE_FCALL)
+      add_to_parse_tree(current, node->nd_recv);
+    rb_ary_push(current, rb_str_new2(rb_id2name(node->nd_mid)));
+    if (node->nd_args || nd_type(node) != NODE_FCALL)
+      add_to_parse_tree(current, node->nd_args);
+    break;
+
+  case NODE_SUPER:
+    add_to_parse_tree(current, node->nd_args);
+    break;
+
+  case NODE_DMETHOD:
+    {
+      struct METHOD *data;
+      Data_Get_Struct(node->nd_cval, struct METHOD, data);
+      break;
+    }
+
+  case NODE_SCOPE:
+    dump_local_tbl = node->nd_tbl;
+    add_to_parse_tree(current, node->nd_next);
+    break;
+
+  case NODE_OP_ASGN1:
+    add_to_parse_tree(current, node->nd_recv);
+    add_to_parse_tree(current, node->nd_args->nd_next);
+    add_to_parse_tree(current, node->nd_args->nd_head);
+    break;
+
+  case NODE_OP_ASGN2:
+    add_to_parse_tree(current, node->nd_recv);
+    add_to_parse_tree(current, node->nd_value);
+    break;
+
+  case NODE_OP_ASGN_AND:
+  case NODE_OP_ASGN_OR:
+    add_to_parse_tree(current, node->nd_head);
+    add_to_parse_tree(current, node->nd_value);
+    break;
+
+  case NODE_MASGN:
+    add_to_parse_tree(current, node->nd_head);
+    if (node->nd_args) {
+      if (node->nd_args != (NODE *)-1) {
+	add_to_parse_tree(current, node->nd_args);
+      }
+    }
+    add_to_parse_tree(current, node->nd_value);
+    break;
+
+  case NODE_LASGN:
+  case NODE_IASGN:
+  case NODE_DASGN:
+  case NODE_DASGN_CURR:
+  case NODE_CDECL:
+  case NODE_CVASGN:
+  case NODE_CVDECL:
+  case NODE_GASGN:
+    rb_ary_push(current, rb_str_new2(rb_id2name(node->nd_vid)));
+    add_to_parse_tree(current, node->nd_value);
+    break;
+
+  case NODE_HASH:
+    {
+      NODE *list;
+	
+      list = node->nd_head;
+      while (list) {
+	add_to_parse_tree(current, list->nd_head);
+	list = list->nd_next;
+	if (list == 0)
+	  rb_bug("odd number list for Hash");
+	add_to_parse_tree(current, list->nd_head);
+	list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_ARRAY:
+      while (node) {
+	add_to_parse_tree(current, node->nd_head);
+        node = node->nd_next;
+      }
+    break;
+
+  case NODE_DSTR:
+  case NODE_DXSTR:
+  case NODE_DREGX:
+  case NODE_DREGX_ONCE:
+    {
+      NODE *list = node->nd_next;
+      if (nd_type(node) == NODE_DREGX || nd_type(node) == NODE_DREGX_ONCE) {
+	break;
+      }
+      rb_ary_push(current, rb_str_new3(node->nd_lit));
+      while (list) {
+	if (list->nd_head) {
+	  switch (nd_type(list->nd_head)) {
+	  case NODE_STR:
+	    add_to_parse_tree(current, list->nd_head);
+	    break;
+	  case NODE_EVSTR:
+	    add_to_parse_tree(current, list->nd_head->nd_body);
+	    break;
+	  default:
+	    add_to_parse_tree(current, list->nd_head);
+	    break;
+	  }
+	}
+	list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_DEFN:
+  case NODE_DEFS:
+    if (node->nd_defn) {
+      if (nd_type(node) == NODE_DEFS)
+	add_to_parse_tree(current, node->nd_recv);
+      rb_ary_push(current, rb_str_new2(rb_id2name(node->nd_mid)));
+      add_to_parse_tree(current, node->nd_defn);
+    }
+    break;
+
+  case NODE_CLASS:
+  case NODE_MODULE:
+    rb_ary_push(current, rb_str_new2(rb_id2name((ID)node->nd_cpath->nd_mid)));
+    if (node->nd_super && nd_type(node) == NODE_CLASS) {
+      add_to_parse_tree(current, node->nd_super);
+    }
+    add_to_parse_tree(current, node->nd_body);
+    break;
+
+  case NODE_SCLASS:
+    add_to_parse_tree(current, node->nd_recv);
+    add_to_parse_tree(current, node->nd_body);
+    break;
+
+  case NODE_ARGS:
+    if (dump_local_tbl && 
+	(node->nd_cnt || node->nd_opt || node->nd_rest != -1)) {
+      int i;
+      NODE *optnode;
+
+      for (i = 0; i < node->nd_cnt; i++) {
+        // regular arg names
+        rb_ary_push(current, rb_str_new2(rb_id2name(dump_local_tbl[i + 3])));
+      }
+
+      optnode = node->nd_opt;
+      while (optnode) {
+        // optional arg names
+        rb_ary_push(current, rb_str_new2(rb_id2name(dump_local_tbl[i + 3])));
+	i++;
+	optnode = optnode->nd_next;
+      }
+      if (node->nd_rest != -1) {
+        // *arg name
+        rb_ary_push(current, rb_str_new2(rb_id2name(dump_local_tbl[node->nd_rest + 1])));
+      }
+      optnode = node->nd_opt;
+      // 
+      if (optnode) {
+	add_to_parse_tree(current, node->nd_opt);
+      }
+    }
+    break;
+	
+    case NODE_LVAR:
+    case NODE_DVAR:
+    case NODE_IVAR:
+    case NODE_CVAR:
+    case NODE_GVAR:
+    case NODE_CONST:
+    case NODE_ATTRSET:
+      rb_ary_push(current, rb_str_new2(rb_id2name(node->nd_vid)));
+      break;
+
+    case NODE_STR:
+    case NODE_LIT:
+      rb_ary_push(current, node->nd_lit);
+      break;
+
+    case NODE_NEWLINE:
+      rb_ary_push(current, INT2FIX(nd_line(node)));
+      rb_ary_push(current, rb_str_new2(node->nd_file));
+      rb_ary_pop(ary); // nuke it for now
+
+      node = node->nd_next;
+      goto again;
+
+    // these are things we know we do not need to translate to C.
+    case NODE_BLOCK_ARG:
+    case NODE_SELF:
+    case NODE_NIL:
+    case NODE_TRUE:
+    case NODE_FALSE:
+    case NODE_ZSUPER:
+    case NODE_BMETHOD:
+    case NODE_REDO:
+    case NODE_RETRY:
+    case NODE_COLON3:
+    case NODE_NTH_REF:
+    case NODE_BACK_REF:
+    case NODE_ZARRAY:
+    case NODE_XSTR:
+    case NODE_UNDEF:
+    case NODE_ALIAS:
+    case NODE_VALIAS:
+    break;
+
+    default:
+      rb_ary_push(current, INT2FIX(-99));
+      rb_ary_push(current, INT2FIX(nd_type(node)));
+      break;
+    }
+
+//  finish:
+    if (contnode) {
+	node = contnode;
+	contnode = NULL;
+        current = ary;
+        ary = old_ary;
+        old_ary = Qnil;
+	goto again_no_block;
+    }
+  }
+^
+
+    builder.c %q{
+static VALUE parse_tree_for_method(VALUE klass, VALUE method) {
+  NODE *node = NULL;
+  ID id;
+  VALUE result = rb_ary_new();
+
+  (void) self; // quell warnings
+
+  id = rb_to_id(method);
+  if (st_lookup(RCLASS(klass)->m_tbl, id, (st_data_t *) &node)) {
+    rb_ary_push(result, ID2SYM(rb_intern("defn")));
+    rb_ary_push(result, method);
+    add_to_parse_tree(result, node->nd_body);
+  } else {
+    rb_ary_push(result, Qnil);
+  }
+
+  return result;
+}
+}
+  end
+
+  def parse_tree(klass, meth=nil)
+    code = []
+    if meth then
+      code = parse_tree_for_method(klass, meth.to_s)
+    else
+      klass.instance_methods(false).sort.each do |m|
+	code << parse_tree_for_method(klass, m)
+      end
+    end
+    return code
+  end
+
+end