Hello community,

here is the log from the commit of package rubygem-sexp_processor for 
openSUSE:Factory checked in at 2015-06-12 20:30:40
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/rubygem-sexp_processor (Old)
 and      /work/SRC/openSUSE:Factory/.rubygem-sexp_processor.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "rubygem-sexp_processor"

Changes:
--------
--- 
/work/SRC/openSUSE:Factory/rubygem-sexp_processor/rubygem-sexp_processor.changes
    2015-05-02 21:34:39.000000000 +0200
+++ 
/work/SRC/openSUSE:Factory/.rubygem-sexp_processor.new/rubygem-sexp_processor.changes
       2015-06-12 20:30:41.000000000 +0200
@@ -1,0 +2,17 @@
+Fri May 29 04:34:42 UTC 2015 - co...@suse.com
+
+- updated to version 4.6.0
+ see installed History.txt
+
+  === 4.6.0 / 2015-05-28
+  
+  * 2 minor enhancements:
+  
+    * Extended generate_test to deal with 19 and up.
+    * Extended pt_testcase.rb so add_19tests means 19 and up.
+  
+  * 1 bug fix:
+  
+    * Added and normalized tests to deal with canonicalized block args from 
ruby_parser.
+
+-------------------------------------------------------------------

Old:
----
  sexp_processor-4.5.1.gem

New:
----
  sexp_processor-4.6.0.gem

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ rubygem-sexp_processor.spec ++++++
--- /var/tmp/diff_new_pack.iLvHB2/_old  2015-06-12 20:30:42.000000000 +0200
+++ /var/tmp/diff_new_pack.iLvHB2/_new  2015-06-12 20:30:42.000000000 +0200
@@ -24,7 +24,7 @@
 #
 
 Name:           rubygem-sexp_processor
-Version:        4.5.1
+Version:        4.6.0
 Release:        0
 %define mod_name sexp_processor
 %define mod_full_name %{mod_name}-%{version}

++++++ sexp_processor-4.5.1.gem -> sexp_processor-4.6.0.gem ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/History.txt new/History.txt
--- old/History.txt     2015-04-28 01:39:39.000000000 +0200
+++ new/History.txt     2015-05-28 23:47:41.000000000 +0200
@@ -1,3 +1,14 @@
+=== 4.6.0 / 2015-05-28
+
+* 2 minor enhancements:
+
+  * Extended generate_test to deal with 19 and up.
+  * Extended pt_testcase.rb so add_19tests means 19 and up.
+
+* 1 bug fix:
+
+  * Added and normalized tests to deal with canonicalized block args from 
ruby_parser.
+
 === 4.5.1 / 2015-04-27
 
 * 1 minor enhancement:
Files old/checksums.yaml.gz and new/checksums.yaml.gz differ
Files old/checksums.yaml.gz.sig and new/checksums.yaml.gz.sig differ
Files old/data.tar.gz.sig and new/data.tar.gz.sig differ
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/lib/pt_testcase.rb new/lib/pt_testcase.rb
--- old/lib/pt_testcase.rb      2015-04-28 01:39:39.000000000 +0200
+++ new/lib/pt_testcase.rb      2015-05-28 23:47:41.000000000 +0200
@@ -76,7 +76,7 @@
   end
 
   def self.add_19tests name, hash
-    add_tests "#{name}__19", hash
+    add_tests "#{name}__19_20_21_22", hash # HACK?
   end
 
   def self.add_19edgecases ruby, sexp, cases
@@ -101,15 +101,19 @@
     testcases[verbose][klass] = testcases[nonverbose][klass]
   end
 
+  VER_RE = "(1[89]|2[012])"
+
   def self.generate_test klass, node, data, input_name, output_name
     klass.send :define_method, "test_#{node}" do
       flunk "Processor is nil" if processor.nil?
 
-      if node =~ /(1[89]|2[01])$/ then
-        version = $1
+      tversions = node[/(?:_#{VER_RE})+$/]
+      if tversions then
+        cversion = self.class.name[/#{VER_RE}/]
+
         # can't push this up because it may be generating into an
         # abstract test class and the actual subclass is versioned.
-        return "version specific test" unless self.class.name =~ /#{version}/
+        return "version specific test" unless tversions.include? cversion if 
cversion
       end
 
       assert data.has_key?(input_name), "Unknown input data"
@@ -359,10 +363,16 @@
   add_19edgecases("lambda { || (x + 1) }",
                   s(:iter,
                     s(:call, nil, :lambda),
+                    s(:args),
+                    s(:call, s(:call, nil, :x), :+, s(:lit, 1))),
+                  "stabby_args"                   => "->() { (x + 1) }",
+                  "stabby_args_doend"             => "->() do (x + 1) end")
+
+  add_19edgecases("lambda { (x + 1) }",
+                  s(:iter,
+                    s(:call, nil, :lambda),
                     0,
                     s(:call, s(:call, nil, :x), :+, s(:lit, 1))),
-                  "stabby_args_0"                 => "->() { (x + 1) }",
-                  "stabby_args_0_doend"           => "->() do (x + 1) end",
                   "stabby_args_0_no_parens"       => "-> { (x + 1) }",
                   "stabby_args_0_no_parens_doend" => "-> do (x + 1) end",
                   "stabby_args_0_spacebar_broken" => "->{x+1}") # I hate you
@@ -813,7 +823,7 @@
             "Ruby"         => "a(b) do\n  if b then\n    true\n  else\n    c = 
false\n    d { |x| c = true }\n    c\n  end\nend",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :a, s(:call, nil, :b)),
-                                s(:args),
+                                0,
                                 s(:if,
                                   s(:call, nil, :b),
                                   s(:true),
@@ -970,14 +980,14 @@
             "Ruby"         => "loop { break if true }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :loop),
-                                s(:args),
+                                0,
                                 s(:if, s(:true), s(:break), nil)))
 
   add_tests("break_arg",
             "Ruby"         => "loop { break 42 if true }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :loop),
-                                s(:args),
+                                0,
                                 s(:if, s(:true), s(:break, s(:lit, 42)), nil)))
 
   add_tests("call",
@@ -1282,13 +1292,13 @@
             "Ruby"         => "a do\n  v = nil\n  assert_block(full_message) 
do\n    begin\n      yield\n    rescue Exception => v\n      break\n    end\n  
end\nend",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :a),
-                                s(:args),
+                                0,
                                 s(:block,
                                   s(:lasgn, :v, s(:nil)),
                                   s(:iter,
                                     s(:call, nil, :assert_block,
                                       s(:call, nil, :full_message)),
-                                    s(:args),
+                                    0,
                                     s(:rescue,
                                       s(:yield),
                                       s(:resbody,
@@ -1720,7 +1730,7 @@
             "Ruby"         => "a(:b) { :c }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :a, s(:lit, :b)),
-                                s(:args),
+                                0,
                                 s(:lit, :c)))
 
   add_tests("fcall_index_space",
@@ -1943,7 +1953,7 @@
 
   add_tests("iter_loop_empty",
             "Ruby"         => "loop { }",
-            "ParseTree"    => s(:iter, s(:call, nil, :loop), s(:args)))
+            "ParseTree"    => s(:iter, s(:call, nil, :loop), 0))
 
   add_tests("iter_masgn_2",
             "Ruby"         => "a { |b, c| p(c) }",
@@ -2181,7 +2191,7 @@
                                 s(:defn, :a, s(:args),
                                   s(:iter,
                                     s(:call, nil, :c),
-                                    s(:args),
+                                    0,
                                     s(:rescue,
                                       s(:call, nil, :do_stuff),
                                       s(:resbody,
@@ -2394,14 +2404,14 @@
             "Ruby"         => "loop { next if false }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :loop),
-                                s(:args),
+                                0,
                                 s(:if, s(:false), s(:next), nil)))
 
   add_tests("next_arg",
             "Ruby"         => "loop { next 42 if false }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :loop),
-                                s(:args),
+                                0,
                                 s(:if, s(:false), s(:next, s(:lit, 42)), nil)))
 
   add_tests("nth_ref",
@@ -2551,13 +2561,13 @@
 
   add_tests("postexe",
             "Ruby"         => "END { 1 }",
-            "ParseTree"    => s(:iter, s(:postexe), s(:args), s(:lit, 1)))
+            "ParseTree"    => s(:iter, s(:postexe), 0, s(:lit, 1)))
 
   add_tests("proc_args_0",
             "Ruby"         => "proc { || (x + 1) }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :proc),
-                                0,
+                                s(:args),
                                 s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
 
   add_tests("proc_args_1",
@@ -2578,14 +2588,14 @@
             "Ruby"         => "proc { (x + 1) }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :proc),
-                                s(:args),
+                                0,
                                 s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
 
   add_tests("redo",
             "Ruby"         => "loop { redo if false }",
             "ParseTree"    => s(:iter,
                                 s(:call, nil, :loop),
-                                s(:args),
+                                0,
                                 s(:if, s(:false), s(:redo), nil)))
 
   add_tests("rescue",  # TODO: need a resbody w/ multiple classes and a splat
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/lib/sexp_processor.rb new/lib/sexp_processor.rb
--- old/lib/sexp_processor.rb   2015-04-28 01:39:39.000000000 +0200
+++ new/lib/sexp_processor.rb   2015-05-28 23:47:41.000000000 +0200
@@ -33,7 +33,7 @@
 
 class SexpProcessor
 
-  VERSION = "4.5.1"
+  VERSION = "4.6.0"
 
   ##
   # Automatically shifts off the Sexp type before handing the
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/metadata new/metadata
--- old/metadata        2015-04-28 01:39:39.000000000 +0200
+++ new/metadata        2015-05-28 23:47:41.000000000 +0200
@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sexp_processor
 version: !ruby/object:Gem::Version
-  version: 4.5.1
+  version: 4.6.0
 platform: ruby
 authors:
 - Ryan Davis
@@ -29,7 +29,7 @@
   xJcC6UN6NHMOVMyAXsr2HR0gRRx4ofN1LoP2KhXzSr8UMvQYlwPmE0N5GQv1b5AO
   VpzF30vNaJK6ZT7xlIsIlwmH
   -----END CERTIFICATE-----
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -37,14 +37,14 @@
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '5.7'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
Files old/metadata.gz.sig and new/metadata.gz.sig differ


Reply via email to