sexp_processor 3.0.7 → 3.0.8

data/History.txt

@@ -1,3 +1,12 @@
+=== 3.0.8 / 2011-11-16
+
+* 4 minor enhancements:
+
+  * Add 6 missing ruby 1.9 tests (brynary)
+  * Added new 1.9 hash tests to pt_testcase.rb
+  * Version specific tests are now skipped at runtime, not test creation time
+  * Added new block arg tests.
+
 === 3.0.7 / 2011-09-21
 
 * 2 bug fixes:

data/lib/pt_testcase.rb

@@ -72,12 +72,10 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
   end
 
   def self.add_18tests name, hash
-    return unless RUBY_VERSION >= "1.8" and RUBY_VERSION < "1.9"
     add_tests "#{name}__18", hash
   end
 
   def self.add_19tests name, hash
-    return unless RUBY_VERSION >= "1.9"
     add_tests "#{name}__19", hash
   end
 
@@ -98,9 +96,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
   end
 
   def self.generate_test klass, node, data, input_name, output_name
-    klass.send(:define_method, "test_#{node}".to_sym) do
+    klass.send :define_method, "test_#{node}" do
       flunk "Processor is nil" if processor.nil?
 
+      if node =~ /(1[89])$/ then
+        version = $1
+        skip "version specific test" unless self.class.name =~ /#{version}/
+      end
+
       assert data.has_key?(input_name), "Unknown input data"
       assert data.has_key?(output_name), "Missing test data"
 
@@ -128,7 +131,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
         # body into an assertion. It'll allow subclasses to hook in
         # and add behavior before or after the processor does it's
         # thing. If you go the body refactor route, some of the
-        # RawParseTree test casese fail for completely bogus reasons.
+        # RawParseTree test cases fail for completely bogus reasons.
 
         before_process_hook klass, node, data, input_name, output_name
         refute_nil data[input_name], "testcase does not exist?"
@@ -846,6 +849,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
             "ParseTree"    => s(:call, s(:call, nil, :o, s(:arglist)), :puts,
                                 s(:arglist, s(:lit, 42))))
 
+  add_tests("call_no_space_symbol",
+            "Ruby"         => "foo:bar",
+            "RawParseTree" => [:call, nil, :foo, [:array, [:lit, :bar]]],
+            "ParseTree"    => s(:call, nil, :foo, s(:arglist, s(:lit, :bar))))
+
   add_tests("call_arglist_hash",
             "Ruby"         => "o.m(:a => 1, :b => 2)",
             "RawParseTree" => [:call,
@@ -4506,6 +4514,38 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
                                   s(:args, :"*rest", :mand),
                                   s(:scope, s(:block, s(:nil)))))
 
+  add_19tests("defn_args_mand_opt_splat_mand",
+              "Ruby"      => "def f(mand1, opt = 42, *rest, mand2)\n  # do nothing\nend",
+              "ParseTree" => s(:defn, :f,
+                               s(:args, :mand1, :opt, :"*rest", :mand2,
+                                 s(:block,
+                                   s(:lasgn, :opt, s(:lit, 42)))),
+                               s(:scope, s(:block, s(:nil)))))
+
+  add_19tests("defn_args_mand_opt_mand",
+              "Ruby"      => "def f(mand1, opt = 42, mand2)\n  # do nothing\nend",
+              "ParseTree" => s(:defn, :f,
+                               s(:args, :mand1, :opt, :mand2,
+                                 s(:block,
+                                   s(:lasgn, :opt, s(:lit, 42)))),
+                               s(:scope, s(:block, s(:nil)))))
+
+  add_19tests("defn_args_opt_splat_mand",
+              "Ruby"      => "def f(opt = 42, *rest, mand)\n  # do nothing\nend",
+              "ParseTree" => s(:defn, :f,
+                               s(:args, :opt, :"*rest", :mand,
+                                 s(:block,
+                                   s(:lasgn, :opt, s(:lit, 42)))),
+                               s(:scope, s(:block, s(:nil)))))
+
+  add_19tests("defn_args_opt_mand",
+              "Ruby"      => "def f(opt = 42, mand)\n  # do nothing\nend",
+              "ParseTree" => s(:defn, :f,
+                               s(:args, :opt, :mand,
+                                 s(:block,
+                                   s(:lasgn, :opt, s(:lit, 42)))),
+                               s(:scope, s(:block, s(:nil)))))
+
   add_19tests("defn_args_splat_middle",
             "Ruby"         => "def f(first, *middle, last)\n  # do nothing\nend",
             "RawParseTree" => [:defn, :f,
@@ -4539,6 +4579,22 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
                                   s(:lit, :a), s(:lit, 1),
                                   s(:lit, :b), s(:lit, 2)))
 
+  add_19tests("hash_new_no_space",
+              "Ruby"         => "{a:1,b:2}",
+              "RawParseTree" => [:hash,
+                                 [:lit, :a], [:lit, 1],
+                                 [:lit, :b], [:lit, 2]],
+              "ParseTree"    => s(:hash,
+                                  s(:lit, :a), s(:lit, 1),
+                                  s(:lit, :b), s(:lit, 2)))
+
+  add_19tests("lambda_args_block",
+              "Ruby"         => "lambda { |&block| block }",
+              "ParseTree"    => s(:iter,
+                                  s(:call, nil, :lambda, s(:arglist)),
+                                  s(:lasgn, :"&block"),
+                                  s(:lvar, :block)))
+
   add_19tests("lambda_args_0",
               "Ruby"         => "->(){ (x + 1) }",
               "RawParseTree" => [:iter,
@@ -4615,6 +4671,91 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
                                   s(:call, s(:call, nil, :x, s(:arglist)),
                                     :+, s(:arglist, s(:lit, 1)))))
 
+  add_19tests("lambda_args_no_do",
+              "Ruby"         => "-> do (x + 1) end",
+              "RawParseTree" => [:iter,
+                                 [:fcall, :lambda],
+                                 nil,
+                                 [:call, [:vcall, :x], :+,
+                                  [:array, [:lit, 1]]]],
+              "ParseTree"    => s(:iter,
+                                  s(:call, nil, :lambda, s(:arglist)),
+                                  nil,
+                                  s(:call, s(:call, nil, :x, s(:arglist)),
+                                    :+, s(:arglist, s(:lit, 1)))))
+
+  add_19tests("lambda_args_0_do",
+              "Ruby"         => "->() do (x + 1) end",
+              "RawParseTree" => [:iter,
+                                 [:fcall, :lambda],
+                                 0,
+                                 [:call, [:vcall, :x], :+,
+                                  [:array, [:lit, 1]]]],
+              "ParseTree"    => s(:iter,
+                                  s(:call, nil, :lambda, s(:arglist)),
+                                  0,
+                                  s(:call,
+                                    s(:call, nil, :x, s(:arglist)),
+                                    :+,
+                                    s(:arglist, s(:lit, 1)))))
+
+  add_19tests("lambda_args_1_do",
+              "Ruby"         => "-> (x) do (x + 1) end",
+              "RawParseTree" => [:iter,
+                                 [:fcall, :lambda],
+                                 [:dasgn_curr, :x],
+                                 [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
+              "ParseTree"    => s(:iter,
+                                  s(:call, nil, :lambda, s(:arglist)),
+                                  s(:lasgn, :x),
+                                  s(:call, s(:lvar, :x), :+,
+                                    s(:arglist, s(:lit, 1)))))
+
+  add_19tests("lambda_args_2_do",
+              "Ruby"         => "-> (x, y) do (x + y) end",
+              "RawParseTree" => [:iter,
+                                 [:fcall, :lambda],
+                                 [:masgn, [:array,
+                                           [:dasgn_curr, :x],
+                                           [:dasgn_curr, :y]], nil, nil],
+                                 [:call, [:dvar, :x], :+,
+                                  [:array, [:dvar, :y]]]],
+              "ParseTree"    => s(:iter,
+                                  s(:call, nil, :lambda, s(:arglist)),
+                                  s(:masgn,
+                                    s(:array,
+                                      s(:lasgn, :x),
+                                      s(:lasgn, :y))),
+                                  s(:call, s(:lvar, :x), :+,
+                                    s(:arglist, s(:lvar, :y)))))
+
+  add_19tests("lambda_args_2_no_parens_do",
+              "Ruby"         => "->  x, y do (x + y) end",
+              "RawParseTree" => [:iter,
+                                 [:fcall, :lambda],
+                                 [:masgn, [:array,
+                                           [:dasgn_curr, :x],
+                                           [:dasgn_curr, :y]], nil, nil],
+                                 [:call, [:dvar, :x], :+,
+                                  [:array, [:dvar, :y]]]],
+              "ParseTree"    => s(:iter,
+                                  s(:call, nil, :lambda, s(:arglist)),
+                                  s(:masgn,
+                                    s(:array,
+                                      s(:lasgn, :x),
+                                      s(:lasgn, :y))),
+                                  s(:call, s(:lvar, :x), :+,
+                                    s(:arglist, s(:lvar, :y)))))
+
+  add_19tests("hash_new_with_keyword",
+              "Ruby"         => "{ true: 1, b: 2 }",
+              "RawParseTree" => [:hash,
+                                 [:lit, :true], [:lit, 1],
+                                 [:lit, :b], [:lit, 2]],
+              "ParseTree"    => s(:hash,
+                                  s(:lit, :true), s(:lit, 1),
+                                  s(:lit, :b), s(:lit, 2)))
+
   add_19tests("splat_fcall_middle",
               "Ruby"         => "meth(1, *[2], 3)",
               "RawParseTree" => [:fcall, :meth,

data/lib/sexp_processor.rb

@@ -34,7 +34,7 @@ require 'sexp'
 
 class SexpProcessor
 
-  VERSION = '3.0.7'
+  VERSION = '3.0.8'
 
   ##
   # Automatically shifts off the Sexp type before handing the

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sexp_processor
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 23
   prerelease: 
   segments: 
   - 3
   - 0
-  - 7
-  version: 3.0.7
+  - 8
+  version: 3.0.8
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2011-09-22 00:00:00 Z
+date: 2011-11-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rdoc
@@ -61,11 +61,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 13
         segments: 
         - 2
-        - 5
-        version: "2.5"
+        - 7
+        version: "2.7"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency