ParseTree 1.3.7 → 1.4.0

data/History.txt

@@ -1,3 +1,21 @@
+*** 1.4.0 / 2005-10-15
+
++ 5 minor enhancements
+	+ Improved Makefile's install rule, uninstall, and added FILTER to all.
+	+ Fixed minor issues w/ Makefile.
+	+ Added -I=loadpath to parse_tree_abc.
+	+ Added *args support for methods.
+	+ Split out sexp to its own file.
++ 2 bug fixes
+	+ Fixed weird bug in parse_tree_deps where sort was failing on deps.
+	+ ! Fixed fatal bug in parse_tree.rb caused by safe_level fix in ruby 1.8.3.
+
+*** 1.3.8 / 2005-09-27
+
++ 1 bug fix:
+	+ Our private version of struct METHOD went out of sync w/ latest ruby.
+	+ Only use this if you are on 1.8.3+.
+
 *** 1.3.7 / 2005-07-13
 
 + 3 bug fixes:

data/Makefile

@@ -3,9 +3,27 @@ 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
+	$(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.
@@ -14,19 +32,17 @@ docs:
 	rdoc -d -I png --main SexpProcessor -x test_\* -x something.rb
 
 install:
-	cp -f lib/parse_tree.rb lib/sexp_processor.rb lib/composite_sexp_processor.rb $(RUBY_LIB)
-	cp -f test/test_sexp_processor.rb $(RUBY_LIB)
-	cp -f bin/parse_tree_show $(PREFIX)/bin
-	cp -f bin/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
+	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:
-	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
+	cd $(RUBY_LIB)   && rm -f $(LIB_FILES) $(TEST_FILES)
+	cd $(PREFIX)/bin && rm -f $(BIN_FILES)
 
 audit:
-	ZenTest composite_sexp_processor.rb sexp_processor.rb test_all.rb test_composite_sexp_processor.rb test_sexp_processor.rb
+	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
@@ -36,6 +52,6 @@ demo:
 	echo 1+1 | $(RUBY) $(RUBY_FLAGS) ./bin/parse_tree_show -f
 
 gem:
-	gem ParseTree.gemspec
+	ruby ParseTree.gemspec
 
 FORCE:

data/Manifest.txt

@@ -1,17 +1,20 @@
 History.txt
 Makefile
 Manifest.txt
-README.txt
 ParseTree.gemspec
+README.txt
 bin/parse_tree_abc
 bin/parse_tree_deps
 bin/parse_tree_show
+demo/printer.rb
 lib/composite_sexp_processor.rb
 lib/parse_tree.rb
+lib/sexp.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.rb
 test/test_sexp_processor.rb
 validate.sh

data/bin/parse_tree_abc

@@ -1,4 +1,4 @@
-#!/usr/local/bin/ruby
+#!/usr/local/bin/ruby -ws
 
 # ABC metric
 #
@@ -6,9 +6,16 @@
 #
 # A simple way to measure the complexity of a function or method.
 
+if defined? $I and String === $I then
+  $I.split(/:/).each do |dir|
+    $: << dir
+  end
+end
+
 PARSE_TREE_ABC=true
 
 begin require 'rubygems' rescue LoadError end
+require 'sexp'
 require 'parse_tree'
 require 'sexp_processor'
 
@@ -78,5 +85,5 @@ score.sort_by { |k,v| v }.reverse.each do |key,val|
   tval += val
   printf "%3d) %-50s = %2d + %2d + %2d = %6.2f\n", count, name, a, b, c, val
   count += 1
-end
+end rescue nil
 printf "%3d) %-50s = %2d + %2d + %2d = %6.2f\n", count, "Total", ta, tb, tc, tval

data/bin/parse_tree_deps

@@ -33,7 +33,7 @@ class DependencyAnalyzer < SexpProcessor
     end
 
     deps = analyzer.dependencies
-    deps.keys.sort.each do |dep_to|
+    deps.keys.sort_by {|k| k.to_s}.each do |dep_to|
       dep_from = deps[dep_to]
       puts "#{dep_to}: #{dep_from.uniq.sort.join(", ")}"
     end
@@ -57,5 +57,6 @@ end
 if __FILE__ == $0 then
   ARGV.each { |name| require name }
   ObjectSpace.each_object(Module) { |klass| new_classes << klass }
+  new_classes.delete DependencyAnalyzer unless defined? $a
   DependencyAnalyzer.process(*(new_classes - old_classes))
 end

data/demo/printer.rb

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby -w
+require 'rubygems'
+require 'sexp_processor'
+
+class QuickPrinter < SexpProcessor
+  def initialize
+    super
+    self.strict = false
+    self.auto_shift_type = true
+  end
+  def process_defn(exp)
+    name = exp.shift
+    args = process exp.shift
+    body = process exp.shift
+    puts "  def #{name}"
+    return s(:defn, name, args, body)
+  end
+end
+
+QuickPrinter.new.process(*ParseTree.new.parse_tree(QuickPrinter))

data/lib/parse_tree.rb

@@ -24,7 +24,7 @@ require 'inline'
 
 class ParseTree
 
-  VERSION = '1.3.7'
+  VERSION = '1.4.0'
 
   ##
   # Initializes a ParseTree instance. Includes newline nodes if
@@ -129,13 +129,14 @@ class ParseTree
     # builder.add_compile_flags "-Wmissing-prototypes"
     # builder.add_compile_flags "-Wsign-compare"
 
-    builder.prefix %q{
+    builder.prefix %{
         #define nd_3rd   u3.node
 
         struct METHOD {
           VALUE klass, rklass;
           VALUE recv;
           ID id, oid;
+          #{ RUBY_VERSION <= "1.8.2" ? "" : "int safe_level;" }
           NODE *body;
         };
 
@@ -586,7 +587,8 @@ again_no_block:
       arg_count = node->nd_rest;
       if (arg_count > 0) {
         // *arg name
-        rb_ary_push(current, ID2SYM(locals[node->nd_rest + 1]));
+        VALUE sym = rb_str_intern(rb_str_plus(rb_str_new2("*"), rb_str_new2(rb_id2name(locals[node->nd_rest + 1]))));
+        rb_ary_push(current, sym);
       } else if (arg_count == -1) {
         // nothing to do in this case, handled above
       } else if (arg_count == -2) {

data/lib/sexp.rb

@@ -0,0 +1,257 @@
+##
+# Sexps are the basic storage mechanism of SexpProcessor.  Sexps have
+# a +type+ (to be renamed +node_type+) which is the first element of
+# the Sexp. The type is used by SexpProcessor to determine whom to
+# dispatch the Sexp to for processing.
+
+$TESTING ||= false # unless defined $TESTING
+
+class Sexp < Array # ZenTest FULL
+
+  @@array_types = [ :array, :args, ]
+
+  ##
+  # Named positional parameters.
+  # Use with +SexpProcessor.require_empty=false+.
+  attr_accessor :accessors
+
+  ##
+  # Create a new Sexp containing +args+.
+
+  def initialize(*args)
+    @accessors = []
+    super(args)
+  end
+
+  def self.from_array(a)
+    ary = Array === a ? a : [a]
+
+    result = self.new
+
+    ary.each do |x|
+      case x
+      when Sexp
+        result << x
+      when Array
+        result << self.from_array(x)
+      else
+        result << x
+      end
+    end
+
+    result
+  end
+
+  def ==(obj) # :nodoc:
+    if obj.class == self.class then
+      super
+    else
+      false
+    end
+  end
+
+  def ===(sexp)
+    return nil unless Sexp === sexp
+    pattern = self # this is just for my brain
+
+    return true if pattern == sexp
+
+    sexp.each do |subset|
+      return true if pattern === subset
+    end
+
+    return nil
+  end
+
+  def =~(pattern)
+    return pattern === self
+  end
+
+  ##
+  # Returns true if the node_type is +array+ or +args+.
+  #
+  # REFACTOR: to TypedSexp - we only care when we have units.
+
+  def array_type?
+    type = self.first
+    @@array_types.include? type
+  end
+
+  ##
+  # Enumeratates the sexp yielding to +b+ when the node_type == +t+.
+
+  def each_of_type(t, &b)
+    each do | elem |
+      if Sexp === elem then
+        elem.each_of_type(t, &b)
+        b.call(elem) if elem.first == t
+      end
+    end
+  end
+
+  ##
+  # Replaces all elements whose node_type is +from+ with +to+. Used
+  # only for the most trivial of rewrites.
+
+  def find_and_replace_all(from, to)
+    each_with_index do | elem, index |
+      if Sexp === elem then
+        elem.find_and_replace_all(from, to)
+      else
+        self[index] = to if elem == from
+      end
+    end
+  end
+
+  def gsub(pattern, repl)
+    return repl if pattern == self
+
+    new = self.map do |subset|
+      case subset
+      when Sexp then
+        subset.gsub(pattern, repl)
+      else
+        subset
+      end
+    end
+
+    return Sexp.from_array(new)
+  end
+
+  def inspect # :nodoc:
+    sexp_str = self.map {|x|x.inspect}.join(', ')
+    return "s(#{sexp_str})"
+  end
+
+  ##
+  # Fancy-Schmancy method used to implement named positional accessors
+  # via +accessors+.
+  #
+  # Example:
+  #
+  #   class MyProcessor < SexpProcessor
+  #     def initialize
+  #       super
+  #       self.require_empty = false
+  #       self.sexp_accessors = {
+  #         :call => [:lhs, :name, :rhs]
+  #       }
+  #       ...
+  #     end
+  #   
+  #     def process_call(exp)
+  #       lhs = exp.lhs
+  #       name = exp.name
+  #       rhs = exp.rhs
+  #       ...
+  #     end
+  #   end
+
+  def method_missing(meth, *a, &b)
+    super unless @accessors.include? meth
+
+    index = @accessors.index(meth) + 1 # skip type
+    return self.at(index)
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group(1, 's(', ')') do
+      q.seplist(self) {|v| q.pp v }
+    end
+  end
+
+  ##
+  # Returns the Sexp without the node_type.
+
+  def sexp_body
+    self[1..-1]
+  end
+
+  ##
+  # If run with debug, Sexp will raise if you shift on an empty
+  # Sexp. Helps with debugging.
+
+  def shift
+    raise "I'm empty" if self.empty?
+    super
+  end if $DEBUG or $TESTING
+
+  ##
+  # Returnes the bare bones structure of the sexp.
+  # s(:a, :b, s(:c, :d), :e) => s(:a, s(:c))
+
+  def structure
+    result = self.class.new
+    if Array === self.first then
+      result = self.first.structure
+    else
+      result << self.shift
+      self.grep(Array).each do |subexp|
+        result << subexp.structure
+      end
+    end
+    result
+  end
+
+  def sub(pattern, repl)
+    return repl.dup if pattern == self
+
+    done = false
+
+    new = self.map do |subset|
+      if done then
+        subset
+      else
+        case subset
+        when Sexp then
+          if pattern == subset then
+            done = true
+            repl.dup
+          elsif pattern === subset then
+            done = true
+            subset.sub pattern, repl
+          else
+            subset
+          end
+        else
+          subset
+        end
+      end
+    end
+
+    return Sexp.from_array(new)
+  end
+
+  def to_a # :nodoc:
+    self.map { |o| Sexp === o ? o.to_a : o }
+  end
+
+  def to_s # :nodoc:
+    inspect
+  end
+
+end
+
+class SexpMatchSpecial < Sexp; end
+
+class SexpAny < SexpMatchSpecial
+  def ===(o)
+    return Sexp === o
+  end
+
+  def inspect
+    "ANY"
+  end
+end
+
+module SexpMatchSpecials
+  def ANY(); return SexpAny.new; end
+end
+
+##
+# This is just a stupid shortcut to make indentation much cleaner.
+
+def s(*args)
+  Sexp.new(*args)
+end
+

data/lib/sexp_processor.rb

@@ -1,6 +1,8 @@
 
 $TESTING = false unless defined? $TESTING
 
+require 'sexp'
+
 class Object
 
   ##
@@ -13,185 +15,6 @@ class Object
   end
 end
 
-##
-# Sexps are the basic storage mechanism of SexpProcessor.  Sexps have
-# a +type+ (to be renamed +node_type+) which is the first element of
-# the Sexp. The type is used by SexpProcessor to determine whom to
-# dispatch the Sexp to for processing.
-
-class Sexp < Array # ZenTest FULL
-
-  @@array_types = [ :array, :args, ]
-
-  ##
-  # Named positional parameters.
-  # Use with +SexpProcessor.require_empty=false+.
-  attr_accessor :accessors
-
-  ##
-  # Create a new Sexp containing +args+.
-
-  def initialize(*args)
-    @accessors = []
-    super(args)
-  end
-
-  def self.from_array(a)
-    ary = Array === a ? a : [a]
-
-    result = self.new
-
-    ary.each do |x|
-      case x
-      when Sexp
-        result << x
-      when Array
-        result << self.from_array(x)
-      else
-        result << x
-      end
-    end
-
-    result
-  end
-
-  ##
-  # Returns true if the node_type is +array+ or +args+.
-  #
-  # REFACTOR: to TypedSexp - we only care when we have units.
-
-  def array_type?
-    type = self.first
-    @@array_types.include? type
-  end
-
-  ##
-  # Enumeratates the sexp yielding to +b+ when the node_type == +t+.
-
-  def each_of_type(t, &b)
-    each do | elem |
-      if Sexp === elem then
-        elem.each_of_type(t, &b)
-        b.call(elem) if elem.first == t
-      end
-    end
-  end
-
-  ##
-  # Replaces all elements whose node_type is +from+ with +to+. Used
-  # only for the most trivial of rewrites.
-
-  def find_and_replace_all(from, to)
-    each_with_index do | elem, index |
-      if Sexp === elem then
-        elem.find_and_replace_all(from, to)
-      else
-        self[index] = to if elem == from
-      end
-    end
-  end
-
-  ##
-  # Fancy-Schmancy method used to implement named positional accessors
-  # via +accessors+.
-  #
-  # Example:
-  #
-  #   class MyProcessor < SexpProcessor
-  #     def initialize
-  #       super
-  #       self.require_empty = false
-  #       self.sexp_accessors = {
-  #         :call => [:lhs, :name, :rhs]
-  #       }
-  #       ...
-  #     end
-  #   
-  #     def process_call(exp)
-  #       lhs = exp.lhs
-  #       name = exp.name
-  #       rhs = exp.rhs
-  #       ...
-  #     end
-  #   end
-
-  def method_missing(meth, *a, &b)
-    super unless @accessors.include? meth
-
-    index = @accessors.index(meth) + 1 # skip type
-    return self.at(index)
-  end
-
-  ##
-  # Returns the Sexp without the node_type.
-
-  def sexp_body
-    self[1..-1]
-  end
-
-  ##
-  # Returnes the bare bones structure of the sexp.
-  # s(:a, :b, s(:c, :d), :e) => s(:a, s(:c))
-
-  def structure
-    result = self.class.new
-    if Array === self.first then
-      result = self.first.structure
-    else
-      result << self.shift
-      self.grep(Array).each do |subexp|
-        result << subexp.structure
-      end
-    end
-    result
-  end
-
-  def ==(obj) # :nodoc:
-    case obj
-    when Sexp
-      super
-    else
-      false
-    end
-  end
-
-  def to_a # :nodoc:
-    self.map { |o| Sexp === o ? o.to_a : o }
-  end
-
-  def inspect # :nodoc:
-    sexp_str = self.map {|x|x.inspect}.join(', ')
-    return "s(#{sexp_str})"
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group(1, 's(', ')') do
-      q.seplist(self) {|v| q.pp v }
-    end
-  end
-
-  def to_s # :nodoc:
-    inspect
-  end
-
-  ##
-  # If run with debug, Sexp will raise if you shift on an empty
-  # Sexp. Helps with debugging.
-
-  def shift
-    raise "I'm empty" if self.empty?
-    super
-  end if $DEBUG or $TESTING
-
-end
-
-##
-# This is just a stupid shortcut to make indentation much cleaner.
-
-def s(*args)
-  Sexp.new(*args)
-end
-
 ##
 # SexpProcessor base exception class.
 

data/test/something.rb

@@ -124,6 +124,12 @@ class Something
 
   # Other edge cases:
 
+  def opt_args(arg1, arg2 = 42, *args)
+    arg3 = arg1 * arg2 * 7
+    puts(arg3.to_s)
+    return "foo"
+  end
+
   def multi_args(arg1, arg2)
     arg3 = arg1 * arg2 * 7
     puts(arg3.to_s)

data/test/test_parse_tree.rb

@@ -177,6 +177,21 @@ class TestParseTree < Test::Unit::TestCase
     [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
     nil,
     [:fcall, :puts, [:array, [:str, "hello"]]]]]]]
+  @@opt_args = [:defn, :opt_args,
+    [:scope,
+      [:block,
+        [:args, :arg1, :arg2, :"*args", [:block, [:lasgn, :arg2, [:lit, 42]]]],
+        [:lasgn, :arg3,
+          [:call,
+            [:call,
+              [:lvar, :arg1],
+              :*,
+              [:array, [:lvar, :arg2]]],
+            :*,
+            [:array, [:lit, 7]]]],
+        [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
+        [:return,
+          [:str, "foo"]]]]]
   @@multi_args = [:defn, :multi_args,
     [:scope,
       [:block,

data/test/test_sexp.rb

@@ -0,0 +1,298 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'test/unit' if $0 == __FILE__ unless defined? $ZENTEST and $ZENTEST
+require 'test/unit/testcase'
+require 'sexp_processor'
+require 'stringio'
+require 'pp'
+
+class SexpTestCase < Test::Unit::TestCase
+
+  # KEY for regex tests
+  # :a == no change
+  # :b == will change (but sometimes ONLY once)
+  # :c == change to
+
+  include SexpMatchSpecials
+
+  def util_equals3(x, y)
+    result = x === y
+    assert_not_nil result, "#{x.inspect} does not === #{y.inspect}"
+  end
+
+  def setup
+    @any = ANY()
+  end
+
+  def test_stupid
+    # shuts up test/unit
+  end
+end
+
+class TestSexp < SexpTestCase # ZenTest FULL
+
+  def util_pretty_print(expect, input)
+    io = StringIO.new
+    PP.pp(input, io)
+    io.rewind
+    assert_equal(expect, io.read.chomp)
+  end
+
+  def setup
+    super
+    @sexp_class = Object.const_get(self.class.name[4..-1])
+    @processor = SexpProcessor.new
+    @sexp = @sexp_class.new(1, 2, 3)
+    @basic_sexp = s(:lasgn, :var, s(:lit, 42))
+    @re = s(:lit, 42)
+    @bad1 = s(:lit, 24)
+    @bad1 = s(:blah, 42)
+  end
+
+  def test_class_from_array
+#    raise NotImplementedError, 'Need to write test_class_from_array'
+  end
+
+  def test_class_index
+#    raise NotImplementedError, 'Need to write test_class_index'
+  end
+
+  def test_accessors; end # handled
+
+  def test_accessors_equals
+    a = s(:call, s(:lit, 1), "func", s(:array, s(:lit, 2)))
+    a.accessors = [:lhs, :name, :rhs]
+
+    assert_equal a.accessors, [:lhs, :name, :rhs]
+
+    assert_equal s(:lit, 1), a.lhs
+    assert_equal "func", a.name
+    assert_equal s(:array, s(:lit, 2)), a.rhs
+
+    a.accessors = []
+
+    assert_raises NoMethodError do
+      a.lhs
+    end
+  end
+
+  def test_array_type_eh
+    assert_equal false, @sexp.array_type?
+    @sexp.unshift :array
+    assert_equal true, @sexp.array_type?
+  end
+
+  def test_each_of_type
+    # TODO: huh... this tests fails if top level sexp :b is removed
+    @sexp = s(:b, s(:a, s(:b, s(:a), :a, s(:b, :a), s(:b, s(:a)))))
+    count = 0
+    @sexp.each_of_type(:a) do |exp|
+      count += 1
+    end
+    assert_equal(3, count, "must find 3 a's in #{@sexp.inspect}")
+  end
+
+  def test_equals2_array
+    # can't use assert_equals because it uses array as receiver
+    assert_not_equal(@sexp, [1, 2, 3],
+                     "Sexp must not be equal to equivalent array")
+    # both directions just in case
+    # HACK - this seems to be a bug in ruby as far as I'm concerned
+    # assert_not_equal([1, 2, 3], @sexp,
+    #   "Sexp must not be equal to equivalent array")
+  end
+
+  def test_equals2_not_body
+    sexp2 = s(1, 2, 5)
+    assert_not_equal(@sexp, sexp2)
+  end
+ 
+  def test_equals2_sexp
+    sexp2 = s(1, 2, 3)
+    if @sexp.class == Sexp then
+#    sexp3 = t(1, 2, 3, Type.str)
+#    case @sexp
+#    when TypedSexp
+#      assert_equal(@sexp, sexp3)
+#      assert_not_equal(@sexp, sexp2)
+#    when Sexp
+      assert_equal(@sexp, sexp2)
+#      assert_not_equal(@sexp, sexp3)
+    else
+      assert_not_equal(@sexp, sexp2)
+#    else
+#      flunk "unknown type"
+    end
+  end
+
+  def test_equals3_any
+    util_equals3 @any, s()
+    util_equals3 @any, s(:a)
+    util_equals3 @any, s(:a, :b, s(:c))
+  end
+
+  def test_equals3_full_match
+    util_equals3 s(), s()             # 0
+    util_equals3 s(:blah), s(:blah)   # 1
+    util_equals3 s(:a, :b), s(:a, :b) # 2
+    util_equals3 @basic_sexp, @basic_sexp.dup     # deeper structure
+  end
+
+  def test_equals3_mismatch
+    assert_nil s() === s(:a)
+    assert_nil s(:a) === s()
+    assert_nil s(:blah1) === s(:blah2)
+    assert_nil s(:a) === s(:a, :b)
+    assert_nil s(:a, :b) === s(:a)
+    assert_nil s(:a1, :b) === s(:a2, :b)
+    assert_nil s(:a, :b1) === s(:a, :b2)
+    assert_nil @basic_sexp === @basic_sexp.dup.push(42)
+    assert_nil @basic_sexp.dup.push(42) === @basic_sexp
+  end
+
+  def test_equals3_subset_match
+    util_equals3 s(:a), s(s(:a), s(:b))                 # left
+    util_equals3 s(:a), s(:blah, s(:a   ), s(:b))       # mid 1
+    util_equals3 s(:a, 1), s(:blah, s(:a, 1), s(:b))    # mid 2
+    util_equals3 @basic_sexp, s(:blah, @basic_sexp.dup, s(:b))      # mid deeper
+    util_equals3 @basic_sexp, s(@basic_sexp.dup, s(:a), s(:b))      # left deeper
+
+    util_equals3 s(:a), s(:blah, s(:blah, s(:a)))       # left deeper
+  end
+  
+#   def test_equalstilde_any
+#     result = @basic_sexp =~ s(:lit, ANY())
+#     p result
+#     assert result
+#   end
+
+  def test_equalstilde_fancy   
+    assert_nil     s(:b) =~ s(:a, s(:b), :c)
+    assert_not_nil s(:a, s(:b), :c) =~ s(:b)
+  end
+
+  def test_equalstilde_plain
+    result = @basic_sexp =~ @re
+    assert result
+  end
+
+  def test_find_and_replace_all
+    @sexp    = s(:a, s(:b, s(:a), s(:b), s(:b, s(:a))))
+    expected = s(:a, s(:a, s(:a), s(:a), s(:a, s(:a))))
+
+    @sexp.find_and_replace_all(:b, :a)
+
+    assert_equal(expected, @sexp)
+  end
+
+  def test_gsub
+    assert_equal s(:c), s().gsub(s(), s(:c))
+    assert_equal s(:c), s(:b).gsub(s(:b), s(:c))
+    assert_equal s(:a), s(:a).gsub(s(:b), s(:c))
+    assert_equal s(:a, s(:c)), s(:a, s(:b)).gsub(s(:b), s(:c))
+
+    assert_equal(s(:a, s(:c), s(:c)),
+                 s(:a, s(:b), s(:b)).gsub(s(:b), s(:c)))
+    assert_equal(s(:a, s(:c), s(:a, s(:c))),
+                 s(:a, s(:b), s(:a, s(:b))).gsub(s(:b), s(:c)))
+  end
+
+  def test_inspect
+    k = @sexp_class
+    n = k.name[0].chr.downcase
+    assert_equal("#{n}()",
+                 k.new().inspect)
+    assert_equal("#{n}(:a)",
+                 k.new(:a).inspect)
+    assert_equal("#{n}(:a, :b)",
+                 k.new(:a, :b).inspect)
+    assert_equal("#{n}(:a, #{n}(:b))",
+                 k.new(:a, k.new(:b)).inspect)
+  end
+
+  def test_method_missing
+    assert_raises NoMethodError do
+      @sexp.no_such_method
+    end
+
+    @sexp.accessors = [:its_a_method_now]
+
+    assert_nothing_raised do
+      assert_equal 2, @sexp.its_a_method_now
+    end
+  end
+
+  def test_pretty_print
+    util_pretty_print("s()",
+                       s())
+    util_pretty_print("s(:a)",
+                       s(:a))
+    util_pretty_print("s(:a, :b)",
+                       s(:a, :b))
+    util_pretty_print("s(:a, s(:b))",
+                       s(:a, s(:b)))
+  end
+
+  def test_sexp_body
+    assert_equal [2, 3], @sexp.sexp_body
+  end
+
+  def test_shift
+    assert_equal(1, @sexp.shift)
+    assert_equal(2, @sexp.shift)
+    assert_equal(3, @sexp.shift)
+
+    assert_raise(RuntimeError) do
+      @sexp.shift
+    end
+  end
+
+  def test_structure
+    @sexp    = s(:a, 1, 2, s(:b, 3, 4), 5, 6)
+    expected = s(:a, s(:b))
+
+    assert_equal(expected, @sexp.structure)
+  end
+
+  def test_sub
+    assert_equal s(:c), s().sub(s(), s(:c))
+    assert_equal s(:c), s(:b).sub(s(:b), s(:c))
+    assert_equal s(:a), s(:a).sub(s(:b), s(:c))
+    assert_equal s(:a, s(:c)), s(:a, s(:c)).sub(s(:b), s(:c))
+
+    assert_equal s(:a, s(:c), s(:b)), s(:a, s(:b), s(:b)).sub(s(:b), s(:c))
+
+    assert_equal(s(:a, s(:c), s(:a)),
+                 s(:a, s(:b), s(:a)).sub(s(:b), s(:c)))
+    assert_equal(s(:a, s(:c), s(:a, s(:a))),
+                 s(:a, s(:b), s(:a, s(:a))).sub(s(:b), s(:c)))
+    assert_equal(s(:a, s(:a), s(:a, s(:c), s(:b))),
+                 s(:a, s(:a), s(:a, s(:b), s(:b))).sub(s(:b), s(:c)))
+    assert_equal(s(:a, s(:c, s(:b))),
+                 s(:a, s(:b)).sub(s(:b), s(:c, s(:b))))
+  end
+
+  def test_to_a
+    assert_equal([1, 2, 3], @sexp.to_a)
+  end
+
+  def test_to_s
+    test_inspect
+  end
+end
+
+class TestSexpAny < SexpTestCase
+
+  def setup
+    super
+  end
+
+  def test_equals3
+    util_equals3 @any, s()
+    util_equals3 @any, s(:a)
+    util_equals3 @any, s(:a, :b, s(:c))
+  end
+
+end

data/test/test_sexp_processor.rb

@@ -78,156 +78,6 @@ end
 
 # Real test classes:
 
-class TestSexp < Test::Unit::TestCase # ZenTest FULL
-
-  def setup
-    @sexp_class = Object.const_get(self.class.name[4..-1])
-    @processor = SexpProcessor.new
-    @sexp = @sexp_class.new(1, 2, 3)
-  end
-
-  def test_new_nested
-    @sexp = s(:lasgn, "var", s(:str, "foo"))
-    assert_equal('s(:lasgn, "var", s(:str, "foo"))',
-                 @sexp.inspect)
-  end
-
-  def test_equals_array
-    # can't use assert_equals because it uses array as receiver
-    assert_not_equal(@sexp, [1, 2, 3],
-                     "Sexp must not be equal to equivalent array")
-    # both directions just in case
-# HACK - not sure why it is failing now that we split out TypedSexp
-#    assert_not_equal([1, 2, 3], @sexp,
-#                     "Sexp must not be equal to equivalent array")
-  end
-
-  def test_equals_sexp
-    sexp2 = s(1, 2, 3)
-    assert_equal(@sexp, sexp2)
-  end
-
-  def test_equals_not_body
-    sexp2 = s(1, 2, 5)
-    assert_not_equal(@sexp, sexp2)
-  end
- 
-  def test_to_a
-    assert_equal([1, 2, 3], @sexp.to_a)
-  end
-
-  def test_accessors=
-    a = s(:call, s(:lit, 1), "func", s(:array, s(:lit, 2)))
-    a.accessors = [:lhs, :name, :rhs]
-
-    assert_equal a.accessors, [:lhs, :name, :rhs]
-
-    assert_equal s(:lit, 1), a.lhs
-    assert_equal "func", a.name
-    assert_equal s(:array, s(:lit, 2)), a.rhs
-
-    a.accessors = []
-
-    assert_raises NoMethodError do
-      a.lhs
-    end
-  end
-  def test_accessors; end # handled
-
-  def test_sexp_body
-    assert_equal [2, 3], @sexp.sexp_body
-  end
-
-  def test_array_type?
-    assert_equal false, @sexp.array_type?
-    @sexp.unshift :array
-    assert_equal true, @sexp.array_type?
-  end
-
-  def test_each_of_type
-    # TODO: huh... this tests fails if top level sexp :b is removed
-    @sexp = s(:b, s(:a, s(:b, s(:a), :a, s(:b, :a), s(:b, s(:a)))))
-    count = 0
-    @sexp.each_of_type(:a) do |exp|
-      count += 1
-    end
-    assert_equal(3, count, "must find 3 a's in #{@sexp.inspect}")
-  end
-
-  def test_find_and_replace_all
-    @sexp    = s(:a, s(:b, s(:a), s(:b), s(:b, s(:a))))
-    expected = s(:a, s(:a, s(:a), s(:a), s(:a, s(:a))))
-
-    @sexp.find_and_replace_all(:b, :a)
-
-    assert_equal(expected, @sexp)
-  end
-
-  def test_structure
-    @sexp    = s(:a, 1, 2, s(:b, 3, 4), 5, 6)
-    expected = s(:a, s(:b))
-
-    assert_equal(expected, @sexp.structure)
-  end
-
-  def test_method_missing
-    assert_raises NoMethodError do
-      @sexp.no_such_method
-    end
-
-    @sexp.accessors = [:its_a_method_now]
-
-    assert_nothing_raised do
-      assert_equal 2, @sexp.its_a_method_now
-    end
-  end
-
-  def test_inspect
-    k = @sexp_class
-    n = k.name[0].chr.downcase
-    assert_equal("#{n}()",
-                 k.new().inspect)
-    assert_equal("#{n}(:a)",
-                 k.new(:a).inspect)
-    assert_equal("#{n}(:a, :b)",
-                 k.new(:a, :b).inspect)
-    assert_equal("#{n}(:a, #{n}(:b))",
-                 k.new(:a, k.new(:b)).inspect)
-  end
-
-  def test_to_s
-    test_inspect
-  end
-
-  def util_pretty_print(expect, input)
-    io = StringIO.new
-    PP.pp(input, io)
-    io.rewind
-    assert_equal(expect, io.read.chomp)
-  end
-
-  def test_pretty_print
-    util_pretty_print("s()",
-                       s())
-    util_pretty_print("s(:a)",
-                       s(:a))
-    util_pretty_print("s(:a, :b)",
-                       s(:a, :b))
-    util_pretty_print("s(:a, s(:b))",
-                       s(:a, s(:b)))
-  end
-
-  def test_shift
-    assert_equal(1, @sexp.shift)
-    assert_equal(2, @sexp.shift)
-    assert_equal(3, @sexp.shift)
-
-    assert_raise(RuntimeError) do
-      @sexp.shift
-    end
-  end
-end
-
 class TestSexpProcessor < Test::Unit::TestCase
 
   def setup

metadata

@@ -1,69 +1,74 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10.1
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11.1
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.3.7
-date: 2005-07-13
+  version: 1.4.0
+date: 2005-10-17 00:00:00 -07:00
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
-  - lib
-  - test
+- lib
+- test
 email: ryand-ruby@zenspider.com
 homepage: http://www.zenspider.com/ZSS/Products/ParseTree/
 rubyforge_project: parsetree
-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."
+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: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: 
-  - Ryan Davis
+- Ryan Davis
 files: 
-  - History.txt
-  - Makefile
-  - Manifest.txt
-  - README.txt
-  - 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
-  - validate.sh
+- History.txt
+- Makefile
+- Manifest.txt
+- README.txt
+- bin/parse_tree_abc
+- bin/parse_tree_deps
+- bin/parse_tree_show
+- demo/printer.rb
+- lib/composite_sexp_processor.rb
+- lib/parse_tree.rb
+- lib/sexp.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.rb
+- test/test_sexp_processor.rb
+- validate.sh
 test_files: 
-  - test/test_all.rb
+- test/test_all.rb
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: 
-  - parse_tree_abc
-  - parse_tree_deps
-  - parse_tree_show
+- parse_tree_abc
+- parse_tree_deps
+- parse_tree_show
 extensions: []
+
 requirements: []
+
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: RubyInline
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Version::Requirement 
-      requirements: 
-        - 
-          - ">="
-          - !ruby/object:Gem::Version 
-            version: 3.2.0
-      version: 
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.2.0
+    version: