clean_ripper 0.0.0

data/lib/clean_ripper.rb

@@ -0,0 +1,8 @@
+
+require 'clean_sexp_builder'
+
+CleanRipper = Ripper::CleanSexpBuilder
+
+def CleanRipper.parse(source)
+  CleanRipper.new(source).parse
+end

data/lib/clean_sexp_builder.rb

@@ -0,0 +1,196 @@
+
+require 'ripper'
+
+class Ripper
+  class CleanSexpBuilder < SexpBuilder
+  
+    def initialize(source)
+      @source = source.split("\n")
+      super
+    end
+    
+    def on_program(*args)
+      [:program] + args.first
+    end
+    
+    def on_void_stmt(*args)
+      nil
+    end
+    
+    def on_stmts_new(*args)
+      nil
+    end
+    
+    def on_mrhs_new(*args)
+      nil
+    end
+    
+    def on_stmts_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_mrhs_add_star(*args)
+      [:splat, args.last]
+    end
+    
+    def on_args_add_star(*args)
+      [:splat, args.last]
+    end
+    
+    def on_int(*args)
+      [:lit, eval(args.first)]
+    end
+    
+    def on_float(*args)
+      [:lit, eval(args.first)]
+    end
+    
+    def on_CHAR(*args)
+      [:lit, eval(args.first)]
+    end
+    
+    def on_var_field(*args)
+      var = args.first
+      var[0] = :lvar if var.first == :ident
+      var
+    end
+    
+    def on_var_ref(*args)
+      var = args.first
+      var[0] = :ident if var.first == :ident
+      var
+    end
+    
+    def on_gvar(*args)
+      [:gvar, args.first.to_sym]
+    end
+    
+    def on_cvar(*args)
+      [:cvar, args.first.to_sym]
+    end
+    
+    def on_ivar(*args)
+      [:ivar, args.first.to_sym]
+    end
+        
+    def on_ident(*args)
+      [:ident, args.first.to_sym]
+    end
+    
+    def on_opassign(*args)
+      [:assign, args.first, [:binary, args.first, args[1][1][0..-2].to_sym, args.last]]
+    end
+    
+    def on_method_add_arg(*args)
+      [:call, args.first[1][1], (args[1][1] if args[1]), nil]
+    end
+    
+    def on_args_add_block(*args)
+      [:block] + args.first
+    end
+    
+    def on_args_new(*args)
+      nil
+    end
+    
+    def on_args_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_method_add_block(*args)
+      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
+    end
+    
+    def on_block_var(*args)
+      [:block] + args.first
+    end
+    
+    def on_params(*args)
+      params = []
+      args.first.each do |p|
+        p[0] = :lvar if p.first == :ident
+        params << [:param, p, nil]
+      end if args.first
+      args[1].each do |p|
+        p.first[0] = :lvar if p.first.first == :ident
+        p[1] = [p[1]] if Symbol === p[1].first
+        params << [:param, p.first, [:block, *p[1]]]
+      end if args[1]
+      params << args[2] if args[2]
+      params
+    end
+    
+    def on_rest_param(*args)
+      args.first[0] = :lvar if args.first.first == :ident
+      [:rest_param, args.first]
+    end
+    
+    def on_param_error(*args)
+      args.first
+    end
+    
+    def on_paren(*args)
+      l = args.first
+      l.size == 1 ? l.first : [:block] + l
+    end
+    
+    def on_kw(*args)
+      [args.first.to_sym]
+    end
+    
+    def on_do_block(*args)
+      [:brace_block] + args
+    end
+    
+    def on_if_mod(*args)
+      [:if] + args + [nil]
+    end
+    
+    def on_if(*args)
+      args[0] = [args.first] if Symbol === args.first.first
+      [:if] << [:block] + args.first << ([:block, *args[1]] if args[1].first) << ([:block, *args[2][1][1..-1]] if args[2])
+    end
+    
+    def on_unless(*args)
+      args[0] = [args.first] if Symbol === args.first.first
+      [:if] << [:block] + args.first << ([:block, *args[2][1][1..-1]] if args[2]) << ([:block, *args[1]] if args[1].first)
+    end
+    
+    def on_array(*args)
+      el = args.first || []
+      [:array] + ((el.size > 0 and Symbol === el.first) ? [el] : el)
+    end
+    
+    def on_string_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_qwords_add(*args)
+      args.first ? args.first + [args.last] : [args.last]
+    end
+    
+    def on_string_content(*args)
+      nil
+    end
+    
+    def on_string_literal(*args)
+      [:string, *(args.first || []).compact]
+    end
+    
+    def on_tstring_content(*args)
+      str = "\""+args.first+"\""
+      if @source[lineno-1][column-1, 1] == "'"
+        str[0] = str[-1] = "'"
+      end
+      [:str, eval(str)]
+    end
+    
+    def on_string_embexpr(*args)
+      [:block] + args.first if args.first.first
+    end
+    
+  end
+end

data/test/clean_ripper_test.rb

@@ -0,0 +1,418 @@
+
+require 'test/unit'
+require '../lib/clean_ripper'
+
+class CleanRipperTest < Test::Unit::TestCase
+  
+  def test_001
+    code = <<-END
+    (12 + 65) * 3
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:binary,
+        [:binary, 
+          [:lit, 12], 
+          :+, 
+          [:lit, 65]
+        ],
+        :*,
+        [:lit, 3]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:binary,
+          [:paren,
+            [:stmts_add,
+              [:stmts_new],
+              [:binary,
+                [:@int, "12", [1, 5]],
+                :+,
+                [:@int, "65", [1, 10]]
+              ]
+            ]
+          ],
+          :*,
+          [:@int, "3", [1, 16]]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_002
+    code = <<-END
+    --2
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:unary,
+        :-@,
+        [:unary, :-@, [:lit, 2]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:unary, 
+          :-@,
+          [:unary, 
+            :-@, 
+            [:@int, "2", [1, 6]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_003
+    code = <<-END
+    -2**-3
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:unary,
+        :-@,
+        [:binary,
+          [:lit, 2],
+          :**,
+          [:unary, :-@, [:lit, 3]]
+        ]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:unary,
+          :-@,
+          [:binary,
+            [:@int, "2", [1, 5]],
+            :**,
+            [:unary,
+              :-@,
+              [:@int, "3", [1, 9]]
+            ]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_004
+    code = <<-END
+    true ? 2 : 3 ? 4 : 5
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:ifop,
+        [:true],
+        [:lit, 2],
+        [:ifop,
+          [:lit, 3],
+          [:lit, 4],
+          [:lit, 5]
+        ]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:ifop,
+          [:var_ref, [:@kw, "true", [1, 4]]],
+          [:@int, "2", [1, 11]],
+          [:ifop,
+            [:@int, "3", [1, 15]],
+            [:@int, "4", [1, 19]],
+            [:@int, "5", [1, 23]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_005
+    code = <<-END
+    a = oops rescue 10
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:assign,
+        [:lvar, :a],
+        [:rescue_mod,
+          [:ident, :oops],
+          [:lit, 10]
+        ]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:assign,
+          [:var_field, [:@ident, "a", [1, 4]]],
+          [:rescue_mod,
+            [:var_ref, [:@ident, "oops", [1, 8]]],
+            [:@int, "10", [1, 20]]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_006
+    code = <<-END
+    a = nil
+    b = 1 + 2
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:assign,
+        [:lvar, :a],
+        [:nil]
+      ],
+      [:assign,
+        [:lvar, :b], 
+        [:binary, [:lit, 1], :+, [:lit, 2]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_new],
+          [:assign,
+            [:var_field, [:@ident, "a", [1, 4]]],
+            [:var_ref, [:@kw, "nil", [1, 8]]]]
+        ],
+        [:assign,
+          [:var_field, [:@ident, "b", [2, 4]]],
+          [:binary, [:@int, "1", [2, 8]], :+, [:@int, "2", [2, 12]]]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_007
+    code = <<-END
+    a = *()
+    b = *[1, 2, 3]
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:assign,
+        [:lvar, :a],
+        [:splat, nil]
+      ],
+      [:assign,
+        [:lvar, :b], 
+        [:splat, 
+          [:array, [:lit, 1], [:lit, 2], [:lit, 3]]
+        ]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_new],
+          [:assign,
+            [:var_field, [:@ident, "a", [1, 4]]],
+            [:mrhs_add_star,
+              [:mrhs_new],
+              [:paren, 
+                [:stmts_add, 
+                  [:stmts_new],
+                  [:void_stmt]
+                ]
+              ]
+            ]
+          ]
+        ],
+        [:assign,
+          [:var_field, [:@ident, "b", [2, 4]]],
+          [:mrhs_add_star,
+            [:mrhs_new],
+            [:array,
+              [:args_add,
+                [:args_add,
+                  [:args_add, 
+                    [:args_new],
+                    [:@int, "1", [2, 10]]
+                  ],
+                  [:@int, "2", [2, 13]]
+                ],
+                [:@int, "3", [2, 16]]
+              ]
+            ]
+          ]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_008
+    code = <<-END
+    a = b = 2
+    a += 5
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:assign,
+        [:lvar, :a],
+        [:assign, [:lvar, :b], [:lit, 2]]
+      ],
+      [:assign,
+        [:lvar, :a], 
+        [:binary, [:lvar, :a], :+, [:lit, 5]]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_new],
+          [:assign,
+            [:var_field, [:@ident, "a", [1, 4]]],
+            [:assign,
+              [:var_field, [:@ident, "b", [1, 8]]],
+              [:@int, "2", [1, 12]]
+            ]
+          ]
+        ],
+        [:opassign,
+          [:var_field, [:@ident, "a", [2, 4]]],
+          [:@op, "+=", [2, 6]],
+          [:@int, "5", [2, 9]]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_009
+    code = <<-END
+    !!10
+    a || b and c
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:unary,
+        :!, 
+        [:unary, :!, [:lit, 10]]
+      ],
+      [:binary,
+        [:binary, [:ident, :a], :"||", [:ident, :b]],
+        :and, 
+        [:ident, :c]
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_add,
+          [:stmts_new],
+          [:unary,
+            :!,
+            [:unary, :!, [:@int, "10", [1, 6]]]
+          ]
+        ],
+        [:binary,
+          [:binary,
+            [:var_ref, [:@ident, "a", [2, 4]]],
+            :"||",
+            [:var_ref, [:@ident, "b", [2, 9]]]],
+          :and,
+          [:var_ref, [:@ident, "c", [2, 15]]]
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  def test_010
+    code = <<-END
+    if true
+      true while true or false
+    end
+    END
+    
+    # CleanRipper output
+    clean_ripper = [:program,
+      [:if,
+        [:block, [:true]],
+        [:block, 
+          [:while_mod,
+            [:binary, [:true], :or, [:false]],
+            [:true]
+          ]
+        ],
+        nil
+      ]
+    ]
+    
+    # Ripper output
+    ripper = [:program,
+      [:stmts_add,
+        [:stmts_new],
+        [:if,
+          [:var_ref, [:@kw, "true", [1, 7]]],
+          [:stmts_add,
+            [:stmts_new],
+            [:while_mod,
+              [:binary,
+                [:var_ref, [:@kw, "true", [2, 17]]],
+                :or,
+                [:var_ref, [:@kw, "false", [2, 25]]]
+              ],
+              [:var_ref, [:@kw, "true", [2, 6]]]
+            ]
+          ],
+          nil
+        ]
+      ]
+    ]
+    
+    assert_equal(clean_ripper, CleanRipper.parse(code))
+    assert_equal(ripper, Ripper::SexpBuilder.new(code).parse)
+  end
+  
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: clean_ripper
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Guilherme Bernal
+autorequire: 
+bindir: bin
+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.
+email: lb-guilherme@live.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/clean_ripper.rb
+- lib/clean_sexp_builder.rb
+- test/clean_ripper_test.rb
+homepage: https://github.com/LBg/CleanRipper
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Produces a clean output for Ripper.
+test_files:
+- test/clean_ripper_test.rb