sexp2ruby 0.0.1 → 0.0.2

data/test/test_ruby2ruby.rb

@@ -1,496 +0,0 @@
-# WIP: Converting to rspec.  This file is not in a usable state.
-class TestRuby2Ruby
-  def setup
-    super
-    @check_sexp = ENV["CHECK_SEXPS"]
-    @processor = Ruby2Ruby.new
-  end
-
-  def do_not_check_sexp!
-    @check_sexp = false
-  end
-
-  def processor(opts)
-    Ruby2Ruby.new(opts)
-  end
-
-  def test_and_alias
-    inn = s(:and, s(:true), s(:alias, s(:lit, :a), s(:lit, :b)))
-    out = "true and (alias :a :b)"
-    util_compare inn, out
-  end
-
-  def test_attr_reader_diff
-    inn = s(:defn, :same, s(:args), s(:ivar, :@diff))
-    out = "def same\n  @diff\nend"
-    util_compare inn, out
-  end
-
-  def test_attr_reader_same
-    do_not_check_sexp!
-
-    inn = s(:defn, :same, s(:args), s(:ivar, :@same))
-    out = "attr_reader :same"
-    util_compare inn, out
-  end
-
-  def test_attr_reader_double
-    inn = s(:defn, :same, s(:args), s(:ivar, :@same), s(:ivar, :@diff))
-    out = "def same\n  @same\n  @diff\nend"
-    util_compare inn, out
-  end
-
-  def test_attr_reader_same_name_diff_body
-    do_not_check_sexp!
-
-    inn = s(:defn, :same, s(:args), s(:not, s(:ivar, :@same)))
-    out = "def same\n  (not @same)\nend"
-    util_compare inn, out
-  end
-
-  def test_attr_writer_diff
-    inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@diff, s(:lvar, :o)))
-    out = "def same=(o)\n  @diff = o\nend"
-    util_compare inn, out
-  end
-
-  def test_attr_writer_double
-    inn = s(:defn, :same=, s(:args, :o),
-            s(:iasgn, :@same, s(:lvar, :o)), s(:iasgn, :@diff, s(:lvar, :o)))
-    out = "def same=(o)\n  @same = o\n  @diff = o\nend"
-    util_compare inn, out
-  end
-
-  def test_attr_writer_same_name_diff_body
-    inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@same, s(:lit, 42)))
-    out = "def same=(o)\n  @same = 42\nend"
-    util_compare inn, out
-  end
-
-  def test_attr_writer_same
-    do_not_check_sexp!
-
-    inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@same , s(:lvar, :o)))
-    out = "attr_writer :same"
-    util_compare inn, out
-  end
-
-  def test_dregx_slash
-    do_not_check_sexp!
-
-    inn = util_thingy(:dregx)
-    out = '/a"b#{(1 + 1)}c"d\/e/'
-    util_compare inn, out, /a"b2c"d\/e/
-  end
-
-  def test_dstr_quote
-    inn = util_thingy(:dstr)
-    out = '"a\"b#{(1 + 1)}c\"d/e"'
-    util_compare inn, out, 'a"b2c"d/e'
-  end
-
-  def test_dsym_quote
-    inn = util_thingy(:dsym)
-    out = ':"a\"b#{(1 + 1)}c\"d/e"'
-    util_compare inn, out, :'a"b2c"d/e'
-  end
-
-  def test_lit_regexp_slash
-    do_not_check_sexp! # dunno why on this one
-
-    util_compare s(:lit, /blah\/blah/), '/blah\/blah/', /blah\/blah/
-  end
-
-  def test_call_kwsplat
-    inn = s(:call, nil, :test_splat, s(:hash, s(:kwsplat, s(:call, nil, :testing))))
-    out = "test_splat(**testing)"
-
-    util_compare inn, out
-  end
-
-  def test_call_arg_assoc_kwsplat
-    inn = s(:call, nil, :f,
-           s(:lit, 1),
-           s(:hash, s(:lit, :kw), s(:lit, 2), s(:kwsplat, s(:lit, 3))))
-    out = "f(1, :kw => 2, **3)"
-
-    util_compare inn, out
-  end
-
-  def test_call_kwsplat_x
-    inn = s(:call, nil, :a, s(:hash, s(:kwsplat, s(:lit, 1))))
-    out = "a(**1)"
-
-    util_compare inn, out
-  end
-
-  def test_defn_kwargs
-    inn = s(:defn, :initialize,
-            s(:args, :arg, s(:kwarg, :keyword, s(:nil)), :"**args"),
-            s(:nil))
-    out = "def initialize(arg, keyword: nil, **args)\n  # do nothing\nend"
-
-    util_compare inn, out
-  end
-
-  def test_defn_kwargs2
-    inn = s(:defn, :initialize,
-            s(:args, :arg,
-              s(:kwarg, :kw1, s(:nil)),
-              s(:kwarg, :kw2, s(:nil)),
-              :"**args"),
-            s(:nil))
-    out = "def initialize(arg, kw1: nil, kw2: nil, **args)\n  # do nothing\nend"
-
-    util_compare inn, out
-  end
-
-  def test_call_self_index
-    util_compare s(:call, nil, :[], s(:lit, 42)), "self[42]"
-  end
-
-  def test_call_self_index_equals
-    util_compare(s(:attrasgn, s(:self), :[]=, s(:lit, 42), s(:lit, 24)),
-                 "self[42] = 24")
-  end
-
-  def test_call_self_index_equals_array
-    util_compare(s(:attrasgn, s(:self), :[]=, s(:lit, 1), s(:lit, 2), s(:lit, 3)),
-                 "self[1, 2] = 3")
-  end
-
-  def test_call_arglist_hash_first
-    inn = s(:call, nil, :method,
-            s(:hash, s(:lit, :a), s(:lit, 1)),
-            s(:call, nil, :b))
-    out = "method({ :a => 1 }, b)"
-
-    util_compare inn, out
-  end
-
-  def test_call_arglist_hash_first_last
-    inn = s(:call, nil, :method,
-            s(:hash, s(:lit, :a), s(:lit, 1)),
-            s(:call, nil, :b),
-            s(:hash, s(:lit, :c), s(:lit, 1)))
-    out = "method({ :a => 1 }, b, :c => 1)"
-
-    util_compare inn, out
-  end
-
-  def test_call_arglist_hash_last
-    inn = s(:call, nil, :method,
-            s(:call, nil, :b),
-            s(:hash, s(:lit, :a), s(:lit, 1)))
-    out = "method(b, :a => 1)"
-
-    util_compare inn, out
-  end
-
-  def test_call_arglist_if
-    inn = s(:call,
-            s(:call, nil, :a),
-            :+,
-            s(:if,
-              s(:call, nil, :b),
-              s(:call, nil, :c),
-              s(:call, nil, :d)))
-
-    out = "(a + (b ? (c) : (d)))"
-    util_compare inn, out
-  end
-
-  def test_defn_kwsplat
-    inn = s(:defn, :test, s(:args, :"**testing"), s(:nil))
-    out = "def test(**testing)\n  # do nothing\nend"
-    assert_parse inn, out
-  end
-
-  def test_defn_rescue_return
-    inn = s(:defn, :blah, s(:args),
-           s(:rescue,
-             s(:lasgn, :a, s(:lit, 1)),
-             s(:resbody, s(:array), s(:return, s(:str, "a")))))
-    out = "def blah\n  a = 1\nrescue\n  return \"a\"\nend"
-
-    assert_parse inn, out
-  end
-
-  def test_masgn_block_arg
-    inn = s(:iter,
-            s(:call,
-              s(:nil),
-              :x),
-            s(:args, s(:masgn, :a, :b)),
-            s(:dstr, "",
-              s(:evstr, s(:lvar, :a)),
-              s(:str, "="),
-              s(:evstr, s(:lvar, :b))))
-    out = 'nil.x { |(a, b)| "#{a}=#{b}" }'
-
-    util_compare inn, out
-  end
-
-  def test_masgn_wtf
-    inn = s(:block,
-            s(:masgn,
-              s(:array, s(:lasgn, :k), s(:lasgn, :v)),
-              s(:splat,
-                s(:call,
-                  s(:call, nil, :line),
-                  :split,
-                  s(:lit, /\=/), s(:lit, 2)))),
-            s(:attrasgn,
-              s(:self),
-              :[]=,
-              s(:lvar, :k),
-              s(:call, s(:lvar, :v), :strip)))
-
-    out = "k, v = *line.split(/\\=/, 2)\nself[k] = v.strip\n"
-
-    util_compare inn, out
-  end
-
-  def test_masgn_splat_wtf
-    inn = s(:masgn,
-            s(:array, s(:lasgn, :k), s(:lasgn, :v)),
-            s(:splat,
-              s(:call,
-                s(:call, nil, :line),
-                :split,
-                s(:lit, /\=/), s(:lit, 2))))
-    out = 'k, v = *line.split(/\\=/, 2)'
-    util_compare inn, out
-  end
-
-  def test_match3_asgn
-    inn = s(:match3, s(:lit, //), s(:lasgn, :y, s(:call, nil, :x)))
-    out = "(y = x) =~ //"
-    # "y = x =~ //", which matches on x and assigns to y (not what sexp says).
-    util_compare inn, out
-  end
-
-  def test_splat_call
-    inn = s(:call, nil, :x,
-            s(:splat,
-              s(:call,
-                s(:call, nil, :line),
-                :split,
-                s(:lit, /\=/), s(:lit, 2))))
-
-    out = 'x(*line.split(/\=/, 2))'
-    util_compare inn, out
-  end
-
-  def test_resbody_block
-    inn = s(:rescue,
-            s(:call, nil, :x1),
-            s(:resbody,
-              s(:array),
-              s(:call, nil, :x2),
-              s(:call, nil, :x3)))
-
-    out = "begin\n  x1\nrescue\n  x2\n  x3\nend"
-    util_compare inn, out
-  end
-
-  def test_resbody_short_with_begin_end
-    # "begin; blah; rescue; []; end"
-    inn = s(:rescue,
-            s(:call, nil, :blah),
-            s(:resbody, s(:array), s(:array)))
-    out = "blah rescue []"
-    util_compare inn, out
-  end
-
-  def test_resbody_short_with_begin_end_multiple
-    # "begin; blah; rescue; []; end"
-    inn = s(:rescue,
-            s(:call, nil, :blah),
-            s(:resbody, s(:array),
-              s(:call, nil, :log),
-              s(:call, nil, :raise)))
-    out = "begin\n  blah\nrescue\n  log\n  raise\nend"
-    util_compare inn, out
-  end
-
-  def test_resbody_short_with_defn_multiple
-    inn = s(:defn,
-            :foo,
-            s(:args),
-            s(:rescue,
-              s(:lasgn, :a, s(:lit, 1)),
-              s(:resbody,
-                s(:array),
-                s(:call, nil, :log),
-                s(:call, nil, :raise))))
-    out = "def foo\n  a = 1\nrescue\n  log\n  raise\nend"
-    util_compare inn, out
-  end
-
-  def test_regexp_options
-    inn = s(:match3,
-            s(:dregx,
-              "abc",
-              s(:evstr, s(:call, nil, :x)),
-              s(:str, "def"),
-              4),
-            s(:str, "a"))
-    out = '"a" =~ /abc#{x}def/m'
-    util_compare inn, out
-  end
-
-  def test_resbody_short_with_rescue_args
-    inn = s(:rescue,
-            s(:call, nil, :blah),
-            s(:resbody, s(:array, s(:const, :A), s(:const, :B)), s(:array)))
-    out = "begin\n  blah\nrescue A, B\n  []\nend"
-    util_compare inn, out
-  end
-
-  def test_call_binary_call_with_hash_arg
-    # if 42
-    #   args << {:key => 24}
-    # end
-
-    inn = s(:if, s(:lit, 42),
-            s(:call, s(:call, nil, :args),
-              :<<,
-              s(:hash, s(:lit, :key), s(:lit, 24))),
-            nil)
-
-    out = "(args << { :key => 24 }) if 42"
-
-    util_compare inn, out
-  end
-
-  def test_binary_operators
-    # (1 > 2)
-    Ruby2Ruby::BINARY.each do |op|
-      inn = s(:call, s(:lit, 1), op, s(:lit, 2))
-      out = "(1 #{op} 2)"
-      util_compare inn, out
-    end
-  end
-
-  def test_call_empty_hash
-    inn = s(:call, nil, :foo, s(:hash))
-    out = "foo({})"
-    util_compare inn, out
-  end
-
-  def test_if_empty
-    inn = s(:if, s(:call, nil, :x), nil, nil)
-    out = "if x then\n  # do nothing\nend"
-    util_compare inn, out
-  end
-
-  def test_interpolation_and_escapes
-    # log_entry = "  \e[#{message_color}m#{message}\e[0m   "
-    inn = s(:lasgn, :log_entry,
-            s(:dstr, "  \e[",
-              s(:evstr, s(:call, nil, :message_color)),
-              s(:str, "m"),
-              s(:evstr, s(:call, nil, :message)),
-              s(:str, "\e[0m   ")))
-    out = "log_entry = \"  \e[#\{message_color}m#\{message}\e[0m   \""
-
-    util_compare inn, out
-  end
-
-  def test_class_comments
-    inn = s(:class, :Z, nil)
-    inn.comments = "# x\n# y\n"
-    out = "# x\n# y\nclass Z\nend"
-    util_compare inn, out
-  end
-
-  def test_module_comments
-    inn = s(:module, :Z)
-    inn.comments = "# x\n# y\n"
-    out = "# x\n# y\nmodule Z\nend"
-    util_compare inn, out
-  end
-
-  def test_method_comments
-    inn = s(:defn, :z, s(:args), s(:nil))
-    inn.comments = "# x\n# y\n"
-    out = "# x\n# y\ndef z\n  # do nothing\nend"
-    util_compare inn, out
-  end
-
-  def test_basic_ensure
-    inn = s(:ensure, s(:lit, 1), s(:lit, 2))
-    out = "begin\n  1\nensure\n  2\nend"
-    util_compare inn, out
-  end
-
-  def test_nested_ensure
-    inn = s(:ensure, s(:lit, 1), s(:ensure, s(:lit, 2), s(:lit, 3)))
-    out = "begin\n  1\nensure\n  begin\n    2\n  ensure\n    3\n  end\nend"
-    util_compare inn, out
-  end
-
-  def test_nested_rescue
-    inn = s(:ensure, s(:lit, 1), s(:rescue, s(:lit, 2), s(:resbody, s(:array), s(:lit, 3))))
-    out = "begin\n  1\nensure\n  2 rescue 3\nend"
-    util_compare inn, out
-  end
-
-  def test_nested_rescue_exception
-    inn = s(:ensure, s(:lit, 1), s(:rescue, s(:lit, 2), s(:resbody, s(:array, s(:const, :Exception)), s(:lit, 3))))
-    out = "begin\n  1\nensure\n  begin\n    2\n  rescue Exception\n    3\n  end\nend"
-    util_compare inn, out
-  end
-
-  def test_nested_rescue_exception2
-    inn = s(:ensure, s(:rescue, s(:lit, 2), s(:resbody, s(:array, s(:const, :Exception)), s(:lit, 3))), s(:lit, 1))
-    out = "begin\n  2\nrescue Exception\n  3\nensure\n  1\nend"
-    util_compare inn, out
-  end
-
-  def test_rescue_block
-    inn = s(:rescue,
-            s(:call, nil, :alpha),
-            s(:resbody, s(:array),
-              s(:call, nil, :beta),
-              s(:call, nil, :gamma)))
-    out = "begin\n  alpha\nrescue\n  beta\n  gamma\nend"
-    util_compare inn, out
-  end
-
-  def test_array_adds_parens_around_rescue
-    inn = s(:array,
-            s(:call, nil, :a),
-            s(:rescue, s(:call, nil, :b), s(:resbody, s(:array), s(:call, nil, :c))))
-    out = "[a, (b rescue c)]"
-
-    util_compare inn, out
-  end
-
-  def test_call_arglist_rescue
-    inn = s(:call,
-            nil,
-            :method,
-            s(:rescue,
-              s(:call, nil, :a),
-              s(:resbody, s(:array), s(:call, nil, :b))))
-    out = "method((a rescue b))"
-    util_compare inn, out
-  end
-
-  def test_unless_vs_if_not
-    rb1 = "a unless b"
-    rb2 = "a if (not b)"
-    rb3 = "a if ! b"
-
-    util_compare Ruby18Parser.new.parse(rb1), rb1
-    util_compare Ruby19Parser.new.parse(rb1), rb1
-
-    util_compare Ruby18Parser.new.parse(rb2), rb1
-    util_compare Ruby19Parser.new.parse(rb2), rb2
-
-    util_compare Ruby18Parser.new.parse(rb3), rb1
-    util_compare Ruby19Parser.new.parse(rb3), rb2
-  end
-end