ParseTree 1.1.0

data/test_all.rb

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

data/test_composite_sexp_processor.rb

@@ -0,0 +1,69 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'composite_sexp_processor'
+require 'test/unit'
+
+class FakeProcessor1 < SexpProcessor # ZenTest SKIP
+
+  def initialize
+    super
+    self.warn_on_default = false
+    self.default_method = :default_processor
+    self.expected = Array
+  end
+
+  def default_processor(exp)
+    result = []
+    until exp.empty? do
+      result << exp.shift.to_s + " woot"
+    end
+    result
+  end
+end
+
+class TestCompositeSexpProcessor < Test::Unit::TestCase
+
+  def setup
+    @p = CompositeSexpProcessor.new
+  end
+
+  def test_process_default
+    data = [1, 2, 3]
+    result = @p.process(data.dup)
+    assert_equal(data.dup, result)
+  end
+
+  def test_process_fake1
+    data = [1, 2, 3]
+    @p << FakeProcessor1.new
+    result = @p.process(data.dup)
+    assert_equal(data.map {|x| "#{x} woot"}, result)
+  end
+
+  def test_process_fake1_twice
+    data = [1, 2, 3]
+    @p << FakeProcessor1.new
+    @p << FakeProcessor1.new
+    result = @p.process(data.dup)
+    assert_equal(data.map {|x| "#{x} woot woot"}, result)
+  end
+
+  def test_processors
+    # everything is tested by test_append
+  end
+
+  def test_append
+    assert_equal([], @p.processors)
+
+    assert_raises(ArgumentError) do
+      @p << 42
+    end
+
+    fp1 = FakeProcessor1.new
+    @p << fp1
+    assert_equal([fp1], @p.processors)
+  end
+
+end

data/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 = []
+
+  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
+

data/test_sexp_processor.rb

@@ -0,0 +1,382 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'sexp_processor'
+require 'stringio'
+require 'test/unit'
+require 'pp'
+
+# Fake test classes:
+
+class TestProcessor < SexpProcessor # ZenTest SKIP
+  attr_accessor :auto_shift_type
+
+  def process_acc1(exp)
+    out = self.expected.new(:acc2, exp.thing_three, exp.thing_two, exp.thing_one)
+    exp.clear
+    return out
+  end
+
+  def process_acc2(exp)
+    out = []
+    out << exp.thing_one
+  end
+
+  def process_specific(exp)
+    result = exp[1..-1]
+    exp.clear
+    self.expected.new(*result)
+  end
+
+  def process_strip(exp)
+    result = exp.deep_clone
+    exp.clear
+    result
+  end
+
+  def process_nonempty(exp)
+    exp
+  end
+
+  def process_broken(exp)
+    result = [*exp]
+    exp.clear
+    result
+  end
+
+  def process_expected(exp)
+    exp.clear
+    return {}
+  end
+
+  def process_string(exp)
+    return exp.shift
+  end 
+
+end
+
+class TestProcessorDefault < SexpProcessor # ZenTest SKIP
+  def initialize
+    super
+    self.default_method = :def_method
+  end
+
+  def def_method(exp)
+    exp.clear
+    self.expected.new(42)
+  end
+end
+
+# Real test classes:
+
+class TestSexp < Test::Unit::TestCase # ZenTest FULL
+
+  def util_sexp_class
+    Object.const_get(self.class.name[4..-1])
+  end
+
+  def setup
+    @sexp_class = util_sexp_class
+    @processor = SexpProcessor.new
+    @sexp = @sexp_class.new(1, 2, 3)
+  end
+
+  def test_new_nested
+    @sexp = Sexp.new(:lasgn, "var", Sexp.new(:str, "foo"))
+    assert_equal('Sexp.new(:lasgn, "var", Sexp.new(: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 = Sexp.new(1, 2, 3)
+    assert_equal(@sexp, sexp2)
+  end
+
+  def test_equals_not_body
+    sexp2 = Sexp.new(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_inspect
+    k = @sexp_class
+    assert_equal("#{k}.new()",
+                 k.new().inspect)
+    assert_equal("#{k}.new(:a)",
+                 k.new(:a).inspect)
+    assert_equal("#{k}.new(:a, :b)",
+                 k.new(:a, :b).inspect)
+    assert_equal("#{k}.new(:a, #{k}.new(:b))",
+                 k.new(:a, k.new(:b)).inspect)
+  end
+
+  def test_to_s
+    test_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 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_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
+
+  def setup
+    @processor = TestProcessor.new
+  end
+
+  def test_sexp_accessors
+    @processor.sexp_accessors = {
+      :acc1 => [:thing_one, :thing_two, :thing_three]
+    }
+
+    a = s(:acc1, 1, 2, 3)
+
+    assert_equal s(:acc2, 3, 2, 1), @processor.process(a)
+  end
+
+  def test_sexp_accessors_reset
+    @processor.sexp_accessors = {
+      :acc1 => [:thing_one, :thing_two, :thing_three]
+    }
+
+    a = s(:acc1, 1, 2, 3)
+    b = @processor.process(a)
+
+    assert_raises NoMethodError do
+      @processor.process(b)
+    end
+  end
+  def test_sexp_accessors=; end # handled
+
+  def test_process_specific
+    a = [:specific, 1, 2, 3]
+    expected = a[1..-1]
+    assert_equal(expected, @processor.process(a))
+  end
+
+  def test_process_general
+    a = [:blah, 1, 2, 3]
+    expected = a.deep_clone
+    assert_equal(expected, @processor.process(a))
+  end
+
+  def test_process_default
+    @processor = TestProcessorDefault.new
+    @processor.warn_on_default = false
+
+    a = s(:blah, 1, 2, 3)
+    assert_equal(@processor.expected.new(42), @processor.process(a))
+  end
+
+  def test_process_not_sexp
+    @processor = TestProcessor.new
+    @processor.warn_on_default = false
+
+    assert_raises(TypeError) do
+      @processor.process([:broken, 1, 2, 3])
+    end
+  end
+
+  def test_exclude
+    @processor.exclude = [ :blah ]
+    assert_raise(SyntaxError) do
+      @processor.process([:blah, 1, 2, 3])
+    end
+  end
+
+  def test_exclude=; end # Handled
+
+  def test_strict
+    @processor.strict = true
+    assert_raise(SyntaxError) do
+      @processor.process([:blah, 1, 2, 3])
+    end
+  end
+  def test_strict=; end #Handled
+
+  def test_require_empty_false
+    @processor.require_empty = false
+    @processor.expected = Object
+
+    assert_nothing_raised do
+      @processor.process([:nonempty, 1, 2, 3])
+    end
+  end
+
+  def test_require_empty_true
+    assert_raise(TypeError) do
+      @processor.process([:nonempty, 1, 2, 3])
+    end
+  end
+  def test_require_empty=; end # handled
+
+  def test_process_strip
+    @processor.auto_shift_type = true
+    assert_equal([1, 2, 3], @processor.process(s(:strip, 1, 2, 3)))
+  end
+
+  def test_assert_type_hit
+    assert_nothing_raised do
+      @processor.assert_type([:blah, 1, 2, 3], :blah)
+    end
+  end
+
+  def test_assert_type_miss
+    assert_raise(TypeError) do
+      @processor.assert_type([:thingy, 1, 2, 3], :blah)
+    end
+  end
+
+  def test_generate
+    # nothing to test at this time... soon.
+  end
+
+  def test_auto_shift_type
+    @processor.auto_shift_type = false
+    assert_equal(false, @processor.auto_shift_type)
+    @processor.auto_shift_type = true
+    assert_equal(true, @processor.auto_shift_type)
+  end
+  def test_auto_shift_type_equal; end # handled
+
+  def test_default_method
+    # default functionality tested in process_default
+    assert_nil @processor.default_method
+    @processor.default_method = :something
+    assert_equal :something, @processor.default_method
+  end
+  def test_default_method=; end # handled
+
+  def test_expected
+    assert_equal Sexp, @processor.expected
+    assert_raises(TypeError) do
+      @processor.process([:expected])           # should raise
+    end
+
+    @processor.process(s(:str, "string"))       # shouldn't raise
+
+    @processor.expected = Hash
+    assert_equal Hash, @processor.expected
+    assert !(Hash === Sexp.new()), "Hash === Sexp.new should not be true"
+
+    assert_raises(TypeError) do
+      @processor.process(s(:string, "string"))     # should raise
+    end
+
+    @processor.process([:expected])        # shouldn't raise
+  end
+  def test_expected=; end # handled
+
+  # Not Testing:
+  def test_debug; end
+  def test_debug=; end
+  def test_warn_on_default; end
+  def test_warn_on_default=; end
+
+end
+