ParseTree 1.1.1 → 1.2.0

data/{sexp_processor.rb → lib/sexp_processor.rb}

@@ -2,31 +2,53 @@
 $TESTING = false unless defined? $TESTING
 
 class Object
+
+  ##
+  # deep_clone is the usual Marshalling hack to make a deep copy.
+  # It is rather slow, so use it sparingly. Helps with debugging
+  # SexpProcessors since you usually shift off sexps.
+
   def deep_clone
     Marshal.load(Marshal.dump(self))
   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
-  attr_accessor :unpack
 
-  alias_method :unpack?, :unpack
+  ##
+  # Create a new Sexp containing +args+.
 
   def initialize(*args)
-    @unpack = false
     @accessors = []
     super(args)
   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
@@ -36,7 +58,10 @@ class Sexp < Array # ZenTest FULL
     end
   end
 
-  # TODO: need to write test
+  ##
+  # 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
@@ -47,6 +72,30 @@ class Sexp < Array # ZenTest FULL
     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
 
@@ -54,11 +103,14 @@ class Sexp < Array # ZenTest FULL
     return self.at(index)
   end
 
+  ##
+  # Returns the Sexp without the node_type.
+
   def sexp_body
     self[1..-1]
   end
 
-  def ==(obj)
+  def ==(obj) # :nodoc:
     case obj
     when Sexp
       super
@@ -67,25 +119,29 @@ class Sexp < Array # ZenTest FULL
     end
   end
 
-  def to_a
+  def to_a # :nodoc:
     self.map { |o| Sexp === o ? o.to_a : o }
   end
 
-  def inspect
+  def inspect # :nodoc:
     sexp_str = self.map {|x|x.inspect}.join(', ')
     return "Sexp.new(#{sexp_str})"
   end
 
-  def pretty_print(q)
+  def pretty_print(q) # :nodoc:
     q.group(1, 's(', ')') do
       q.seplist(self) {|v| q.pp v }
     end
   end
 
-  def to_s
+  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
@@ -93,7 +149,10 @@ class Sexp < Array # ZenTest FULL
 
 end
 
-def s(*args) # stupid shortcut to make indentation much cleaner
+##
+# This is just a stupid shortcut to make indentation much cleaner.
+
+def s(*args)
   Sexp.new(*args)
 end
 
@@ -114,7 +173,6 @@ end
 # Here is a simple example:
 #
 #   class MyProcessor < SexpProcessor
-#   
 #     def initialize
 #       super
 #       self.strict = false
@@ -124,7 +182,6 @@ end
 #       val = exp.shift
 #       return val
 #     end
-#   
 #   end
 
 class SexpProcessor
@@ -263,11 +320,7 @@ class SexpProcessor
           else
             sub_result = sub_exp
           end
-          if Sexp === sub_result && sub_result.unpack? then
-            result.push(*sub_result)
-          else
-            result << sub_result
-          end
+          result << sub_result
         end
 
         # NOTE: this is costly, but we are in the generic processor
@@ -293,9 +346,26 @@ class SexpProcessor
   # Raises unless the Sexp type for +list+ matches +typ+
 
   def assert_type(list, typ)
-    raise TypeError, "Expected type #{typ.inspect} in #{list.inspect}" \
-      if list.first != typ
+    raise TypeError, "Expected type #{typ.inspect} in #{list.inspect}" if
+      list.first != typ
   end
 
+  ##
+  # A fairly generic processor for a dummy node. Dummy nodes are used
+  # when your processor is doing a complicated rewrite that replaces
+  # the current sexp with multiple sexps.
+  #
+  # Bogus Example:
+  #
+  # def process_something(exp)
+  #   return s(:dummy, process(exp), s(:extra, 42))
+
+  def process_dummy(exp)
+    result = @expected.new(:dummy)
+    until exp.empty? do
+      result << self.process(exp.shift)
+    end
+    result
+  end
 end
 

data/test/test_all.rb

@@ -0,0 +1,13 @@
+#!/usr/local/bin/ruby -w
+
+pat = "test_*.rb"
+if File.basename(Dir.pwd) != "test" then
+  $: << "test"
+  pat = File.join("test", pat)
+end
+
+Dir.glob(pat).each do |f|
+  require f
+end
+
+require 'test/unit'

data/test/test_parse_tree.rb

@@ -0,0 +1,275 @@
+#!/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 = [:class, :Something, :Object]
+
+  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_for_method(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_for_method(Something, :missing),
+		 "Must return -3 for missing methods")
+  end
+
+  def test_class
+    assert_equal([@@__all],
+		 @thing.parse_tree(Something),
+		 "Must return a lot of shit")
+  end
+
+end
+