ripper_ruby_parser 0.0.1

data/test/unit/sexp_processor_test.rb

@@ -0,0 +1,309 @@
+require File.expand_path('../test_helper.rb', File.dirname(__FILE__))
+
+class TestProcessor < RipperRubyParser::SexpProcessor
+  def process_foo exp
+    exp.shift
+    s(:foo_p)
+  end
+
+  def process_bar exp
+    exp.shift
+    s(:bar_p)
+  end
+
+  def process_baz exp
+    exp.shift
+    s(:baz_p)
+  end
+end
+
+describe RipperRubyParser::SexpProcessor do
+  let :processor do
+    TestProcessor.new
+  end
+
+  describe "#process" do
+    it "can handle s(s()) constructs" do
+      sexp = s(s())
+      processor.process sexp
+    end
+
+    it "can handle line number information constructs" do
+      sexp = s(1, 6)
+      processor.process sexp
+    end
+
+    describe "for a :program sexp" do
+      it "strips off the outer :program node" do
+        sexp = s(:program, s(s(:foo)))
+        result = processor.process sexp
+        result.must_equal s(:foo_p)
+      end
+
+      it "transforms a multi-statement :program into a :block sexp" do
+        sexp = s(:program, s(s(:foo), s(:bar)))
+        result = processor.process sexp
+        result.must_equal s(:block, s(:foo_p), s(:bar_p))
+      end
+    end
+
+    describe "for a :string_literal sexp" do
+      it "transforms a simple sexp to :str" do
+        sexp = s(:string_literal, s(:string_content, s(:@tstring_content, "foo")))
+        result = processor.process sexp
+        result.must_equal s(:str, "foo")
+      end
+    end
+
+    describe "for an :args_add_block sexp" do
+      it "transforms a one-argument sexp to an :arglist" do
+        sexp = s(:args_add_block, s(s(:foo)), false)
+        result = processor.process sexp
+        result.must_equal s(:arglist, s(:foo_p))
+      end
+
+      it "transforms a multi-argument sexp to an :arglist" do
+        sexp = s(:args_add_block, s(s(:foo), s(:bar)), false)
+        result = processor.process sexp
+        result.must_equal s(:arglist, s(:foo_p), s(:bar_p))
+      end
+    end
+
+    describe "for a :command sexp" do
+      it "transforms a sexp to a :call" do
+        sexp = s(:command, s(:@ident, "foo", s(1, 0)), s(:foo))
+        result = processor.process sexp
+        result.must_equal s(:call, nil, :foo, s(:foo_p))
+      end
+    end
+
+    describe "for a :var_ref sexp" do
+      it "transforms the sexp to a :lvar sexp" do
+        sexp = s(:var_ref, s(:@ident, "bar", s(1, 4)))
+        result = processor.process sexp
+        result.must_equal s(:lvar, :bar)
+      end
+    end
+
+    describe "for a :vcall sexp" do
+      it "transforms the sexp to a :call sexp" do
+        sexp = s(:vcall, s(:@ident, "bar", s(1, 4)))
+        result = processor.process sexp
+        result.must_equal s(:call, nil, :bar, s(:arglist))
+      end
+    end
+
+    describe "for a :module sexp" do
+      it "does not create a nested :block sexp for an empty definition" do
+        sexp = s(:module,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
+                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:module, :Foo, s(:scope))
+      end
+
+      it "does not create a nested :block sexp for a definition with one statement" do
+        sexp = s(:module,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
+                 s(:bodystmt, s(s(:foo)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:module, :Foo, s(:scope, s(:foo_p)))
+      end
+
+      it "creates a nested :block sexp for a definition with more than one statement" do
+        sexp = s(:module,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
+                 s(:bodystmt, s(s(:foo), s(:bar)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:module, :Foo,
+                            s(:scope, s(:block, s(:foo_p), s(:bar_p))))
+      end
+    end
+
+    describe "for a :class sexp" do
+      it "does not create a nested :block sexp for an empty definition" do
+        sexp = s(:class,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
+                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:class, :Foo, nil, s(:scope))
+      end
+
+      it "does not create a nested :block sexp for a definition with one statement" do
+        sexp = s(:class,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
+                 s(:bodystmt, s(s(:foo)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:class, :Foo, nil, s(:scope, s(:foo_p)))
+      end
+
+      it "creates a nested :block sexp for a definition with more than one statement" do
+        sexp = s(:class,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))), nil,
+                 s(:bodystmt, s(s(:foo), s(:bar)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:class,
+                            :Foo, nil,
+                            s(:scope, s(:block, s(:foo_p), s(:bar_p))))
+      end
+
+      it "passes on the given ancestor" do
+        sexp = s(:class,
+                 s(:const_ref, s(:@const, "Foo", s(1, 13))),
+                 s(:var_ref, s(:@const, "Bar", s(1, 12))),
+                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:class, :Foo, s(:const, :Bar), s(:scope))
+      end
+    end
+
+    describe "for a :bodystmt sexp" do
+      it "creates a :scope sexp with nested :block" do
+        sexp = s(:bodystmt, s(s(:foo), s(:bar)), nil, nil, nil)
+        result = processor.process sexp
+        result.must_equal s(:scope, s(:block, s(:foo_p), s(:bar_p)))
+      end
+
+      it "removes nested :void_stmt sexps" do
+        sexp = s(:bodystmt, s(s(:void_stmt), s(:foo)), nil, nil, nil)
+        result = processor.process sexp
+        result.must_equal s(:scope, s(:block, s(:foo_p)))
+      end
+    end
+
+    describe "for a :def sexp" do
+      it "transforms the sexp for a basic function definition" do
+        sexp = s(:def,
+                 s(:@ident, "foo", s(1, 4)),
+                 s(:params, nil, nil, nil, nil, nil),
+                 s(:bodystmt, s(s(:void_stmt)), nil, nil, nil))
+        result = processor.process sexp
+        result.must_equal s(:defn,
+                            :foo, s(:args), s(:scope, s(:block, s(:nil))))
+
+      end
+    end
+
+    describe "for a :params sexp" do
+      describe "with a normal argument" do
+        it "uses the bare argument names" do
+          sexp =  s(:params, s(s(:@ident, "bar", s(1, 8))), nil, nil, nil, nil)
+          result = processor.process sexp
+          result.must_equal s(:args, :bar)
+        end
+      end
+    end
+
+    describe "for an :assign sexp" do
+      it "creates a :lasgn sexp" do
+        sexp = s(:assign,
+                 s(:var_field, s(:@ident, "a", s(1, 0))),
+                 s(:@int, "1", s(1, 4)))
+        result = processor.process sexp
+        result.must_equal s(:lasgn, :a, s(:lit, 1))
+      end
+    end
+
+    describe "for a :binary sexp" do
+      it "creates a :call sexp with an :arglist" do
+        sexp = s(:binary, s(:bar), :==, s(:foo))
+        result = processor.process sexp
+        result.must_equal s(:call, s(:bar_p), :==, s(:arglist, s(:foo_p)))
+      end
+    end
+
+    describe "for a :method_add_block sexp" do
+      it "creates an :iter sexp" do
+        sexp = s(:method_add_block,
+                 s(:call, s(:foo), :".", s(:@ident, "baz", s(1, 2))),
+                 s(:brace_block, nil, s(s(:bar))))
+        result = processor.process sexp
+        result.must_equal s(:iter,
+                            s(:call, s(:foo_p), :baz, s(:arglist)), nil,
+                            s(:bar_p))
+      end
+
+      describe "with a block parameter" do
+        it "creates an :iter sexp with a :lasgn sexp for the block parameter" do
+          sexp = s(:method_add_block,
+                   s(:call, s(:foo), :".", s(:@ident, "baz", s(1, 2))),
+                   s(:brace_block,
+                     s(:block_var,
+                       s(:params, s(s(:@ident, "i", s(1, 6))), nil, nil, nil, nil),
+                       nil),
+                     s(s(:bar))))
+          result = processor.process sexp
+          result.must_equal s(:iter,
+                              s(:call, s(:foo_p), :baz, s(:arglist)),
+                              s(:lasgn, :i),
+                              s(:bar_p))
+        end
+      end
+    end
+
+    describe "for an :if sexp" do
+      describe "with a single statement in the if body" do
+        it "uses the statement sexp as the body" do
+          sexp = s(:if, s(:foo), s(s(:bar)), nil)
+          result = processor.process sexp
+          result.must_equal s(:if, s(:foo_p), s(:bar_p), nil)
+        end
+      end
+
+      describe "with multiple statements in the if body" do
+        it "uses a block containing the statement sexps as the body" do
+          sexp = s(:if, s(:foo), s(s(:bar), s(:baz)), nil)
+          result = processor.process sexp
+          result.must_equal s(:if, s(:foo_p), s(:block, s(:bar_p), s(:baz_p)), nil)
+        end
+      end
+    end
+
+    describe "for an :array sexp" do
+      it "pulls up the element sexps" do
+        sexp = s(:array, s(s(:foo), s(:bar), s(:baz)))
+        result = processor.process sexp
+        result.must_equal s(:array, s(:foo_p), s(:bar_p), s(:baz_p))
+      end
+    end
+
+    describe "for a :const_path_ref sexp" do
+      it "returns a :colon2 sexp" do
+        sexp = s(:const_path_ref,
+                 s(:var_ref, s(:@const, "Foo", s(1, 0))),
+                 s(:@const, "Bar", s(1, 5)))
+        result = processor.process sexp
+        result.must_equal s(:colon2, s(:const, :Foo), :Bar)
+      end
+    end
+
+    describe "for a :when sexp" do
+      it "turns nested :when clauses into a list" do
+        sexp = s(:when, s(s(:foo)), s(s(:bar)),
+                 s(:when, s(s(:foo)), s(s(:bar)),
+                   s(:when, s(s(:foo)), s(s(:bar)), nil)))
+        result = processor.process sexp
+        result.must_equal s(s(:when, s(:array, s(:foo_p)), s(:bar_p)),
+                            s(:when, s(:array, s(:foo_p)), s(:bar_p)),
+                            s(:when, s(:array, s(:foo_p)), s(:bar_p)),
+                            nil)
+      end
+    end
+  end
+
+  describe "#identifier_node_to_symbol" do
+    it "processes an identifier sexp to a bare symbol" do
+      sexp = s(:@ident, "foo", s(1, 0))
+      result = processor.send :identifier_node_to_symbol, sexp
+      result.must_equal :foo
+    end
+  end
+
+  describe "#const_node_to_symbol" do
+    it "processes a const sexp to a bare symbol" do
+      sexp = s(:@const, "Foo", s(1, 0))
+      result = processor.send :const_node_to_symbol, sexp
+      result.must_equal :Foo
+    end
+  end
+end

data/test/unit/version_test.rb

@@ -0,0 +1,5 @@
+describe RipperRubyParser do
+  it "knows its own version" do
+    RipperRubyParser::VERSION.wont_be_nil
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: ripper_ruby_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matijs van Zuijlen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sexp_processor
+  requirement: &22169420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *22169420
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &22168900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.2
+  type: :development
+  prerelease: false
+  version_requirements: *22168900
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &22221020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *22221020
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: &22220540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :development
+  prerelease: false
+  version_requirements: *22220540
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &22220160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *22220160
+description: 
+email:
+- matijs@matijs.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/ripper_ruby_parser.rb
+- lib/ripper_ruby_parser/sexp_ext.rb
+- lib/ripper_ruby_parser/sexp_handlers/operators.rb
+- lib/ripper_ruby_parser/sexp_handlers/methods.rb
+- lib/ripper_ruby_parser/sexp_handlers/arrays.rb
+- lib/ripper_ruby_parser/sexp_handlers/method_calls.rb
+- lib/ripper_ruby_parser/sexp_handlers/loops.rb
+- lib/ripper_ruby_parser/sexp_handlers/conditionals.rb
+- lib/ripper_ruby_parser/sexp_handlers/blocks.rb
+- lib/ripper_ruby_parser/sexp_handlers/literals.rb
+- lib/ripper_ruby_parser/sexp_handlers/assignment.rb
+- lib/ripper_ruby_parser/sexp_handlers/arguments.rb
+- lib/ripper_ruby_parser/sexp_handlers/hashes.rb
+- lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb
+- lib/ripper_ruby_parser/parser.rb
+- lib/ripper_ruby_parser/version.rb
+- lib/ripper_ruby_parser/sexp_handlers.rb
+- lib/ripper_ruby_parser/sexp_processor.rb
+- test/test_helper.rb
+- test/end_to_end/lib_comparison_test.rb
+- test/end_to_end/comparison_test.rb
+- test/end_to_end/test_comparison_test.rb
+- test/unit/parser_test.rb
+- test/unit/sexp_processor_test.rb
+- test/unit/version_test.rb
+- README.rdoc
+- Rakefile
+homepage: http://www.github.com/mvz/ripper_ruby_parser
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Parse with Ripper, produce sexps that are compatible with RubyParser.
+test_files:
+- test/end_to_end/comparison_test.rb
+- test/end_to_end/lib_comparison_test.rb
+- test/end_to_end/test_comparison_test.rb
+- test/test_helper.rb
+- test/unit/parser_test.rb
+- test/unit/sexp_processor_test.rb
+- test/unit/version_test.rb