rubyjs 0.7.1 → 0.8.0

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

@@ -1,53 +0,0 @@
-
-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

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

@@ -1,69 +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 = []
-    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

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

@@ -1,291 +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
-
-  # 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