ruby2ruby 1.3.1 → 2.0.0.b1

data/History.txt

@@ -1,3 +1,26 @@
+=== 2.0.0.b1 / 2012-07-27
+
+* 4 major enhancements:
+
+  * Made it work without arglist in call.
+  * Made it work without scope/block in class/module/defn/defs.
+  * Removed block from resbody
+  * Removed block from when node
+
+* 4 minor enhancements:
+
+  * Added debug task to help isolate an error
+  * Empty hash is now a proper {}
+  * Refactored and added finish method.
+  * Switched to new Ruby18Parser to avoid deprecation warnings
+
+* 4 bug fixes:
+
+  * Fixed call with empty hash arg. (neilconway)
+  * OMG WTF... removed long decrepit ParseTree dependency
+  * Removed isolate/rake require to reduce minimum bootstrap to hoe + rake + rake install_plugins (*2)
+  * Skip 1.9 tests for now.
+
 === 1.3.1 / 2011-09-22
 
 * 1 minor enhancement:

data/README.txt

@@ -48,6 +48,18 @@ processors in ruby easier than ever!
 
 + sudo gem install ruby2ruby
 
+== How to Contribute:
+
+To get started all you need is a checkout, rake, and hoe. The easiest
+way is:
+
+    % git clone seattlerb/ruby2ruby # assumes you use the `hub` wrapper.
+    % gem i rake hoe
+    % rake install_plugins # installs hoe-seattlerb & isolate
+    % rake install_plugins # installs minitest (referenced from hoe-seattlerb)
+
+From here you should be good to go. We accept pull requests on github.
+
 == LICENSE:
 
 (The MIT License)

data/Rakefile

@@ -2,7 +2,6 @@
 
 require 'rubygems'
 require 'hoe'
-require 'isolate/rake'
 
 Hoe.add_include_dirs("lib",
                      "../../ruby_parser/dev/lib",
@@ -16,36 +15,42 @@ Hoe.spec 'ruby2ruby' do
 
   self.rubyforge_name = 'seattlerb'
 
-  dependency "sexp_processor", "~> 3.0"
-  dependency "ruby_parser",    "~> 2.0"
-  dependency "ParseTree",      "~> 3.0", :developer
+  dependency "sexp_processor", "~> 4.0"
+  dependency "ruby_parser",    "~> 3.0.0.a4"
+end
+
+def process ruby, file="stdin"
+  require "ruby_parser"
+  require "ruby2ruby"
+
+  parser    = RubyParser.new
+  ruby2ruby = Ruby2Ruby.new
+
+  begin
+    sexp = parser.process(ruby, file)
+
+    ruby2ruby.process(sexp)
+  rescue Interrupt => e
+    raise e
+  end
 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)
+      process File.read(file), file
     rescue Interrupt => e
       raise e
     rescue Exception => e
@@ -56,4 +61,28 @@ task :stress do
   pp bad
 end
 
+task :debug => :isolate do
+  ENV["V"] ||= "18"
+
+  $: << "lib"
+  require 'ruby_parser'
+
+  parser = if ENV["V"] == "18" then
+             Ruby18Parser.new
+           else
+             Ruby19Parser.new
+           end
+
+  file = ENV["F"] || ENV["FILE"]
+
+  ruby = if file then
+           File.read(file)
+         else
+           file = "env"
+           ENV["R"] || ENV["RUBY"]
+         end
+
+  puts process(ruby, file)
+end
+
 # vim: syntax=ruby

data/bin/r2r_show

@@ -18,7 +18,7 @@ end
 
 ARGV.push "-" if ARGV.empty?
 
-parser    = RubyParser.new
+parser    = Ruby18Parser.new
 ruby2ruby = Ruby2Ruby.new
 
 ARGV.each do |file|

data/lib/ruby2ruby.rb

@@ -24,7 +24,7 @@ class Regexp
 end
 
 class Ruby2Ruby < SexpProcessor
-  VERSION = '1.3.1'
+  VERSION = '2.0.0.b1'
   LINE_LENGTH = 78
 
   BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**]
@@ -121,8 +121,8 @@ class Ruby2Ruby < SexpProcessor
 
     case name
     when :[]= then
-      rhs = process args.pop
-      "#{receiver}[#{process(args)}] = #{rhs}"
+      rhs = exp.empty? ? nil : exp.shift
+      "#{receiver}[#{process args}] = #{process rhs}"
     else
       name = name.to_s.sub(/=$/, '')
       if args && args != s(:arglist) then
@@ -169,7 +169,7 @@ class Ruby2Ruby < SexpProcessor
 
   def parenthesize exp
     case self.context[1]
-    when nil, :scope, :if, :iter, :resbody, :when, :while then
+    when nil, :defn, :defs, :class, :sclass, :if, :iter, :resbody, :when, :while then
       exp
     else
       "(#{exp})"
@@ -208,12 +208,14 @@ class Ruby2Ruby < SexpProcessor
     in_context :arglist do
       until exp.empty? do
         arg_type = exp.first.sexp_type
+        is_empty_hash = (exp.first == s(:hash))
         arg = process exp.shift
 
         next if arg.empty?
 
         strip_hash = (arg_type == :hash and
                       not BINARY.include? name and
+                      not is_empty_hash and
                       (exp.empty? or exp.first.sexp_type == :splat))
         wrap_arg = Ruby2Ruby::ASSIGN_NODES.include? arg_type
 
@@ -332,20 +334,23 @@ class Ruby2Ruby < SexpProcessor
       end
     end
 
-    case type1
-    when :scope, :args then
-      name = exp.shift
-      args = process(exp.shift)
-      args = "" if args == "()"
-      body = []
-      until exp.empty? do
-        body << indent(process(exp.shift))
-      end
-      body = body.join("\n")
-      return "#{exp.comments}def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
-    else
-      raise "Unknown defn type: #{type1} for #{exp.inspect}"
+    comm = exp.comments
+    name = exp.shift
+    args = process(exp.shift)
+    args = "" if args == "()"
+
+    exp.shift if exp == s(s(:nil)) # empty it out of a default nil expression
+
+    body = []
+    until exp.empty? do
+      body << indent(process(exp.shift))
     end
+
+    body << indent("# do nothing") if body.empty?
+
+    body = body.join("\n")
+
+    return "#{comm}def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, "\n")
   end
 
   def process_defs(exp)
@@ -457,7 +462,7 @@ class Ruby2Ruby < SexpProcessor
       result << "#{lhs} => #{rhs}"
     end
 
-    return "{ #{result.join(', ')} }"
+    return result.empty? ? "{}" : "{ #{result.join(', ')} }"
   end
 
   def process_iasgn(exp)
@@ -706,7 +711,8 @@ class Ruby2Ruby < SexpProcessor
 
   def process_resbody exp
     args = exp.shift
-    body = process(exp.shift) || "# do nothing"
+    body = finish(exp)
+    body << "# do nothing" if body.empty?
 
     name =   args.lasgn true
     name ||= args.iasgn true
@@ -714,7 +720,7 @@ class Ruby2Ruby < SexpProcessor
     args = " #{args}" unless args.empty?
     args += " => #{name[1]}" if name
 
-    "rescue#{args}\n#{indent body}"
+    "rescue#{args}\n#{indent body.join("\n")}"
   end
 
   def process_rescue exp
@@ -761,10 +767,6 @@ class Ruby2Ruby < SexpProcessor
     "class << #{process(exp.shift)}\n#{indent(process(exp.shift))}\nend"
   end
 
-  def process_scope(exp)
-    exp.empty? ? "" : process(exp.shift)
-  end
-
   def process_self(exp)
     "self"
   end
@@ -782,10 +784,7 @@ class Ruby2Ruby < SexpProcessor
   end
 
   def process_super(exp)
-    args = []
-    until exp.empty? do
-      args << process(exp.shift)
-    end
+    args = finish exp
 
     "super(#{args.join(', ')})"
   end
@@ -829,7 +828,7 @@ class Ruby2Ruby < SexpProcessor
 
     until exp.empty?
       cond = process(exp.shift).to_s[1..-2]
-      code = indent(process(exp.shift))
+      code = indent(finish(exp).join("\n"))
       code = indent "# do nothing" if code =~ /\A\s*\Z/
       src << "when #{cond} then\n#{code.chomp}"
     end
@@ -935,6 +934,14 @@ class Ruby2Ruby < SexpProcessor
   ############################################################
   # Utility Methods:
 
+  def finish exp # REFACTOR: work this out of the rest of the processors
+    body = []
+    until exp.empty? do
+      body << process(exp.shift)
+    end
+    body.compact
+  end
+
   def dthing_escape type, lit
     lit = lit.gsub(/\n/, '\n')
     case type
@@ -992,7 +999,7 @@ class Ruby2Ruby < SexpProcessor
 
     body = []
     begin
-      code = process(exp.shift)
+      code = process(exp.shift) unless exp.empty?
       body << code.chomp unless code.nil? or code.chomp.empty?
     end until exp.empty?
 

data/test/test_ruby2ruby.rb

@@ -18,6 +18,8 @@ class R2RTestCase < ParseTreeTestCase
   def self.generate_test klass, node, data, input_name, output_name
     output_name = data.has_key?('Ruby2Ruby') ? 'Ruby2Ruby' : 'Ruby'
 
+    return if node.to_s =~ /19$/
+
     klass.class_eval <<-EOM
       def test_#{node}
         pt = #{data[input_name].inspect}
@@ -101,19 +103,18 @@ class TestRuby2Ruby < R2RTestCase
   end
 
   def test_call_self_index
-    util_compare s(:call, nil, :[], s(:arglist, s(:lit, 42))), "self[42]"
+    util_compare s(:call, nil, :[], s(:lit, 42)), "self[42]"
   end
 
   def test_call_self_index_equals
-    util_compare(s(:call, nil, :[]=, s(:arglist, s(:lit, 42), s(:lit, 24))),
+    util_compare(s(:call, nil, :[]=, s(:lit, 42), s(:lit, 24)),
                  "self[42] = 24")
   end
 
   def test_call_arglist_hash_first
     inn = s(:call, nil, :method,
-            s(:arglist,
-              s(:hash, s(:lit, :a), s(:lit, 1)),
-              s(:call, nil, :b, s(:arglist))))
+            s(:hash, s(:lit, :a), s(:lit, 1)),
+            s(:call, nil, :b))
     out = "method({ :a => 1 }, b)"
 
     util_compare inn, out
@@ -121,10 +122,9 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_call_arglist_hash_first_last
     inn = s(:call, nil, :method,
-            s(:arglist,
-              s(:hash, s(:lit, :a), s(:lit, 1)),
-              s(:call, nil, :b, s(:arglist)),
-              s(:hash, s(:lit, :c), s(:lit, 1))))
+            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
@@ -132,9 +132,8 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_call_arglist_hash_last
     inn = s(:call, nil, :method,
-            s(:arglist,
-              s(:call, nil, :b, s(:arglist)),
-              s(:hash, s(:lit, :a), s(:lit, 1))))
+            s(:call, nil, :b),
+            s(:hash, s(:lit, :a), s(:lit, 1)))
     out = "method(b, :a => 1)"
 
     util_compare inn, out
@@ -142,13 +141,12 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_call_arglist_if
     inn = s(:call,
-            s(:call, nil, :a, s(:arglist)),
+            s(:call, nil, :a),
             :+,
-            s(:arglist,
-              s(:if,
-                s(:call, nil, :b, s(:arglist)),
-                s(:call, nil, :c, s(:arglist)),
-                s(:call, nil, :d, s(:arglist)))))
+            s(:if,
+              s(:call, nil, :b),
+              s(:call, nil, :c),
+              s(:call, nil, :d)))
 
     out = "(a + (b ? (c) : (d)))"
     util_compare inn, out
@@ -161,14 +159,14 @@ class TestRuby2Ruby < R2RTestCase
               s(:array,
                 s(:splat,
                   s(:call,
-                    s(:call, nil, :line, s(:arglist)),
+                    s(:call, nil, :line),
                     :split,
-                    s(:arglist, s(:lit, /\=/), s(:lit, 2)))))),
+                    s(:lit, /\=/), s(:lit, 2))))),
             s(:attrasgn,
               s(:self),
               :[]=,
-              s(:arglist, s(:lvar, :k),
-                s(:call, s(:lvar, :v), :strip, s(:arglist)))))
+              s(:arglist, s(:lvar, :k)),
+              s(:call, s(:lvar, :v), :strip)))
 
     out = "k, v = *line.split(/\\=/, 2)\nself[k] = v.strip\n"
 
@@ -181,15 +179,15 @@ class TestRuby2Ruby < R2RTestCase
             s(:array,
               s(:splat,
                 s(:call,
-                  s(:call, nil, :line, s(:arglist)),
+                  s(:call, nil, :line),
                   :split,
-                  s(:arglist, s(:lit, /\=/), s(:lit, 2))))))
+                  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, s(:arglist))))
+    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
@@ -197,12 +195,11 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_splat_call
     inn = s(:call, nil, :x,
-            s(:arglist,
-              s(:splat,
-                s(:call,
-                  s(:call, nil, :line, s(:arglist)),
-                  :split,
-                  s(:arglist, s(:lit, /\=/), s(:lit, 2))))))
+            s(:splat,
+              s(:call,
+                s(:call, nil, :line),
+                :split,
+                s(:lit, /\=/), s(:lit, 2))))
 
     out = 'x(*line.split(/\=/, 2))'
     util_compare inn, out
@@ -210,12 +207,12 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_resbody_block
     inn = s(:rescue,
-            s(:call, nil, :x1, s(:arglist)),
+            s(:call, nil, :x1),
             s(:resbody,
               s(:array),
               s(:block,
-                s(:call, nil, :x2, s(:arglist)),
-                s(:call, nil, :x3, s(:arglist)))))
+                s(:call, nil, :x2),
+                s(:call, nil, :x3))))
 
     out = "begin\n  x1\nrescue\n  x2\n  x3\nend"
     util_compare inn, out
@@ -224,7 +221,7 @@ class TestRuby2Ruby < R2RTestCase
   def test_resbody_short_with_begin_end
     # "begin; blah; rescue; []; end"
     inn = s(:rescue,
-            s(:call, nil, :blah, s(:arglist)),
+            s(:call, nil, :blah),
             s(:resbody, s(:array), s(:array)))
     out = "blah rescue []"
     util_compare inn, out
@@ -234,7 +231,7 @@ class TestRuby2Ruby < R2RTestCase
     inn = s(:match3,
             s(:dregx,
               "abc",
-              s(:evstr, s(:call, nil, :x, s(:arglist))),
+              s(:evstr, s(:call, nil, :x)),
               s(:str, "def"),
               4),
             s(:str, "a"))
@@ -244,7 +241,7 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_resbody_short_with_rescue_args
     inn = s(:rescue,
-            s(:call, nil, :blah, s(:arglist)),
+            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
@@ -256,9 +253,9 @@ class TestRuby2Ruby < R2RTestCase
     # end
 
     inn = s(:if, s(:lit, 42),
-            s(:call, s(:call, nil, :args, s(:arglist)),
+            s(:call, s(:call, nil, :args),
               :<<,
-              s(:arglist, s(:hash, s(:lit, :key), s(:lit, 24)))),
+              s(:hash, s(:lit, :key), s(:lit, 24))),
             nil)
 
     out = "(args << { :key => 24 }) if 42"
@@ -266,8 +263,14 @@ class TestRuby2Ruby < R2RTestCase
     util_compare inn, out
   end
 
+  def test_call_empty_hash
+    inn = s(:call, nil, :foo, s(:arglist, s(:hash)))
+    out = "foo({})"
+    util_compare inn, out
+  end
+
   def test_if_empty
-    inn = s(:if, s(:call, nil, :x, s(:arglist)), nil, nil)
+    inn = s(:if, s(:call, nil, :x), nil, nil)
     out = "if x then\n  # do nothing\nend"
     util_compare inn, out
   end
@@ -276,9 +279,9 @@ class TestRuby2Ruby < R2RTestCase
     # 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(:evstr, s(:call, nil, :message_color)),
               s(:str, "m"),
-              s(:evstr, s(:call, nil, :message, s(:arglist))),
+              s(:evstr, s(:call, nil, :message)),
               s(:str, "\e[0m   ")))
     out = "log_entry = \"  \e[#\{message_color}m#\{message}\e[0m   \""
 
@@ -286,21 +289,21 @@ class TestRuby2Ruby < R2RTestCase
   end
 
   def test_class_comments
-    inn = s(:class, :Z, nil, s(:scope))
+    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, s(:scope))
+    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(:scope, s(:block, s(:nil))))
+    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
@@ -311,19 +314,19 @@ class TestRuby2Ruby < R2RTestCase
     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"
@@ -338,15 +341,15 @@ class TestRuby2Ruby < R2RTestCase
 
   def test_rescue_block
     inn = s(:rescue,
-            s(:call, nil, :alpha, s(:arglist)),
-            s(:resbody, s(:array), 
+            s(:call, nil, :alpha),
+            s(:resbody, s(:array),
               s(:block,
-                s(:call, nil, :beta, s(:arglist)),
-                s(:call, nil, :gamma, s(:arglist)))))
+                s(:call, nil, :beta),
+                s(:call, nil, :gamma))))
     out = "begin\n  alpha\nrescue\n  beta\n  gamma\nend"
     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
@@ -355,7 +358,7 @@ class TestRuby2Ruby < R2RTestCase
   def util_thingy(type)
     s(type,
       'a"b',
-      s(:evstr, s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1)))),
+      s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
       s(:str, 'c"d/e'))
   end
 end
@@ -381,7 +384,8 @@ def silent_eval ruby
 end
 
 def morph_and_eval src, from, to, processor
-  new_src = processor.new.process(RubyParser.new.process(src.sub(from, to)))
+  new_src = processor.new.process(Ruby18Parser.new.process(src.sub(from, to)))
+
   silent_eval new_src
   new_src
 end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: ruby2ruby
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
+  hash: -533234434
+  prerelease: 6
   segments: 
+  - 2
+  - 0
+  - 0
+  - b
   - 1
-  - 3
-  - 1
-  version: 1.3.1
+  version: 2.0.0.b1
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +38,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2011-09-22 00:00:00 Z
+date: 2012-07-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sexp_processor
@@ -46,11 +48,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 27
         segments: 
-        - 3
+        - 4
         - 0
-        version: "3.0"
+        version: "4.0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -61,11 +63,14 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: -533251372
         segments: 
-        - 2
+        - 3
+        - 0
         - 0
-        version: "2.0"
+        - a
+        - 4
+        version: 3.0.0.a4
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -76,26 +81,26 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 3
         segments: 
+        - 3
         - 2
-        - 5
-        version: "2.5"
+        version: "3.2"
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: ParseTree
+  name: rdoc
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 19
         segments: 
         - 3
-        - 0
-        version: "3.0"
+        - 10
+        version: "3.10"
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -106,11 +111,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 7
         segments: 
-        - 2
-        - 12
-        version: "2.12"
+        - 3
+        - 0
+        version: "3.0"
   type: :development
   version_requirements: *id005
 description: |-
@@ -158,16 +163,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: seattlerb
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: ruby2ruby provides a means of generating pure ruby code easily from RubyParser compatible Sexps

metadata.gz.sig

@@ -1 +1,3 @@
-�|����6d�4�e
 �ڿ7]�0���o+1�y' �s1��
+�eߵB�IY��:���q�F��5M��H�{�V>LYy��8��uc��$���{������Q`{��f.���#�8����cs�	׵Ct�|ɘB��ӭ��\������������H_5����Wb�m�k���������
+��k㎄8K��m\����ti���y��JT��5�_���p��1g]�Wk+��_��nmQ��]
+ ��L�8�%�?��&����a`��ލ<g�3(�����=��L