ParseTree 1.1.1 → 1.2.0

data/{test_sexp_processor.rb → test/test_sexp_processor.rb}

@@ -212,15 +212,6 @@ class TestSexp < Test::Unit::TestCase # ZenTest FULL
     assert_nil(@sexp.shift)
   end
 
-  def test_unpack_equal
-    assert_equal false, @sexp.unpack
-    @sexp.unpack = true
-    assert_equal true, @sexp.unpack
-  end
-
-  def test_unpack; end # handled
-  def test_unpack_q; end # handled
-
 end
 
 class TestSexpProcessor < Test::Unit::TestCase

metadata

@@ -3,19 +3,22 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
-date: 2004-11-20
+  version: 1.2.0
+date: 2004-11-29
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
-  - "."
+  - lib
+  - test
 author: Ryan Davis
 email: ryand-ruby@zenspider.com
 homepage: http://www.zenspider.com/ZSS/Products/ParseTree/
 rubyforge_project: parsetree
-description: def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end
+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."
 autorequire: parse_tree
 default_executable: 
-bindir: "."
+bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
@@ -30,22 +33,25 @@ files:
   - 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
+  - ParseTree.gemspec
+  - bin/parse_tree_abc
+  - bin/parse_tree_deps
+  - bin/parse_tree_show
+  - lib/composite_sexp_processor.rb
+  - lib/parse_tree.rb
+  - lib/sexp_processor.rb
+  - test/something.rb
+  - test/test_all.rb
+  - test/test_composite_sexp_processor.rb
+  - test/test_parse_tree.rb
+  - test/test_sexp_processor.rb
 test_files: 
-  - test_all.rb
+  - test/test_all.rb
 rdoc_options: []
 extra_rdoc_files: []
 executables: 
   - parse_tree_abc
+  - parse_tree_deps
   - parse_tree_show
 extensions: []
 requirements: 

data/composite_sexp_processor.rb

@@ -1,24 +0,0 @@
-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_abc

@@ -1,62 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# ABC metric
-#
-# Assignments, Branches, and Calls
-#
-# A simple way to measure the complexity of a function or method.
-
-require 'parse_tree'
-
-old_classes = []
-ObjectSpace.each_object(Module) do |klass|
-  old_classes << klass
-end
-
-ARGV.each do |name|
-  require name
-end
-
-new_classes = []
-ObjectSpace.each_object(Module) do |klass|
-  new_classes << klass
-end
-
-score = {}
-
-new_classes -= old_classes
-
-new_classes.each do |klass|
-  ParseTree.new.parse_tree(klass).each do |defn|
-    a=b=c=0
-    defn.shift
-    name = defn.shift
-    tokens = defn.flatten.find_all { |t| Symbol === t }
-    tokens.each do |token|
-      case token
-      when :attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn then
-        a += 1
-      when :and, :case, :else, :if, :iter, :or, :rescue, :until, :when, :while  then
-        b += 1
-      when :call, :fcall, :super, :vcall, :yield then
-        c += 1
-      when :args, :argscat, :array, :begin, :block, :bool, :cfunc, :colon2, :const, :cvar, :defined, :defn, :dregx, :dstr, :dvar, :dxstr, :ensure, :false, :fbody, :gvar, :hash, :ivar, :lit, :long, :lvar, :match2, :match3, :nil, :not, :nth_ref, :return, :scope, :self, :splat, :str, :to_ary, :true, :unknown, :value, :void, :zarray, :zarray, :zclass, :zsuper then
-        # ignore
-      else
-        puts "unhandled token #{token.inspect}"
-      end
-    end
-    key = ["#{klass}.#{name}", a, b, c]
-    val = a+b+c
-    score[key] = val
-  end
-end
-
-puts "Method = assignments + branches + calls = total"
-puts
-count = 1
-score.sort_by { |k,v| v }.reverse.each do |key,val|
-  name, a, b, c = *key
-  printf "%3d) %-50s = %2d + %2d + %2d = %3d\n", count, name, a, b, c, val
-  count += 1
-end

data/parse_tree_show

@@ -1,28 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require 'pp'
-require 'parse_tree'
-
-old_classes = []
-ObjectSpace.each_object(Module) do |klass|
-  old_classes << klass
-end
-
-ARGV.each do |name|
-  if name == "-" then
-    eval $stdin.read
-  else
-    require name
-  end
-end
-
-new_classes = []
-ObjectSpace.each_object(Module) do |klass|
-  new_classes << klass
-end
-
-new_classes -= old_classes
-
-new_classes.each do |klass|
-  pp ParseTree.new.parse_tree(klass)
-end

data/test_all.rb

@@ -1,7 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-Dir.glob("test_*.rb").each do |f|
-  require f
-end
-
-require 'test/unit'

data/test_parse_tree.rb

@@ -1,275 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require 'test/unit'
-require 'parse_tree'
-require 'something'
-
-class TestParseTree < Test::Unit::TestCase
-
-  # TODO: need a test of interpolated strings
-
-  @@missing = [nil]
-  @@empty = [:defn, "empty",
-    [:scope,
-      [:args]]]
-  @@stupid = [:defn, "stupid",
-    [:scope,
-      [:block,
-        [:args],
-        [:return, [:nil]]]]]
-  @@simple = [:defn, "simple",
-    [:scope,
-      [:block,
-        [:args, "arg1"],
-        [:fcall, "print",
-          [:array, [:lvar, "arg1"]]],
-        [:fcall, "puts",
-          [:array,
-            [:call,
-              [:call,
-                [:lit, 4],
-                "+",
-                [:array, [:lit, 2]]],
-             "to_s"]]]]]]
-  @@global = [:defn, "global",
-    [:scope,
-      [:block,
-        [:args],
-        [:call,
-          [:gvar, "$stderr"],
-          "fputs",
-          [:array, [:str, "blah"]]]]]]
-  @@lasgn_call = [:defn, "lasgn_call",
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, "c",
-          [:call,
-            [:lit, 2],
-            "+",
-            [:array, [:lit, 3]]]]]]]
-  @@conditional1 = [:defn, "conditional1",
-    [:scope,
-      [:block,
-        [:args, "arg1"],
-        [:if,
-          [:call,
-            [:lvar, "arg1"],
-            "==",
-            [:array, [:lit, 0]]],
-          [:return,
-            [:lit, 1]], nil]]]]
-  @@conditional2 = [:defn, "conditional2",
-    [:scope,
-      [:block,
-        [:args, "arg1"],
-        [:if,
-          [:call,
-            [:lvar, "arg1"],
-            "==",
-            [:array, [:lit, 0]]], nil,
-          [:return,
-            [:lit, 2]]]]]]
-  @@conditional3 = [:defn, "conditional3",
-    [:scope,
-      [:block,
-        [:args, "arg1"],
-        [:if,
-          [:call,
-            [:lvar, "arg1"],
-            "==",
-            [:array, [:lit, 0]]],
-          [:return,
-            [:lit, 3]],
-          [:return,
-            [:lit, 4]]]]]]
-  @@conditional4 = [:defn, "conditional4",
-    [:scope,
-      [:block,
-        [:args, "arg1"],
-        [:if,
-          [:call,
-            [:lvar, "arg1"],
-            "==",
-            [:array, [:lit, 0]]],
-          [:return, [:lit, 2]],
-          [:if,
-            [:call,
-              [:lvar, "arg1"],
-              "<",
-              [:array, [:lit, 0]]],
-            [:return, [:lit, 3]],
-            [:return, [:lit, 4]]]]]]]
-  @@iteration_body = [:scope,
-    [:block,
-      [:args],
-      [:lasgn, "array",
-        [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
-      [:iter,
-        [:call,
-          [:lvar, "array"], "each"],
-        [:dasgn_curr, "x"],
-        [:fcall, "puts", [:array, [:call, [:dvar, "x"], "to_s"]]]]]]
-  @@iteration1 = [:defn, "iteration1", @@iteration_body]
-  @@iteration2 = [:defn, "iteration2", @@iteration_body]
-  @@iteration3 = [:defn, "iteration3",
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, "array1",
-          [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
-        [:lasgn, "array2",
-          [:array, [:lit, 4], [:lit, 5], [:lit, 6], [:lit, 7]]],
-        [:iter,
-          [:call,
-            [:lvar, "array1"], "each"],
-          [:dasgn_curr, "x"],
-          [:iter,
-            [:call,
-              [:lvar, "array2"], "each"],
-            [:dasgn_curr, "y"],
-            [:block,
-              [:fcall, "puts",
-                [:array, [:call, [:dvar, "x"], "to_s"]]],
-              [:fcall, "puts",
-                [:array, [:call, [:dvar, "y"], "to_s"]]]]]]]]]
-  @@iteration4 = [:defn,
- "iteration4",
- [:scope,
-  [:block,
-   [:args],
-   [:iter,
-    [:call, [:lit, 1], "upto", [:array, [:lit, 3]]],
-    [:dasgn_curr, "n"],
-    [:fcall, "puts", [:array, [:call, [:dvar, "n"], "to_s"]]]]]]]
-  @@iteration5 = [:defn,
- "iteration5",
- [:scope,
-      [:block,
-   [:args],
-   [:iter,
-    [:call, [:lit, 3], "downto", [:array, [:lit, 1]]],
-    [:dasgn_curr, "n"],
-    [:fcall, "puts", [:array, [:call, [:dvar, "n"], "to_s"]]]]]]]
-  @@iteration6 = [:defn,
- "iteration6",
- [:scope,
-      [:block,
-   [:args],
-   [:iter,
-    [:call, [:lit, 3], "downto", [:array, [:lit, 1]]],
-    nil,
-    [:fcall, "puts", [:array, [:str, "hello"]]]]]]]
-  @@multi_args = [:defn, "multi_args",
-    [:scope,
-      [:block,
-        [:args, "arg1", "arg2"],
-        [:lasgn, "arg3",
-          [:call,
-            [:call,
-              [:lvar, "arg1"],
-              "*",
-              [:array, [:lvar, "arg2"]]],
-            "*",
-            [:array, [:lit, 7]]]],
-        [:fcall, "puts", [:array, [:call, [:lvar, "arg3"], "to_s"]]],
-        [:return,
-          [:str, "foo"]]]]]
-  @@bools = [:defn, "bools",
-    [:scope,
-      [:block,
-        [:args, "arg1"],
-        [:if,
-          [:call,
-            [:lvar, "arg1"], "nil?"],
-          [:return,
-            [:false]],
-          [:return,
-            [:true]]]]]]
-  @@case_stmt = [:defn, "case_stmt",
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, "var", [:lit, 2]],
-        [:lasgn, "result", [:str, ""]],
-        [:case,
-          [:lvar, "var"],
-          [:when,
-            [:array, [:lit, 1]],
-            [:block,
-              [:fcall, "puts", [:array, [:str, "something"]]],
-              [:lasgn, "result", [:str, "red"]]]],
-          [:when,
-            [:array, [:lit, 2], [:lit, 3]],
-            [:lasgn, "result", [:str, "yellow"]]],
-          [:when, [:array, [:lit, 4]], nil],
-          [:lasgn, "result", [:str, "green"]]],
-        [:case,
-          [:lvar, "result"],
-          [:when, [:array, [:str, "red"]], [:lasgn, "var", [:lit, 1]]],
-          [:when, [:array, [:str, "yellow"]], [:lasgn, "var", [:lit, 2]]],
-          [:when, [:array, [:str, "green"]], [:lasgn, "var", [:lit, 3]]],
-          nil],
-        [:return, [:lvar, "result"]]]]]
-  @@eric_is_stubborn = [:defn,
-    "eric_is_stubborn",
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, "var", [:lit, 42]],
-        [:lasgn, "var2", [:call, [:lvar, "var"], "to_s"]],
-        [:call, [:gvar, "$stderr"], "fputs", [:array, [:lvar, "var2"]]],
-        [:return, [:lvar, "var2"]]]]]
-  @@interpolated = [:defn,
-    "interpolated",
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, "var", [:lit, 14]],
-        [:lasgn, "var2", [:dstr, "var is ", [:lvar, "var"], [:str, ". So there."]]]]]]
-  @@unknown_args = [:defn, "unknown_args",
-    [:scope,
-      [:block,
-        [:args, "arg1", "arg2"],
-        [:return, [:lvar, "arg1"]]]]]
-  @@determine_args = [:defn, "determine_args",
-    [:scope,
-      [:block,
-        [:args],
-          [:call,
-            [:lit, 5],
-            "==",
-            [:array,
-              [:fcall,
-                "unknown_args",
-                [:array, [:lit, 4], [:str, "known"]]]]]]]]
-
-  @@__all = []
-
-  def setup
-    @thing = ParseTree.new
-  end
-
-  Something.instance_methods(false).sort.each do |meth|
-    if class_variables.include?("@@#{meth}") then
-      @@__all << eval("@@#{meth}")
-      eval "def test_#{meth}; assert_equal @@#{meth}, @thing.parse_tree(Something, :#{meth}); end"
-    else
-      eval "def test_#{meth}; flunk \"You haven't added @@#{meth} yet\"; end"
-    end
-  end
-
-  def test_missing
-    assert_equal(@@missing,
-		 @thing.parse_tree(Something, :missing),
-		 "Must return -3 for missing methods")
-  end
-
-  def ztest_class
-    assert_equal(@@__all,
-		 @thing.parse_tree(Something),
-		 "Must return a lot of shit")
-  end
-
-end
-