sexp2ruby 0.0.1 → 0.0.2

data/lib/sexp2ruby/version.rb

@@ -1,3 +1,3 @@
 module Sexp2Ruby
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/sexp2ruby.rb

@@ -1,4 +1,91 @@
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/module/delegation"
+require "core_extensions/regexp"
 require "sexp2ruby/version"
 require "sexp2ruby/errors"
-require "sexp2ruby/core_extensions/regexp"
 require "sexp2ruby/processor"
+require "sexp2ruby/node/base"
+require "sexp2ruby/node/alias"
+require "sexp2ruby/node/and"
+require "sexp2ruby/node/arglist"
+require "sexp2ruby/node/args"
+require "sexp2ruby/node/array"
+require "sexp2ruby/node/attrasgn"
+require "sexp2ruby/node/back_ref"
+require "sexp2ruby/node/begin"
+require "sexp2ruby/node/block"
+require "sexp2ruby/node/block_pass"
+require "sexp2ruby/node/break"
+require "sexp2ruby/node/call"
+require "sexp2ruby/node/case"
+require "sexp2ruby/node/cdecl"
+require "sexp2ruby/node/class"
+require "sexp2ruby/node/colon2"
+require "sexp2ruby/node/colon3"
+require "sexp2ruby/node/const"
+require "sexp2ruby/node/cvar"
+require "sexp2ruby/node/cvasgn"
+require "sexp2ruby/node/cvdecl"
+require "sexp2ruby/node/defined"
+require "sexp2ruby/node/defn"
+require "sexp2ruby/node/defs"
+require "sexp2ruby/node/dot2"
+require "sexp2ruby/node/dot3"
+require "sexp2ruby/node/dregx"
+require "sexp2ruby/node/dregx_once"
+require "sexp2ruby/node/dstr"
+require "sexp2ruby/node/dsym"
+require "sexp2ruby/node/dxstr"
+require "sexp2ruby/node/ensure"
+require "sexp2ruby/node/evstr"
+require "sexp2ruby/node/false"
+require "sexp2ruby/node/flip2"
+require "sexp2ruby/node/flip3"
+require "sexp2ruby/node/for"
+require "sexp2ruby/node/gasgn"
+require "sexp2ruby/node/gvar"
+require "sexp2ruby/node/hash"
+require "sexp2ruby/node/iasgn"
+require "sexp2ruby/node/if"
+require "sexp2ruby/node/iter"
+require "sexp2ruby/node/ivar"
+require "sexp2ruby/node/kwsplat"
+require "sexp2ruby/node/lasgn"
+require "sexp2ruby/node/lit"
+require "sexp2ruby/node/lvar"
+require "sexp2ruby/node/masgn"
+require "sexp2ruby/node/match"
+require "sexp2ruby/node/match2"
+require "sexp2ruby/node/match3"
+require "sexp2ruby/node/module"
+require "sexp2ruby/node/next"
+require "sexp2ruby/node/nil"
+require "sexp2ruby/node/not"
+require "sexp2ruby/node/nth_ref"
+require "sexp2ruby/node/op_asgn1"
+require "sexp2ruby/node/op_asgn2"
+require "sexp2ruby/node/op_asgn_and"
+require "sexp2ruby/node/op_asgn_or"
+require "sexp2ruby/node/or"
+require "sexp2ruby/node/postexe"
+require "sexp2ruby/node/redo"
+require "sexp2ruby/node/resbody"
+require "sexp2ruby/node/rescue"
+require "sexp2ruby/node/retry"
+require "sexp2ruby/node/return"
+require "sexp2ruby/node/sclass"
+require "sexp2ruby/node/self"
+require "sexp2ruby/node/splat"
+require "sexp2ruby/node/str"
+require "sexp2ruby/node/super"
+require "sexp2ruby/node/svalue"
+require "sexp2ruby/node/to_ary"
+require "sexp2ruby/node/true"
+require "sexp2ruby/node/undef"
+require "sexp2ruby/node/until"
+require "sexp2ruby/node/valias"
+require "sexp2ruby/node/when"
+require "sexp2ruby/node/while"
+require "sexp2ruby/node/xstr"
+require "sexp2ruby/node/yield"
+require "sexp2ruby/node/zsuper"

data/sexp2ruby.gemspec

@@ -23,6 +23,7 @@ It is a fork of ruby2ruby with slightly different goals.
 
   spec.required_ruby_version = ">= 1.9.3"
 
+  spec.add_runtime_dependency "activesupport", "~> 4.2"
   spec.add_runtime_dependency "sexp_processor", "~> 4.6"
 
   spec.add_development_dependency "rspec-core", "~> 3.2"

data/spec/lib/processor_spec.rb

@@ -113,13 +113,483 @@ module Sexp2Ruby
           end
 
           it "wraps method call with block (iter) in parens" do
-            iter = s(:iter, s(:call, nil, :foo), s(:args), s(:str, "bar"))
+            iter = s(:iter, s(:call, nil, :foo), 0, s(:str, "bar"))
             inp = s(:hash, s(:lit, :k), iter)
             out = '{ :k => (foo { "bar" }) }'
             compare(inp, out, processor, false)
           end
         end
       end
+
+      it "and_alias" do
+        inn = s(:and, s(:true), s(:alias, s(:lit, :a), s(:lit, :b)))
+        out = "true and (alias :a :b)"
+        compare(inn, out, processor)
+      end
+
+      it "attr_reader_diff" do
+        inn = s(:defn, :same, s(:args), s(:ivar, :@diff))
+        out = "def same\n  @diff\nend"
+        compare(inn, out, processor)
+      end
+
+      it "attr_reader_same" do
+        inn = s(:defn, :same, s(:args), s(:ivar, :@same))
+        out = "attr_reader :same"
+        compare(inn, out, processor, false)
+      end
+
+      it "attr_reader_double" do
+        inn = s(:defn, :same, s(:args), s(:ivar, :@same), s(:ivar, :@diff))
+        out = "def same\n  @same\n  @diff\nend"
+        compare(inn, out, processor)
+      end
+
+      it "attr_reader_same_name_diff_body" do
+        inn = s(:defn, :same, s(:args), s(:not, s(:ivar, :@same)))
+        out = "def same\n  (not @same)\nend"
+        compare(inn, out, processor, false)
+      end
+
+      it "attr_writer_diff" do
+        inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@diff, s(:lvar, :o)))
+        out = "def same=(o)\n  @diff = o\nend"
+        compare(inn, out, processor)
+      end
+
+      it "attr_writer_double" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "attr_writer_same_name_diff_body" do
+        inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@same, s(:lit, 42)))
+        out = "def same=(o)\n  @same = 42\nend"
+        compare(inn, out, processor)
+      end
+
+      it "attr_writer_same" do
+        inn = s(:defn, :same=, s(:args, :o), s(:iasgn, :@same , s(:lvar, :o)))
+        out = "attr_writer :same"
+        compare(inn, out, processor, false)
+      end
+
+      it "dregx_slash" do
+        inn = util_thingy(:dregx)
+        out = '/a"b#{(1 + 1)}c"d\/e/'
+        compare(inn, out, processor, false, /a"b2c"d\/e/)
+      end
+
+      it "dstr_quote" do
+        inn = util_thingy(:dstr)
+        out = '"a\"b#{(1 + 1)}c\"d/e"'
+        compare(inn, out, processor, true, 'a"b2c"d/e')
+      end
+
+      it "dsym_quote" do
+        inn = util_thingy(:dsym)
+        out = ':"a\"b#{(1 + 1)}c\"d/e"'
+        compare(inn, out, processor, true, :'a"b2c"d/e')
+      end
+
+      it "lit_regexp_slash" do
+        inp = s(:lit, /blah\/blah/)
+        compare(inp, '/blah\/blah/', processor, false, /blah\/blah/)
+      end
+
+      it "call_kwsplat" do
+        inn = s(:call, nil, :test_splat, s(:hash, s(:kwsplat, s(:call, nil, :testing))))
+        out = "test_splat(**testing)"
+        compare(inn, out, processor)
+      end
+
+      it "call_arg_assoc_kwsplat" do
+        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)"
+
+        compare(inn, out, processor)
+      end
+
+      it "call_kwsplat_x" do
+        inn = s(:call, nil, :a, s(:hash, s(:kwsplat, s(:lit, 1))))
+        out = "a(**1)"
+
+        compare(inn, out, processor)
+      end
+
+      it "defn_kwargs" do
+        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"
+
+        compare(inn, out, processor)
+      end
+
+      it "defn_kwargs2" do
+        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"
+
+        compare(inn, out, processor)
+      end
+
+      it "call_self_index" do
+        compare(s(:call, nil, :[], s(:lit, 42)), "self[42]", processor)
+      end
+
+      it "call_self_index_equals" do
+        inp = s(:attrasgn, s(:self), :[]=, s(:lit, 42), s(:lit, 24))
+        compare(inp, "self[42] = 24", processor)
+      end
+
+      it "call_self_index_equals_array" do
+        inp = s(:attrasgn, s(:self), :[]=, s(:lit, 1), s(:lit, 2), s(:lit, 3))
+        compare(inp, "self[1, 2] = 3", processor)
+      end
+
+      it "call_arglist_hash_first" do
+        inn = s(:call, nil, :method,
+          s(:hash, s(:lit, :a), s(:lit, 1)),
+          s(:call, nil, :b))
+        out = "method({ :a => 1 }, b)"
+
+        compare(inn, out, processor)
+      end
+
+      it "call_arglist_hash_first_last" do
+        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)"
+
+        compare(inn, out, processor)
+      end
+
+      it "call_arglist_hash_last" do
+        inn = s(:call, nil, :method,
+          s(:call, nil, :b),
+          s(:hash, s(:lit, :a), s(:lit, 1)))
+        out = "method(b, :a => 1)"
+
+        compare(inn, out, processor)
+      end
+
+      it "call_arglist_if" do
+        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)))"
+        compare(inn, out, processor)
+      end
+
+      it "defn_kwsplat" do
+        inn = s(:defn, :test, s(:args, :"**testing"), s(:nil))
+        out = "def test(**testing)\n  # do nothing\nend"
+        compare(inn, out, processor)
+      end
+
+      it "defn_rescue_return" do
+        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"
+
+        compare(inn, out, processor)
+      end
+
+      it "masgn_block_arg" do
+        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}" }'
+
+        compare(inn, out, processor)
+      end
+
+      it "masgn_wtf" do
+        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"
+
+        compare(inn, out, processor)
+      end
+
+      it "masgn_splat_wtf" do
+        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)'
+        compare(inn, out, processor)
+      end
+
+      it "match3_asgn" do
+        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).
+        compare(inn, out, processor)
+      end
+
+      it "splat_call" do
+        inn = s(:call, nil, :x,
+          s(:splat,
+            s(:call,
+              s(:call, nil, :line),
+              :split,
+              s(:lit, /\=/), s(:lit, 2))))
+
+        out = 'x(*line.split(/\=/, 2))'
+        compare(inn, out, processor)
+      end
+
+      it "resbody_block" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "resbody_short_with_begin_end" do
+        # "begin; blah; rescue; []; end"
+        inn = s(:rescue,
+          s(:call, nil, :blah),
+          s(:resbody, s(:array), s(:array)))
+        out = "blah rescue []"
+        compare(inn, out, processor)
+      end
+
+      it "resbody_short_with_begin_end_multiple" do
+        # "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"
+        compare(inn, out, processor)
+      end
+
+      it "resbody_short_with_defn_multiple" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "regexp_options" do
+        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'
+        compare(inn, out, processor)
+      end
+
+      it "resbody_short_with_rescue_args" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "call_binary_call_with_hash_arg" do
+        # 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"
+
+        compare(inn, out, processor)
+      end
+
+      it "binary_operators" do
+        # (1 > 2)
+        Node::Call::BINARY.each do |op|
+          inn = s(:call, s(:lit, 1), op, s(:lit, 2))
+          out = "(1 #{op} 2)"
+          compare(inn, out, processor)
+        end
+      end
+
+      it "call_empty_hash" do
+        inn = s(:call, nil, :foo, s(:hash))
+        out = "foo({})"
+        compare(inn, out, processor)
+      end
+
+      it "if_empty" do
+        inn = s(:if, s(:call, nil, :x), nil, nil)
+        out = "if x then\n  # do nothing\nend"
+        compare(inn, out, processor)
+      end
+
+      it "interpolation_and_escapes" do
+        # 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   \""
+
+        compare(inn, out, processor)
+      end
+
+      it "class_comments" do
+        inn = s(:class, :Z, nil)
+        inn.comments = "# x\n# y\n"
+        out = "# x\n# y\nclass Z\nend"
+        compare(inn, out, processor)
+      end
+
+      it "module_comments" do
+        inn = s(:module, :Z)
+        inn.comments = "# x\n# y\n"
+        out = "# x\n# y\nmodule Z\nend"
+        compare(inn, out, processor)
+      end
+
+      it "method_comments" do
+        inn = s(:defn, :z, s(:args), s(:nil))
+        inn.comments = "# x\n# y\n"
+        out = "# x\n# y\ndef z\n  # do nothing\nend"
+        compare(inn, out, processor)
+      end
+
+      it "basic_ensure" do
+        inn = s(:ensure, s(:lit, 1), s(:lit, 2))
+        out = "begin\n  1\nensure\n  2\nend"
+        compare(inn, out, processor)
+      end
+
+      it "nested_ensure" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "nested_rescue" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "nested_rescue_exception" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "nested_rescue_exception2" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "rescue_block" do
+        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"
+        compare(inn, out, processor)
+      end
+
+      it "array_adds_parens_around_rescue" do
+        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)]"
+
+        compare(inn, out, processor)
+      end
+
+      it "call_arglist_rescue" do
+        inn = s(:call,
+          nil,
+          :method,
+          s(:rescue,
+            s(:call, nil, :a),
+            s(:resbody, s(:array), s(:call, nil, :b))))
+        out = "method((a rescue b))"
+        compare(inn, out, processor)
+      end
+
+      it "unless_vs_if_not" do
+        rb1 = "a unless b"
+        rb2 = "a if (not b)"
+        rb3 = "a if ! b"
+
+        compare(Ruby18Parser.new.parse(rb1), rb1, processor)
+        compare(Ruby19Parser.new.parse(rb1), rb1, processor)
+
+        compare(Ruby18Parser.new.parse(rb2), rb1, processor)
+        compare(Ruby19Parser.new.parse(rb2), rb2, processor)
+
+        compare(Ruby18Parser.new.parse(rb3), rb1, processor)
+        compare(Ruby19Parser.new.parse(rb3), rb2, processor)
+      end
     end
 
     describe "#ruby19_hash_key?" do
@@ -179,5 +649,12 @@ module Sexp2Ruby
         expect(eval(expected_ruby)).to eq(expected_eval)
       end
     end
+
+    def util_thingy(type)
+      s(type,
+        'a"b',
+        s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
+        s(:str, 'c"d/e'))
+    end
   end
 end