ruby2ruby 1.2.4 → 1.2.5

data/.autotest

@@ -3,6 +3,9 @@
 require 'autotest/restart'
 
 Autotest.add_hook :initialize do |at|
+  at.order = :random
+  at.testlib = "minitest/autorun"
+
   at.extra_files << "../../ParseTree/dev/test/pt_testcase.rb"
   at.extra_files << "../../ParseTree/dev/lib/unified_ruby.rb"
   at.libs << ":../../sexp_processor/dev/lib:../../ParseTree/dev/lib:../../ParseTree/dev/test"

data/History.txt

@@ -1,3 +1,17 @@
+=== 1.2.5 / 2010-09-01
+
+* 4 minor enhancements:
+
+  * Added braces to hash args surrounded if in a binary method call.
+  * Added rewrite_resbody to double check structure and freak if necessary.
+  * Added stress task
+  * rewrite_rescue now detects rescue with multiple arguments.
+
+* 2 bug fixes:
+
+  * Fixed dstr/dregex/d* roundtripping problem
+  * Fixed up call arg processing to be more correct and to work with the new sexp form
+
 === 1.2.4 / 2009-08-14
 
 * 2 bug fixes:

data/Rakefile

@@ -20,4 +20,39 @@ Hoe.spec 'ruby2ruby' do
   extra_dev_deps << ["ParseTree",      "~> 3.0"]
 end
 
+task :stress do
+  $: << "lib"
+  $: << "../../ruby_parser/dev/lib"
+  require "ruby_parser"
+  require "ruby2ruby"
+  require "pp"
+
+  files = Dir["../../*/dev/**/*.rb"]
+
+  warn "Stress testing against #{files.size} files"
+  parser    = RubyParser.new
+  ruby2ruby = Ruby2Ruby.new
+
+  bad = {}
+
+  files.each do |file|
+    warn file
+    ruby = File.read(file)
+
+    begin
+      sexp = parser.process(ruby, file)
+
+      # $stderr.puts sexp.pretty_inspect
+
+      ruby2ruby.process(sexp)
+    rescue Interrupt => e
+      raise e
+    rescue Exception => e
+      bad[file] = e
+    end
+  end
+
+  pp bad
+end
+
 # vim: syntax=ruby

data/lib/ruby2ruby.rb

@@ -4,9 +4,11 @@ require 'rubygems'
 require 'sexp_processor'
 
 class Ruby2Ruby < SexpProcessor
-  VERSION = '1.2.4'
+  VERSION = '1.2.5'
   LINE_LENGTH = 78
 
+  BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**]
+
   ##
   # Nodes that represent assignment and probably need () around them.
 
@@ -31,6 +33,8 @@ class Ruby2Ruby < SexpProcessor
     self.strict = true
     self.expected = String
 
+    @calls = []
+
     # self.debug[:defn] = /zsuper/
   end
 
@@ -170,30 +174,43 @@ class Ruby2Ruby < SexpProcessor
       Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
 
     name = exp.shift
-    args = exp.shift rescue nil
+    args = []
+
+    # this allows us to do both old and new sexp forms:
+    exp.push(*exp.pop[1..-1]) if exp.size == 1 && exp.first.first == :arglist
+
+    @calls.push name
+
+    in_context :arglist do
+      until exp.empty? do
+        arg = process exp.shift
+        args << arg unless arg.empty?
+      end
+    end
 
     case name
-    when :<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :** then
-      "(#{receiver} #{name} #{process args})"
+    when *BINARY then
+      "(#{receiver} #{name} #{args.join(', ')})"
     when :[] then
-      receiver = "self" if receiver.nil?
-      "#{receiver}[#{process args}]"
+      receiver ||= "self"
+      "#{receiver}[#{args.join(', ')}]"
     when :[]= then
-      receiver = "self" if receiver.nil?
-      lhs = args.pop
-      "#{receiver}[#{process args}] = #{process lhs}"
+      receiver ||= "self"
+      rhs = args.pop
+      "#{receiver}[#{args.join(', ')}] = #{rhs}"
     when :"-@" then
       "-#{receiver}"
     when :"+@" then
       "+#{receiver}"
     else
-      args     = process args
-      args     = nil            if args.empty?
-      args     = "(#{args})"    if args
-      receiver = "#{receiver}." if receiver
+      args     = nil                    if args.empty?
+      args     = "(#{args.join(', ')})" if args
+      receiver = "#{receiver}."         if receiver
 
       "#{receiver}#{name}#{args}"
     end
+  ensure
+    @calls.pop
   end
 
   def process_case(exp)
@@ -284,7 +301,11 @@ class Ruby2Ruby < SexpProcessor
       name = exp.shift
       args = process(exp.shift)
       args = "" if args == "()"
-      body = indent(process(exp.shift))
+      body = []
+      until exp.empty? do
+        body << indent(process(exp.shift))
+      end
+      body = body.join("\n")
       return "def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
     else
       raise "Unknown defn type: #{type1} for #{exp.inspect}"
@@ -312,7 +333,7 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_dregx(exp)
-    "/" << util_dthing(exp, true) << "/"
+    "/" << util_dthing(:dregx, exp) << "/"
   end
 
   def process_dregx_once(exp)
@@ -320,15 +341,15 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_dstr(exp)
-    "\"#{util_dthing(exp)}\""
+    "\"#{util_dthing(:dstr, exp)}\""
   end
 
   def process_dsym(exp)
-    ":#{process_dstr(exp)}"
+    ":\"#{util_dthing(:dsym, exp)}\""
   end
 
   def process_dxstr(exp)
-    "`#{process_dstr(exp)[1..-2]}`"
+    "`#{util_dthing(:dxstr, exp)}`"
   end
 
   def process_ensure(exp)
@@ -393,7 +414,12 @@ class Ruby2Ruby < SexpProcessor
     case self.context[1]
     when :arglist, :argscat then
       unless result.empty? then
-        return "#{result.join(', ')}" # HACK - this will break w/ 2 hashes as args
+        # HACK - this will break w/ 2 hashes as args
+        if BINARY.include? @calls.last then
+          return "{ #{result.join(', ')} }"
+        else
+          return "#{result.join(', ')}"
+        end
       else
         return "{}"
       end
@@ -830,11 +856,18 @@ class Ruby2Ruby < SexpProcessor
     exp
   end
 
+  def rewrite_resbody exp
+    raise "no exception list in #{exp.inspect}" unless exp.size > 2 && exp[1]
+    raise exp[1].inspect if exp[1][0] != :array
+    # for now, do nothing, just check and freak if we see an errant structure
+    exp
+  end
+
   def rewrite_rescue exp
     complex = false
     complex ||= exp.size > 3
     complex ||= exp.block
-    complex ||= exp.find_nodes(:resbody).any? { |n| n.array != s(:array) }
+    complex ||= exp.find_nodes(:resbody).any? { |n| n[1] != s(:array) }
     complex ||= exp.find_nodes(:resbody).any? { |n| n.last.nil? }
 
     handled = context.first == :ensure
@@ -858,27 +891,40 @@ class Ruby2Ruby < SexpProcessor
   ############################################################
   # Utility Methods:
 
-  def util_dthing(exp, regx = false)
+  def dthing_escape type, lit
+    lit = lit.gsub(/\n/, '\n')
+    case type
+    when :dregx then
+      lit.gsub(/(\A|[^\\])\//, '\1\/')
+    when :dstr, :dsym then
+      lit.gsub(/"/, '\"')
+    when :dxstr then
+      lit.gsub(/`/, '\`')
+    else
+      raise "unsupported type #{type.inspect}"
+    end
+  end
+
+  def util_dthing(type, exp)
     s = []
-    suck = true
-    x = exp.shift.gsub(/"/, '\"').gsub(/\n/, '\n')
-    x.gsub!(/\//, '\/') if regx
 
-    s << x
+    # first item in sexp is a string literal
+    s << dthing_escape(type, exp.shift)
+
     until exp.empty?
       pt = exp.shift
       case pt
       when Sexp then
         case pt.first
         when :str then
-          x = pt.last.gsub(/"/, '\"').gsub(/\n/, '\n')
-          x.gsub!(/\//, '\/') if regx
-          s << x
-        else
+          s << dthing_escape(type, pt.last)
+        when :evstr then
           s << '#{' << process(pt) << '}' # do not use interpolation here
+        else
+          raise "unknown type: #{pt.inspect}"
         end
       else
-        # HACK: raise "huh?: #{pt.inspect}"
+        # HACK: raise "huh?: #{pt.inspect}" -- hitting # constants in regexps
         # do nothing for now
       end
     end

data/test/test_ruby2ruby.rb

@@ -40,22 +40,54 @@ class TestRuby2Ruby < R2RTestCase
     @processor = Ruby2Ruby.new
   end
 
+  def test_util_dthing_dregx
+    inn = util_thingy(:dregx)
+    inn.shift
+    out = '/a"b#{(1 + 1)}c"d\/e/'
+    exp = /a"b2c"d\/e/
+
+    assert_equal exp, eval(out)
+
+    assert_equal out[1..-2], @processor.util_dthing(:dregx, inn)
+  end
+
+  def test_util_dthing_dstr
+    inn = util_thingy(:dstr)
+    inn.shift
+    out = '"a\"b#{(1 + 1)}c\"d/e"'
+    exp = 'a"b2c"d/e'
+
+    assert_equal exp, eval(out)
+
+    assert_equal out[1..-2], @processor.util_dthing(:dstr, inn)
+  end
+
+  def test_util_dthing_dregx_bug?
+    inn = s(:dregx, '[\/\"]', s(:evstr, s(:lit, 42)))
+    inn.shift
+    out = '/[\/\"]#{42}/'
+    exp =  /[\/\"]42/
+
+    assert_equal out[1..-2], @processor.util_dthing(:dregx, inn)
+    assert_equal exp, eval(out)
+  end
+
   def test_dregx_slash
     inn = util_thingy(:dregx)
-    out = "/blah\\\"blah#\{(1 + 1)}blah\\\"blah\\/blah/"
-    util_compare inn, out, /blah\"blah2blah\"blah\/blah/
+    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 = "\"blah\\\"blah#\{(1 + 1)}blah\\\"blah/blah\""
-    util_compare inn, out, "blah\"blah2blah\"blah/blah"
+    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 = ":\"blah\\\"blah#\{(1 + 1)}blah\\\"blah/blah\""
-    util_compare inn, out, :"blah\"blah2blah\"blah/blah"
+    out = ':"a\"b#{(1 + 1)}c\"d/e"'
+    util_compare inn, out, :'a"b2c"d/e'
   end
 
   def test_lit_regexp_slash
@@ -119,6 +151,52 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_resbody_short_with_begin_end
+    # "begin; blah; rescue; []; end"
+    inn = s(:rescue,
+            s(:call, nil, :blah, s(:arglist)),
+            s(:resbody, s(:array), s(:array)))
+    out = "blah rescue []"
+    util_compare inn, out
+  end
+
+  def test_resbody_short_with_rescue_args
+    inn = s(:rescue,
+            s(:call, nil, :blah, s(:arglist)),
+            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(:arglist)),
+              :<<,
+              s(:arglist, s(:hash, s(:lit, :key), s(:lit, 24)))),
+            nil)
+
+    out = "(args << { :key => 24 }) if 42"
+
+    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(:arglist))),
+              s(:str, "m"),
+              s(:evstr, s(:call, nil, :message, s(:arglist))),
+              s(:str, "\e[0m   ")))
+    out = "log_entry = \"  \e[#\{message_color}m#\{message}\e[0m   \""
+
+    util_compare inn, out
+  end
+
   def util_compare sexp, expected_ruby, expected_eval = nil
     assert_equal expected_ruby, @processor.process(sexp)
     assert_equal expected_eval, eval(expected_ruby) if expected_eval
@@ -126,9 +204,9 @@ class TestRuby2Ruby < R2RTestCase
 
   def util_thingy(type)
     s(type,
-      'blah"blah',
-      s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))),
-      s(:str, 'blah"blah/blah'))
+      'a"b',
+      s(:evstr, s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1)))),
+      s(:str, 'c"d/e'))
   end
 end
 

metadata

@@ -1,57 +1,137 @@
 --- !ruby/object:Gem::Specification 
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  version: 1.2.4
+  hash: 21
+  prerelease: false
+  segments: 
+  - 1
+  - 2
+  - 5
+  version: 1.2.5
 platform: ruby
 authors: 
 - Ryan Davis
 autorequire: 
 bindir: bin
-cert_chain: []
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRMwEQYDVQQDDApyeWFu
+  ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
+  GRYDY29tMB4XDTA5MDMwNjE4NTMxNVoXDTEwMDMwNjE4NTMxNVowRTETMBEGA1UE
+  AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
+  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
+  b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
+  taCPaLmfYIaFcHHCSY4hYDJijRQkLxPeB3xbOfzfLoBDbjvx5JxgJxUjmGa7xhcT
+  oOvjtt5P8+GSK9zLzxQP0gVLS/D0FmoE44XuDr3iQkVS2ujU5zZL84mMNqNB1znh
+  GiadM9GHRaDiaxuX0cIUBj19T01mVE2iymf9I6bEsiayK/n6QujtyCbTWsAS9Rqt
+  qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
+  gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBBQUAA4IB
+  AQAY59gYvDxqSqgC92nAP9P8dnGgfZgLxP237xS6XxFGJSghdz/nI6pusfCWKM8m
+  vzjjH2wUMSSf3tNudQ3rCGLf2epkcU13/rguI88wO6MrE0wi4ZqLQX+eZQFskJb/
+  w6x9W1ur8eR01s397LSMexySDBrJOh34cm2AlfKr/jokKCTwcM0OvVZnAutaovC0
+  l1SVZ0ecg88bsWHA0Yhh7NFxK1utWoIhtB6AFC/+trM0FQEB/jZkIS8SaNzn96Rl
+  n0sZEf77FLf5peR8TP/PtmIg7Cyqz23sLM4mCOoTGIy5OcZ8TdyiyINUHtb5ej/T
+  FBHgymkyj/AOSqKRIpXPhjC6
+  -----END CERTIFICATE-----
 
-date: 2009-08-14 00:00:00 -07:00
+date: 2010-09-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sexp_processor
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
         version: "3.0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: ruby_parser
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
         version: "2.0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: ParseTree
+  name: rubyforge
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 7
+        - 1
+        version: 1.7.1
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
         version: "3.0"
-    version: 
+  type: :development
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.3.3
-    version: 
+        hash: 19
+        segments: 
+        - 2
+        - 6
+        - 2
+        version: 2.6.2
+  type: :development
+  version_requirements: *id006
 description: |-
   ruby2ruby provides a means of generating pure ruby code easily from
   RubyParser compatible Sexps. This makes making dynamic language
@@ -86,21 +166,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: seattlerb
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: ruby2ruby provides a means of generating pure ruby code easily from RubyParser compatible Sexps