fabiokung-sexp_processor 3.0.1

data/test/test_environment.rb

@@ -0,0 +1,85 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'test/unit' if $0 == __FILE__
+require 'test/unit/testcase'
+require 'sexp_processor'
+
+class TestEnvironment < Test::Unit::TestCase
+
+  def setup
+    @env = SexpProcessor::Environment.new
+  end
+
+  def test_all
+    @env.scope do
+      @env[:x] = 42
+
+      @env.scope do
+        @env[:y] = 3
+        @env[:x] = Math::PI
+
+        expected = { :x => Math::PI, :y => 3 }
+        assert_equal expected, @env.all
+      end
+
+      expected = { :x => Math::PI }
+      assert_equal expected, @env.all
+    end
+  end
+
+  def test_depth
+    assert_equal 1, @env.depth
+
+    @env.scope do
+      assert_equal 2, @env.depth
+    end
+
+    assert_equal 1, @env.depth
+  end
+
+  def test_index
+    test_index_equals
+  end
+
+  def test_index_unknown
+    assert_nil @env[:unknown]
+  end
+
+  def test_index_out_of_scope
+    @env.scope do
+      @env[:var] = 42
+      assert_equal 42, @env[:var]
+    end
+
+    assert_nil @env[:var]
+  end
+
+  def test_index_equals
+    @env[:var] = 42
+
+    assert_equal 42, @env[:var]
+  end
+
+  def test_lookup_scope
+    @env[:var] = 42
+    assert_equal 42, @env[:var]
+
+    @env.scope do
+      assert_equal 42, @env[:var]
+    end
+  end
+
+  def test_scope
+    @env[:var] = 42
+    assert_equal 42, @env[:var]
+
+    @env.scope do
+      @env[:var] = Math::PI
+      assert_equal Math::PI, @env[:var]
+    end
+
+    assert_equal Math::PI, @env[:var]
+  end
+end

data/test/test_sexp.rb

@@ -0,0 +1,305 @@
+#!/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_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

@@ -0,0 +1,297 @@
+#!/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