clean_ripper 0.0.0 → 0.0.1

data/lib/clean_ripper.rb

@@ -1,5 +1,5 @@
 
-require 'clean_sexp_builder'
+require './clean_sexp_builder'
 
 CleanRipper = Ripper::CleanSexpBuilder
 

data/lib/clean_ripper_doc.rb

@@ -0,0 +1,51 @@
+
+warn "Don't include this file! ('clean_ripper_doc.rb')"
+
+# Show all sexp that CleanRipper can output.
+class CleanRipperDocumentation
+  
+  # A literal object.
+  # @example
+  #   1    #=> [:lit, 1]
+  #   "aa" #=> [:lit, "aa"]
+  # @param [Opject] value The literal object.
+  def lit(value)
+    
+  end
+  
+  # A binary operation.
+  # @example
+  #   1+2     #=> [:binary, [:lit, 1], :+, [:lit, 2]]
+  #   a and b #=> [:binary, [lvar, :a], :and, [:lvar, :a]]
+  # @param [Sexp] right The right side of the operation.
+  # @param [Sexp] left The left side of the operation.
+  # @param [Symbol] operator The operator.
+  def binary(right, operator, left)
+    
+  end
+  
+  # A unary operation.
+  # @example
+  #   -a     #=> [:unary, :-, [:lvar, :a]]
+  #   !b     #=> [:unary, :!, [:lvar, :b]]
+  # @param [Sexp] receiver The receiver of the operation.
+  # @param [Symbol] operator The operator.
+  def unary(operator, receiver)
+    
+  end
+  
+  # A method call.
+  # @example
+  #   Array.new(5, nil)
+  #   #=> [:call, [:const, :Array], :new, [[:lit, 5], [:nil]], nil]
+  #   print var
+  #   #=> [:call, nil, :print, [[:ident, :var]], nil]
+  # @param [Sexp, nil] receiver How calls the method.
+  # @param [Symbol] method The method name.
+  # @param [Array] arguments Array of arguments.
+  # @param [Sexp, nil] block Block passed to the method.
+  def call(receiver, method, arguments, block)
+    
+  end
+  
+end

data/lib/clean_sexp_builder.rb

@@ -3,7 +3,7 @@ require 'ripper'
 
 class Ripper
   class CleanSexpBuilder < SexpBuilder
-  
+    
     def initialize(source)
       @source = source.split("\n")
       super
@@ -33,6 +33,42 @@ class Ripper
       [:splat, args.last]
     end
     
+    def on_mlhs_new(*args)
+      nil
+    end
+    
+    def on_mlhs_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_regexp_new(*args)
+      nil
+    end
+    
+    def on_regexp_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_xstring_new(*args)
+      nil
+    end
+    
+    def on_xstring_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_mrhs_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_rescue_mod(*args)
+      [:begin, [:body, args[0]], [:rescue, nil, nil, args[1]], nil, nil]
+    end
+    
+    def on_mrhs_new_from_args(*args)
+      args.first
+    end
+    
     def on_args_add_star(*args)
       [:splat, args.last]
     end
@@ -72,7 +108,7 @@ class Ripper
     def on_ivar(*args)
       [:ivar, args.first.to_sym]
     end
-        
+    
     def on_ident(*args)
       [:ident, args.first.to_sym]
     end
@@ -82,17 +118,29 @@ class Ripper
     end
     
     def on_method_add_arg(*args)
-      [:call, args.first[1][1], (args[1][1] if args[1]), nil]
+      [:call, *args.first, (args[1][1] if args[1]) || [], nil]
+    end
+    
+    def on_call(*args)
+      [args[0], args[-1][1]]
+    end
+    
+    def on_fcall(*args)
+      [nil, args[0][1]]
     end
     
     def on_args_add_block(*args)
-      [:block] + args.first
+      args.first
     end
     
     def on_args_new(*args)
       nil
     end
     
+    def on_command(*args)
+      [:call, nil, args[0][1], args[1] || [], nil]
+    end
+    
     def on_args_add(*args)
       args.first ? args.first + [args.last] : [args.last]
     end
@@ -101,7 +149,7 @@ class Ripper
       brace_block = args[1]
       brace_block[2].unshift(:block)
       brace_block[2] = nil if brace_block[2].compact.size == 1
-      args.first[0..2] << brace_block
+      args.first[0, 4] << brace_block
     end
     
     def on_block_var(*args)
@@ -134,6 +182,7 @@ class Ripper
     
     def on_paren(*args)
       l = args.first
+      l = [l] if Symbol === l[0]
       l.size == 1 ? l.first : [:block] + l
     end
     
@@ -141,8 +190,42 @@ class Ripper
       [args.first.to_sym]
     end
     
+    def on_begin(*args)
+      body = args.first.shift
+      body.size > 1 ? body = [:block, *body] : body = body.first
+      [:begin, [:body, body], *args.first]
+    end
+    
+    def on_else(*args)
+      block = args.first
+      block.size > 1 ? block = [:block, *block] : block = block.first
+      [:else, block]
+    end
+    
+    def on_ensure(*args)
+      block = args.first
+      block.size > 1 ? block = [:block, *block] : block = block.first
+      [:ensure, block]
+    end
+    
+    def on_rescue(*args)
+      err = args.shift
+      var = args.shift
+      block = args.first
+      block.size > 1 ? block = [:block, *block] : block = block.first
+      [:rescue, err, var, block]
+    end
+    
+    def on_const(*args)
+      [:const, args.first.to_sym]
+    end
+    
+    def on_bodystmt(*args)
+      args
+    end
+    
     def on_do_block(*args)
-      [:brace_block] + args
+      [:brace_block, args[0] ? args[0][1..-1] : [], args[1]]
     end
     
     def on_if_mod(*args)
@@ -177,19 +260,88 @@ class Ripper
     end
     
     def on_string_literal(*args)
-      [:string, *(args.first || []).compact]
+      s = [:string, *(args.first || []).compact]
+      if s.size == 2 and s[1][0] == :lit
+        s[1]
+      elsif s.size == 1
+        [:lit, ""]
+      else
+        s
+      end
     end
     
     def on_tstring_content(*args)
       str = "\""+args.first+"\""
       if @source[lineno-1][column-1, 1] == "'"
         str[0] = str[-1] = "'"
+      elsif @source[lineno-1][column-1, 1] == "/"
+        str[0] = str[-1] = "/"
+      else
+        if @source[lineno-1][column-1-2, 2] =~ /%([qQ])/
+          case $1
+          when "q"
+            str[0] = str[-1] = "'"
+          when "Q"
+          end
+        end
       end
-      [:str, eval(str)]
+      [:lit, eval(str)]
     end
     
     def on_string_embexpr(*args)
-      [:block] + args.first if args.first.first
+      if args[0][0]
+        args[0].size == 1 ? args[0][0] : [:block] + args[0]
+      end
+    end
+    
+    def on_qwords_new(*args)
+      args
+    end
+    
+    def on_massign(*args)
+      if args[0][0] == :mlhs_add_star
+        [:massign_splat, args[0][1] << args[0][2], args[1]]
+      else
+        [:massign, *args]
+      end
+    end
+    
+    def on_field(*args)
+      [:field, args[0], args[2][1], []]
+    end
+    
+    def on_aref_field(*args)
+      [:field, args[0], :[], args[1]]
+    end
+    
+    def on_mlhs_paren(*args)
+      [:group, *args[0]]
+    end
+    
+    def on_regexp_literal(*args)
+      s = [:regex, *(args.first || []).compact]
+      if s.size == 2 and s[1][0] == :lit
+        s[1]
+      elsif s.size == 1
+        [:lit, //]
+      else
+        s
+      end
+    end
+    
+    def on_dyna_symbol(*args)
+      s = [:symbol, *(args.first || []).compact]
+      if s.size == 2 and s[1][0] == :lit
+        [:lit, s[1][1].to_sym]
+      elsif s.size == 1
+        [:lit, "".to_sym]
+      else
+        s
+      end
+    end
+    
+    def on_symbol_literal(*args)
+      [:lit, args[0][1][1]]
     end
     
   end

data/test/clean_ripper_test.rb

@@ -160,9 +160,11 @@ class CleanRipperTest < Test::Unit::TestCase
     clean_ripper = [:program,
       [:assign,
         [:lvar, :a],
-        [:rescue_mod,
-          [:ident, :oops],
-          [:lit, 10]
+        [:begin,
+          [:body, [:ident, :oops]],
+          [:rescue, nil, nil, [:lit, 10]],
+          nil,
+          nil
         ]
       ]
     ]
@@ -414,5 +416,633 @@ class CleanRipperTest < Test::Unit::TestCase
     assert_equal(clean_ripper, CleanRipper.parse(code))
     assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
   end
+  def test_011
+    code = <<-END
+    a,b = 1,2
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:massign,
+        [[:ident, :a], [:ident, :b]],
+        [[:lit, 1], [:lit, 2]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:massign,
+          [:mlhs_add,
+            [:mlhs_add,
+              [:mlhs_new], 
+              [:@ident, "a", [1, 4]]
+            ],
+            [:@ident, "b", [1, 6]]
+          ],
+          [:mrhs_add,
+            [:mrhs_new_from_args,
+              [:args_add,
+                [:args_new],
+                [:@int, "1", [1, 10]]
+              ]
+            ],
+            [:@int, "2", [1, 12]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_012
+    code = <<-END
+    begin
+      a
+    rescue
+      b
+    else
+      c
+    ensure
+      d
+    end
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:begin,
+        [:body, [:ident, :a]],
+        [:rescue, nil, nil, [:ident, :b]],
+        [:else, [:ident, :c]],
+        [:ensure, [:ident, :d]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:begin,
+          [:bodystmt,
+            [:stmts_add,
+              [:stmts_new],
+              [:var_ref, [:@ident, "a", [2, 6]]]
+            ],
+            [:rescue, nil, nil,
+              [:stmts_add,
+                [:stmts_new],
+                [:var_ref, [:@ident, "b", [4, 6]]]
+              ],
+              nil
+            ],
+            [:else,
+              [:stmts_add,
+                [:stmts_new],
+                [:var_ref, [:@ident, "c", [6, 6]]]
+              ]
+            ],
+            [:ensure,
+              [:stmts_add,
+                [:stmts_new],
+                [:var_ref, [:@ident, "d", [8, 6]]]
+              ]
+            ]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_013
+    code = <<-END
+      print var
+      print(var)
+      print (var)
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:call, nil, :print, [[:ident, :var]], nil],
+      [:call, nil, :print, [[:ident, :var]], nil],
+      [:call, nil, :print, [[:ident, :var]], nil]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_add,
+            [:stmts_new],
+            [:command,
+              [:@ident, "print", [1, 6]],
+              [:args_add_block,
+                [:args_add,
+                  [:args_new],
+                  [:var_ref, [:@ident, "var", [1, 12]]]
+                ],
+                false
+              ]
+            ]
+          ],
+          [:method_add_arg,
+            [:fcall, [:@ident, "print", [2, 6]]],
+            [:arg_paren,
+              [:args_add_block,
+                [:args_add,
+                  [:args_new],
+                  [:var_ref, [:@ident, "var", [2, 12]]]
+                ],
+                false
+              ]
+            ]
+          ]
+        ],
+        [:command,
+          [:@ident, "print", [3, 6]],
+          [:args_add_block,
+            [:args_add,
+              [:args_new],
+              [:paren,
+                [:var_ref, [:@ident, "var", [3, 13]]]
+              ]
+            ],
+            false
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_014
+    code = <<-END
+    Array.new(5, nil)
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:call, [:const, :Array], :new, [[:lit, 5], [:nil]], nil]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:method_add_arg,
+          [:call,
+            [:var_ref, [:@const, "Array", [1, 4]]],
+            :".",
+            [:@ident, "new", [1, 10]]
+          ],
+          [:arg_paren,
+            [:args_add_block,
+              [:args_add,
+                [:args_add,
+                  [:args_new],
+                  [:@int, "5", [1, 14]]
+                ],
+                [:var_ref, [:@kw, "nil", [1, 17]]]
+              ],
+              false
+            ]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_015
+    code = <<-END
+    eval do
+      print "Hello World!"
+    end
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:call, nil, :eval, [],
+        [:brace_block,
+          [],
+          [:block,
+            [:call, nil, :print, [[:lit, "Hello World!"]], nil]
+          ]
+        ]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:method_add_block,
+          [:method_add_arg,
+            [:fcall, [:@ident, "eval", [1, 4]]], 
+            [:args_new]
+          ],
+          [:do_block, nil,
+            [:stmts_add,
+              [:stmts_new],
+              [:command,
+                [:@ident, "print", [2, 6]],
+                [:args_add_block,
+                  [:args_add,
+                    [:args_new],
+                    [:string_literal,
+                      [:string_add,
+                        [:string_content],
+                        [:@tstring_content, "Hello World!", [2, 13]]
+                      ]
+                    ]
+                  ],
+                  false
+                ]
+              ]
+            ]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_016
+    code = <<-'END'
+    a = "hello"
+    b = /world/
+    "a = #{a}" =~ /(.)\s=\s#{a}/
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:assign, [:lvar, :a], [:lit, "hello"]],
+      [:assign, [:lvar, :b], [:lit, /world/]],
+      [:binary,
+        [:string, [:lit, "a = "], [:ident, :a]],
+        :=~,
+        [:regex, [:lit, /(.)\s=\s/], [:ident, :a]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_add,
+            [:stmts_new],
+            [:assign,
+              [:var_field, [:@ident, "a", [1, 4]]],
+              [:string_literal,
+                [:string_add,
+                  [:string_content],
+                  [:@tstring_content, "hello", [1, 9]]
+                ]
+              ]
+            ]
+          ],
+          [:assign,
+            [:var_field, [:@ident, "b", [2, 4]]],
+            [:regexp_literal,
+              [:regexp_add,
+                [:regexp_new],
+                [:@tstring_content, "world", [2, 9]]
+              ],
+              [:@regexp_end, "/", [2, 14]]
+            ]
+          ]
+        ],
+        [:binary,
+          [:string_literal,
+            [:string_add,
+              [:string_add,
+                [:string_content],
+                [:@tstring_content, "a = ", [3, 5]]
+              ],
+              [:string_embexpr,
+                [:stmts_add,
+                  [:stmts_new],
+                  [:var_ref, [:@ident, "a", [3, 11]]]
+                ]
+              ]
+            ]
+          ],
+          :=~,
+          [:regexp_literal,
+            [:regexp_add,
+              [:regexp_add,
+                [:regexp_new],
+                [:@tstring_content, "(.)\\s=\\s", [3, 19]]
+              ],
+              [:string_embexpr,
+                [:stmts_add,
+                  [:stmts_new],
+                  [:var_ref, [:@ident, "a", [3, 29]]]
+                ]
+              ]
+            ],
+            [:@regexp_end, "/", [3, 31]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_017
+    code = <<-'END'
+    %q{Hello\sWorld}
+    %Q{Hello\sWorld}
+    %w{Hello World}
+    %s{Hello}
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:lit, "Hello\\sWorld"],
+      [:lit, "Hello World"],
+      [:array, [:lit, "Hello"], [:lit, "World"]],
+      [:lit, :Hello]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_add,
+            [:stmts_add,
+              [:stmts_new],
+              [:string_literal,
+                [:string_add,
+                  [:string_content],
+                  [:@tstring_content, "Hello\\sWorld", [1, 7]]
+                ]
+              ]
+            ],
+            [:string_literal,
+              [:string_add,
+                [:string_content],
+                [:@tstring_content, "Hello\\sWorld", [2, 7]]
+              ]
+            ]
+          ],
+          [:array,
+            [:qwords_add,
+              [:qwords_add,
+                [:qwords_new],
+                [:@tstring_content, "Hello", [3, 7]]
+              ],
+              [:@tstring_content, "World", [3, 13]]
+            ]
+          ]
+        ],
+        [:dyna_symbol,
+          [:xstring_add,
+            [:xstring_new],
+            [:@tstring_content, "Hello", [4, 7]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_018
+    code = <<-'END'
+    a, b, c = []
+    a, b, *c = []
+    a, b, c = *[]
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:massign,
+        [[:ident, :a], [:ident, :b], [:ident, :c]],
+        [:array]
+      ],
+      [:massign_splat,
+        [[:ident, :a], [:ident, :b], [:ident, :c]],
+        [:array]
+      ],
+      [:massign,
+        [[:ident, :a], [:ident, :b], [:ident, :c]],
+        [:splat, [:array]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_add,
+            [:stmts_new],
+            [:massign,
+              [:mlhs_add,
+                [:mlhs_add,
+                  [:mlhs_add,
+                    [:mlhs_new],
+                    [:@ident, "a", [1, 4]]
+                  ],
+                  [:@ident, "b", [1, 7]]
+                ],
+                [:@ident, "c", [1, 10]]
+              ],
+              [:array, nil]
+            ]
+          ],
+          [:massign,
+            [:mlhs_add_star,
+              [:mlhs_add,
+                [:mlhs_add,
+                  [:mlhs_new],
+                  [:@ident, "a", [2, 4]]
+                ],
+                [:@ident, "b", [2, 7]]
+              ],
+              [:@ident, "c", [2, 11]]
+            ],
+            [:array, nil]
+          ]
+        ],
+        [:massign,
+          [:mlhs_add,
+            [:mlhs_add,
+              [:mlhs_add,
+                [:mlhs_new],
+                [:@ident, "a", [3, 4]]
+              ],
+              [:@ident, "b", [3, 7]]
+            ],
+            [:@ident, "c", [3, 10]]
+          ],
+          [:mrhs_add_star,
+            [:mrhs_new],
+            [:array, nil]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_019
+    code = <<-'END'
+    a.x, b = 1, 2
+    a[2], b = 1, 2
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:massign,
+        [[:field, [:ident, :a], :x, []], [:ident, :b]],
+        [[:lit, 1], [:lit, 2]]
+      ],
+      [:massign,
+        [[:field, [:ident, :a], :[], [[:lit, 2]]], [:ident, :b]],
+        [[:lit, 1], [:lit, 2]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_new],
+          [:massign,
+            [:mlhs_add,
+              [:mlhs_add,
+                [:mlhs_new],
+                [:field,
+                  [:var_ref, [:@ident, "a", [1, 4]]],
+                  :".",
+                  [:@ident, "x", [1, 6]]
+                ]
+              ],
+              [:@ident, "b", [1, 9]]
+            ],
+            [:mrhs_add,
+              [:mrhs_new_from_args,
+                [:args_add,
+                  [:args_new],
+                  [:@int, "1", [1, 13]]
+                ]
+              ],
+              [:@int, "2", [1, 16]]
+            ]
+          ]
+        ],
+        [:massign,
+          [:mlhs_add,
+            [:mlhs_add,
+              [:mlhs_new],
+              [:aref_field,
+                [:var_ref, [:@ident, "a", [2, 4]]],
+                [:args_add_block,
+                  [:args_add,
+                    [:args_new],
+                    [:@int, "2", [2, 6]]
+                  ],
+                  false
+                ]
+              ]
+            ],
+            [:@ident, "b", [2, 10]]
+          ],
+          [:mrhs_add,
+            [:mrhs_new_from_args,
+              [:args_add,
+                [:args_new],
+                [:@int, "1", [2, 14]]
+              ]
+            ],
+            [:@int, "2", [2, 17]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_020
+    code = <<-'END'
+    a, (b, c), d = 1, [2, 3], 4
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:massign,
+        [
+          [:ident, :a],
+          [:group, [:ident, :b], [:ident, :c]],
+          [:ident, :d]
+        ],
+        [
+          [:lit, 1],
+          [:array, [:lit, 2], [:lit, 3]],
+          [:lit, 4]
+        ]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:massign,
+          [:mlhs_add,
+            [:mlhs_add,
+              [:mlhs_add,
+                [:mlhs_new],
+                [:@ident, "a", [1, 4]]
+              ],
+              [:mlhs_paren,
+                [:mlhs_add,
+                  [:mlhs_add,
+                    [:mlhs_new],
+                    [:@ident, "b", [1, 8]]
+                  ],
+                  [:@ident, "c", [1, 11]]
+                ]
+              ]
+            ],
+            [:@ident, "d", [1, 15]]
+          ],
+          [:mrhs_add,
+            [:mrhs_new_from_args,
+              [:args_add,
+                [:args_add,
+                  [:args_new],
+                  [:@int, "1", [1, 19]]
+                ],
+                [:array,
+                  [:args_add,
+                    [:args_add,
+                      [:args_new],
+                      [:@int, "2", [1, 23]]
+                    ],
+                    [:@int, "3", [1, 26]]
+                  ]
+                ]
+              ]
+            ],
+            [:@int, "4", [1, 30]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clean_ripper
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ cert_chain: []
 date: 2011-09-10 00:00:00.000000000Z
 dependencies: []
 description: Produces a clean output for Ripper, making the output tree usable and
-  redable.
+  readable.
 email: lb-guilherme@live.com
 executables: []
 extensions: []
@@ -20,6 +20,7 @@ extra_rdoc_files: []
 files:
 - lib/clean_ripper.rb
 - lib/clean_sexp_builder.rb
+- lib/clean_ripper_doc.rb
 - test/clean_ripper_test.rb
 homepage: https://github.com/LBg/CleanRipper
 licenses: []
@@ -41,9 +42,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: Produces a clean output for Ripper.
 test_files:
 - test/clean_ripper_test.rb
+has_rdoc: