rubyjs 0.7.0

data/vendor/ParseTree-1.7.1/test/something.rb

@@ -0,0 +1,53 @@
+
+class Something
+
+  def self.classmethod
+    1 + 1
+  end
+
+  # 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)
+    return "foo"
+  end
+
+  def unknown_args(arg1, arg2)
+    # does nothing
+    return arg1
+  end
+
+  def determine_args
+    5 == unknown_args(4, "known")
+  end
+
+  # TODO: sort list
+  def bbegin
+    begin
+      1
+    rescue SyntaxError => e1
+      2
+    rescue Exception => e2
+      3
+    else
+      4
+    ensure
+      5
+    end
+  end
+
+  def bbegin_no_exception
+    begin
+      5
+    rescue
+      6
+    end
+  end
+end

data/vendor/ParseTree-1.7.1/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/vendor/ParseTree-1.7.1/test/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/vendor/ParseTree-1.7.1/test/test_parse_tree.rb

@@ -0,0 +1,216 @@
+#!/usr/local/bin/ruby -w
+
+dir = File.expand_path "~/.ruby_inline"
+if test ?d, dir then
+  require 'fileutils'
+  puts "nuking #{dir}"
+  FileUtils.rm_r dir
+end
+
+require 'test/unit'
+require 'parse_tree'
+require 'pt_testcase'
+require 'test/something'
+
+class SomethingWithInitialize
+  def initialize; end # this method is private
+  protected
+  def protected_meth; end
+end
+
+class ParseTree
+  def process(input) # makes it play with with ParseTreeTestCase (FIX?)
+    # um. kinda stupid, but cleaner
+    case input
+    when Array then
+      ParseTree.translate(*input)
+    else
+      ParseTree.translate(input)
+    end
+  end
+end
+
+class TestParseTree < ParseTreeTestCase
+  def setup
+    super
+    @processor = ParseTree.new(false)
+  end
+
+  def test_class_initialize
+    expected = [[:class, :SomethingWithInitialize, [:const, :Object],
+      [:defn, :initialize, [:scope, [:block, [:args], [:nil]]]],
+      [:defn, :protected_meth, [:scope, [:block, [:args], [:nil]]]],
+    ]]
+    tree = @processor.parse_tree SomethingWithInitialize
+    assert_equal expected, tree
+  end
+
+  def test_class_translate_string
+    str = "class A; def a; end; end"
+
+    sexp = ParseTree.translate str
+
+    expected = [:class, :A, nil,
+                 [:scope,
+                   [:defn, :a, [:scope, [:block, [:args], [:nil]]]]]]
+
+    assert_equal expected, sexp
+  end
+
+  def test_class_translate_string_method
+    str = "class A; def a; end; def b; end; end"
+
+    sexp = ParseTree.translate str, :a
+
+    expected = [:defn, :a, [:scope, [:block, [:args], [:nil]]]]
+
+    assert_equal expected, sexp
+  end
+
+  def test_parse_tree_for_string
+    actual   = @processor.parse_tree_for_string '1 + nil', '(string)', 1, false
+    expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  def test_parse_tree_for_string_with_newlines
+    actual   = @processor.parse_tree_for_string "1 +\n nil", 'test.rb', 5, true
+    expected = [[:newline, 6, "test.rb"],
+                [:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  def test_parse_tree_for_str
+    actual   = @processor.parse_tree_for_str '1 + nil', '(string)', 1, false
+    expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  @@self_classmethod = [:defn, :"self.classmethod",
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]]]
+
+  @@missing = [nil]
+
+  @@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,
+        [: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"]]]]]
+  @@unknown_args = [:defn, :unknown_args,
+    [:scope,
+      [:block,
+        [:args, :arg1, :arg2],
+        [:return, [:lvar, :arg1]]]]]
+  @@bbegin = [:defn, :bbegin,
+    [:scope,
+      [:block,
+        [:args],
+        [:begin,
+          [:ensure,
+            [:rescue,
+              [:lit, 1],
+              [:resbody,
+                [:array, [:const, :SyntaxError]],
+                [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
+                [:resbody,
+                  [:array, [:const, :Exception]],
+                  [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
+              [:lit, 4]],
+            [:lit, 5]]]]]]
+  @@bbegin_no_exception = [:defn, :bbegin_no_exception,
+    [:scope,
+      [:block,
+        [:args],
+        [:begin,
+          [:rescue,
+            [:lit, 5],
+            [:resbody, nil, [:lit, 6]]]]]]]
+
+  @@determine_args = [:defn, :determine_args,
+    [:scope,
+      [:block,
+        [:args],
+          [:call,
+            [:lit, 5],
+            :==,
+            [:array,
+              [:fcall,
+                :unknown_args,
+                [:array, [:lit, 4], [:str, "known"]]]]]]]]
+
+
+  @@attrasgn = [:defn,
+    :attrasgn,
+    [:scope,
+      [:block,
+        [:args],
+        [:attrasgn, [:lit, 42], :method=, [:array, [:vcall, :y]]],
+        [:attrasgn,
+          [:self],
+          :type=,
+          [:array, [:call, [:vcall, :other], :type]]]]]]
+
+  @@__all = [:class, :Something, [:const, :Object]]
+
+  Something.instance_methods(false).sort.each do |meth|
+    if class_variables.include?("@@#{meth}") then
+      @@__all << eval("@@#{meth}")
+      eval "def test_#{meth}; assert_equal @@#{meth}, @processor.parse_tree_for_method(Something, :#{meth}); end"
+    else
+      eval "def test_#{meth}; flunk \"You haven't added @@#{meth} yet\"; end"
+    end
+  end
+
+  Something.singleton_methods.sort.each do |meth|
+    next if meth =~ /yaml/ # rubygems introduced a bug
+    if class_variables.include?("@@self_#{meth}") then
+      @@__all << eval("@@self_#{meth}")
+      eval "def test_self_#{meth}; assert_equal @@self_#{meth}, @processor.parse_tree_for_method(Something, :#{meth}, true); end"
+    else
+      eval "def test_self_#{meth}; flunk \"You haven't added @@self_#{meth} yet\"; end"
+    end
+  end
+
+  def test_missing
+    assert_equal(@@missing,
+                 @processor.parse_tree_for_method(Something, :missing),
+                 "Must return -3 for missing methods")
+  end
+
+  def test_whole_class
+    assert_equal([@@__all],
+                 @processor.parse_tree(Something),
+                 "Must return a lot of shit")
+  end
+end

data/vendor/ParseTree-1.7.1/test/test_sexp.rb

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