ParseTree 2.2.0 → 3.0.0

data/test/test_composite_sexp_processor.rb

@@ -1,70 +0,0 @@
-#!/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 = []
-    result << exp.shift
-    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 = [:x, 1, 2, 3]
-    @p << FakeProcessor1.new
-    result = @p.process(data.dup)
-    assert_equal [:x, "1 woot", "2 woot", "3 woot"], result
-  end
-
-  def test_process_fake1_twice
-    data = [:x, 1, 2, 3]
-    @p << FakeProcessor1.new
-    @p << FakeProcessor1.new
-    result = @p.process(data.dup)
-    assert_equal [:x, "1 woot woot", "2 woot woot", "3 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/test_sexp.rb

@@ -1,313 +0,0 @@
-#!/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
-
-  unless defined? Mini then
-    alias :refute_nil :assert_not_nil
-    alias :refute_equal :assert_not_equal
-    alias :assert_raises :assert_raise
-  end
-
-  # KEY for regex tests
-  # :a == no change
-  # :b == will change (but sometimes ONLY once)
-  # :c == change to
-
-  include SexpMatchSpecials
-
-  def util_equals(x, y)
-    result = x == y
-    refute_nil result, "#{x.inspect} does not === #{y.inspect}"
-  end
-
-  def util_equals3(x, y)
-    result = x === y
-    refute_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
-
-  class SexpFor
-    def method
-      1
-    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 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_for
-    sexp = Sexp.for SexpFor
-    assert_equal s(:class, :"TestSexp::SexpFor"), sexp[0..1]
-
-    sexp = Sexp.for SexpFor, :method
-    assert_equal s(:defn, :method), sexp[0..1]
-  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_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
-    refute_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)
-    refute_equal(@sexp, sexp2)
-  end
-
-  def test_equals2_sexp
-    sexp2 = s(1, 2, 3)
-    unless @sexp.class == Sexp then
-      refute_equal(@sexp, sexp2)
-    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)
-    refute_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_nil @sexp.not_there
-    assert_equal s(:lit, 42), @basic_sexp.lit
-  end
-
-  def test_method_missing_ambigious
-    assert_raises NoMethodError do
-      pirate = s(:says, s(:arrr!), s(:arrr!), s(:arrr!))
-      pirate.arrr!
-    end
-  end
-
-  def test_method_missing_deep
-    sexp = s(:blah, s(:a, s(:b, s(:c, :yay!))))
-    assert_equal(s(:c, :yay!), sexp.a.b.c)
-  end
-
-  def test_method_missing_delete
-    sexp = s(:blah, s(:a, s(:b, s(:c, :yay!))))
-
-    assert_equal(s(:c, :yay!), sexp.a.b.c(true))
-    assert_equal(s(:blah, s(:a, s(:b))), sexp)
-  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_raises(RuntimeError) do
-      @sexp.shift
-    end
-  end
-
-  def test_structure
-    @sexp    = s(:a, 1, 2, s(:b, 3, 4), 5, 6)
-    backup = @sexp.deep_clone
-    expected = s(:a, s(:b))
-
-    assert_equal(expected, @sexp.structure)
-    assert_equal(backup, @sexp)
-  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_equals
-    util_equals @any, s()
-    util_equals @any, s(:a)
-    util_equals @any, s(:a, :b, s(:c))
-  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

@@ -1,297 +0,0 @@
-#!/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)
-    name = exp.shift
-    result = s(:blah)
-    until exp.empty?
-      result.push process(exp.shift)
-    end
-    result
-  end
-
-  def process_strip(exp)
-    result = exp.deep_clone
-    exp.clear
-    result
-  end
-
-  def process_nonempty(exp)
-    s(*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
-
-  def rewrite_rewritable(exp) # (a b c) => (a c b)
-    return s(exp.shift, exp.pop, exp.shift)
-  end
-
-  def process_rewritable(exp)
-    @n ||= 0
-    exp.shift # name
-    result = s(:rewritten)
-    until exp.empty?
-      result.push process(exp.shift)
-    end
-    result.push @n
-    @n += 1
-    result
-  end
-
-  def rewrite_major_rewrite(exp)
-    exp[0] = :rewritable
-    exp
-  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 TestSexpProcessor < Test::Unit::TestCase
-
-  def setup
-    @processor = TestProcessor.new
-  end
-
-  def test_process_specific
-    a = [:specific, [:x, 1], [:y, 2], [:z, 3]]
-    expected = [:blah, [:x, 1], [:y, 2], [:z, 3]]
-    assert_equal(expected, @processor.process(a))
-  end
-
-  def test_process_generic
-    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 SexpTypeError do
-      @processor.process([:broken, 1, 2, 3])
-    end
-  end
-
-  def test_process_unsupported_wrong
-    @processor = TestProcessor.new
-    @processor.unsupported << :strip
-
-    assert_raises UnsupportedNodeError do
-      @processor.process([:whatever])
-    end
-  end
-
-  def test_unsupported_equal
-    @processor.strict = true
-    @processor.unsupported = [ :unsupported ]
-    assert_raises UnsupportedNodeError do
-      @processor.process([:unsupported, 42])
-    end
-  end
-
-  def test_strict
-    @processor.strict = true
-    assert_raises UnknownNodeError do
-      @processor.process([:blah, 1, 2, 3])
-    end
-  end
-  def test_strict=; end #Handled
-
-  def test_require_empty_false
-    @processor.require_empty = false
-
-    @processor.process([:nonempty, 1, 2, 3])
-  end
-
-  def test_require_empty_true
-    assert_raises NotEmptyError 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_rewrite
-    assert_equal(s(:rewritable, :b, :a),
-                 @processor.rewrite(s(:rewritable, :a, :b)))
-  end
-
-  def test_rewrite_different_type
-    assert_equal(s(:rewritable, :b, :a),
-                 @processor.rewrite(s(:major_rewrite, :a, :b)))
-  end
-
-  def test_rewrite_deep
-    assert_equal(s(:specific, s(:rewritable, :b, :a)),
-                 @processor.rewrite(s(:specific, s(:rewritable, :a, :b))))
-  end
-
-  def test_rewrite_not_empty
-    insert = s(:rewritable, 1, 2, 2)
-    expect = s(:rewritable, 2, 1)
-    result = @processor.rewrite(insert)
-    assert_equal(expect, result)
-    assert_equal(s(2), insert) # post-processing
-  end
-
-  def test_process_rewrite
-    assert_equal(s(:rewritten, s(:y, 2), s(:x, 1), 0),
-                 @processor.process(s(:rewritable, s(:x, 1), s(:y, 2))))
-  end
-
-  def test_process_rewrite_deep
-    assert_equal(s(:blah, s(:rewritten, s(:b), s(:a), 0)),
-                 @processor.process(s(:specific, s(:rewritable, s(:a), s(:b)))))
-  end
-
-  def test_rewrite_depth_first
-    inn = s(:specific,
-            s(:rewritable,
-              s(:a),
-              s(:rewritable,
-                s(:rewritable, s(:b), s(:c)),
-                s(:d))))
-    out = s(:specific,
-            s(:rewritable,
-              s(:rewritable,
-                s(:d),
-                s(:rewritable, s(:c), s(:b))),
-              s(:a)))
-
-    assert_equal(out, @processor.rewrite(inn))
-  end
-
-  def test_process_rewrite_depth_first
-    inn = s(:specific,
-            s(:rewritable,
-              s(:a),
-              s(:rewritable,
-                s(:rewritable, s(:b), s(:c)),
-                s(:d))))
-    out = s(:blah,
-            s(:rewritten,
-              s(:rewritten,
-                s(:d),
-                s(:rewritten, s(:c), s(:b), 0), 1),
-              s(:a), 2))
-
-    assert_equal(out, @processor.process(inn))
-  end
-
-  def test_assert_type_hit
-    @processor.assert_type([:blah, 1, 2, 3], :blah)
-  end
-
-  def test_assert_type_miss
-    assert_raises SexpTypeError 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 SexpTypeError 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 === s()), "Hash === s() should not be true"
-
-    assert_raises SexpTypeError 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