serializable_proc 0.1.1 → 0.2.0

data/.gitignore

@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+tmp

data/HISTORY.txt

@@ -1,3 +1,12 @@
+=== 0.2.0 (Aug 18, 2010)
+
+* added SerializableProc#to_sexp to facilitate retrieving of sexp representation of the
+  code block [#ngty]
+* added support @@_not_isolated_vars, which allows fine-tuning of whether global, class,
+  instance or local variables should be isolated [#ngty]
+* fixed bug of block-scoped (eg. within 'def' block) variables being isolated [#ngty]
+* house-keeping, lots of reorganizing for specs [#ngty]
+
 === 0.1.1 (Aug 16, 2010)
 
 * acheived compatibility with MRI-1.8.6 [#ngty]

data/README.rdoc

@@ -12,9 +12,9 @@ A SerializableProc differs from the vanilla Proc in the following 2 ways:
 
 === 1. Isolated variables
 
-Upon initializing, all variables (local, instance, class & global) within its context
-are extracted from the proc's binding, and are isolated from changes outside the proc's
-scope, thus, achieving a snapshot effect.
+By default, upon initializing, all variables (local, instance, class & global) within its
+context are extracted from the proc's binding, and are isolated from changes outside the
+proc's scope, thus, achieving a snapshot effect.
 
   require 'rubygems'
   require 'serializable_proc'
@@ -29,6 +29,28 @@ scope, thus, achieving a snapshot effect.
   s_proc.call # >> "lx, ix, cx, gx"
   v_proc.call # >> "ly, iy, cy, gy"
 
+Sometimes, we may want global variables to behave as truely global, meaning we don't want
+to isolate globals at all, this can be done by declaring @@_not_isolated_vars within the
+code block:
+
+  s_proc = SerializableProc.new do
+    @@_not_isolated_vars = :global # globals won't be isolated
+    $stdout << "WakeUp !!"         # $stdout is the $stdout in the execution context
+  end
+
+The following declares all variables as not isolatable:
+
+  s_proc = SerializableProc.new do
+    @@_not_isolated_vars = :global, :class, :instance, :local
+    # (blah blah)
+  end
+
+When invoking, Kernel.binding should be passed in to avoid unpleasant surprises:
+
+  s_proc.call(binding)
+
+(take a look at SerializableProc's rdoc for more details)
+
 === 2. Marshallable
 
 No throwing of TypeError when marshalling a SerializableProc:
@@ -110,15 +132,11 @@ SerializableProc has been tested to work on the following rubies:
 
 == TODO (just brain-dumping)
 
-1. Provide flexibility for user to specify whether global variables should be isolated,
-   because globals are globals, it may sometimes be useful to use/manipulate the globals
-   within the context that the SerializableProc is called, instead of when it is
-   initialized
-2. The RubyParser-based implementation probably need alot more optimization to catch up
+1. The RubyParser-based implementation probably need alot more optimization to catch up
    on ParseTree-based one
-3. Implementing alternative means of extracting the code block without requiring help
+2. Implementing alternative means of extracting the code block without requiring help
    of ParseTree or RubyParser
-4. Implement workaround to tackle line-numbering bug in JRuby, which causes the
+3. Implement workaround to tackle line-numbering bug in JRuby, which causes the
    RubyParser-based implementation to fail, for more info abt JRuby's line-numbering
    bug, see http://stackoverflow.com/questions/3454838/jruby-line-numbering-problem &
    http://jira.codehaus.org/browse/JRUBY-5014

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/serializable_proc/binding.rb

@@ -4,51 +4,46 @@ class SerializableProc
 
   class Binding
 
+    include Isolatable
     include Marshalable
     marshal_attr :vars
 
     def initialize(binding, sexp)
-      @vars, sexp_str = {}, sexp.inspect
-      while m = sexp_str.match(/^(.*?s\(:(?:l|g|c|i)var, :([^\)]+)\))/)
-        ignore, var = m[1..2]
-        sexp_str.sub!(ignore,'')
-        begin
-          val = eval(var, binding) rescue nil
-          @vars.update(Sandboxer.fvar(var) => mclone(val))
-        rescue TypeError
-          raise CannotSerializeVariableError.new("Variable #{var} cannot be serialized !!")
+      sexp, @vars = sexp.gsub(s(:scope, s(:block, SexpAny.new)), nil), {}
+      types = isolated_types(sexp)
+      unless types.empty?
+        sexp_str = sexp.inspect
+        while m = sexp_str.match(/^(.*?s\(:(?:#{types.join('|')})var, :([^\)]+)\))/)
+          ignore, var = m[1..2]
+          sexp_str.sub!(ignore,'')
+          next unless isolatable?(var)
+          begin
+            val = eval(var, binding) rescue nil
+            @vars.update(isolated_var(var) => mclone(val))
+          rescue TypeError
+            raise CannotSerializeVariableError.new("Variable #{var} cannot be serialized !!")
+          end
         end
       end
     end
 
-    def eval!
-      @binding ||= (
-        set_vars = @vars.map{|(k,v)| "#{k} = Marshal.load(%|#{mdump(v)}|)" } * '; '
-        eval(set_vars, binding = Kernel.binding)
+    def eval!(binding = nil)
+      unless binding
+        @binding ||= (
+          eval(declare_vars, binding = Kernel.binding)
+          binding
+        )
+      else
+        eval(declare_vars, binding)
         binding
-        # binding.extend(Extensions)
-      )
+      end
     end
 
-    module Extensions
-      def self.extended(base)
-        class << base
+    private
 
-          alias_method :orig_eval, :eval
-
-          def eval(str)
-            begin
-              @fvar = Sandboxer.fvar(str).to_s
-              orig_eval(@fvar)
-            rescue NameError => e
-              msg = e.message.sub(@fvar, str)
-              raise NameError.new(msg)
-            end
-          end
-
-        end
+      def declare_vars
+        @declare_vars ||= @vars.map{|(k,v)| "#{k} = Marshal.load(%|#{mdump(v)}|)" } * '; '
       end
-    end
 
   end
 end

data/lib/serializable_proc/fixes.rb

@@ -1,7 +1,7 @@
 # NOTE: This file contains hackeries to ensure compatibility with different rubies
 
 unless 1.respond_to?(:pred)
-  class Integer
+  class Integer #:nodoc:
     def pred
       self - 1
     end

data/lib/serializable_proc/isolatable.rb

@@ -0,0 +1,59 @@
+class SerializableProc
+  module Isolatable
+
+    protected
+
+      def isolated_sexp(sexp)
+        # TODO: This nasty mess needs some loving touch !!
+        block_replace = :_serializable_proc_block_scope_marker_
+        t_sexp = sexp.gsub(s(:scope, s(:block, SexpAny.new)), block_replace)
+        blocks_pattern = %r{^#{Regexp.quote(t_sexp.inspect).gsub(block_replace.inspect,'(.*?)')}$}
+        blocks = sexp.inspect.match(blocks_pattern)[1..-1] rescue []
+        n_sexp_str = nil
+
+        unless (types = isolated_types(sexp)).empty?
+          var_pattern = /^(.*?s\(:)((#{types.join('|')})(asgn|var|vdecl))(,\ :)((|@|@@|\$)([\w]+))(\)|,)/
+          t_sexp_str = t_sexp.inspect
+
+          while m = t_sexp_str.match(var_pattern)
+            orig, prepend, _, type, declare, join, var, _, name, append = m[0..-1]
+            n_sexp_str = isolatable?(var) ?
+              "#{n_sexp_str}#{prepend}l#{declare.sub('vdecl','asgn')}#{join}#{type}var_#{name}#{append}" :
+              "#{n_sexp_str}#{orig}"
+            t_sexp_str.sub!(orig,'')
+          end
+
+          n_sexp_str = n_sexp_str.nil? ? nil :
+            blocks.inject("#{n_sexp_str}#{t_sexp_str}") do |sexp_str, block_str|
+              sexp_str.sub(block_replace.inspect, block_str)
+            end
+        end
+
+        eval(n_sexp_str ? n_sexp_str : sexp.inspect)
+      end
+
+      def isolated_var(var)
+        @translate_var_maps ||= {'@' => 'ivar_', '@@' => 'cvar_', '$' => 'gvar_', '' => 'lvar_'}
+        m = var.to_s.match(/^(|@|@@|\$)(\w+)$/)
+        var.to_s.sub(m[1], @translate_var_maps[m[1]]).to_sym
+      end
+
+      def isolated_types(sexp)
+        o_sexp_arry = sexp.to_a
+        n_sexp = sexp.gsub(s(:cvdecl, :@@_not_isolated_vars, SexpAny.new), nil)
+        types = %w{global instance local class}
+
+        if (diff = o_sexp_arry - n_sexp.to_a).empty?
+          types.map{|t| t[0].chr }
+        else
+          sexp_str = Sexp.from_array(diff).inspect
+          types.map{|t| t[0].chr unless sexp_str.include?("s(:lit, :#{t})") }.compact
+        end
+      end
+
+      def isolatable?(var)
+        var != '@@_not_isolated_vars'
+      end
+
+  end
+end

data/lib/serializable_proc/parsers/pt.rb

@@ -1,13 +1,10 @@
 class SerializableProc
   module Parsers
-    module PT
+    class PT < Base
       class << self
         def process(block)
           if Object.const_defined?(:ParseTree)
-            sexp = block.to_sexp
-            runnable_code = RUBY_2_RUBY.process(Sandboxer.fsexp(sexp))
-            extracted_code = RUBY_2_RUBY.process(eval(sexp.inspect))
-            [{:runnable => runnable_code, :extracted => extracted_code}, sexp]
+            sexp_derivatives(block.to_sexp)
           end
         end
       end

data/lib/serializable_proc/parsers/rp.rb

@@ -3,7 +3,7 @@ class SerializableProc
   class CannotAnalyseCodeError < Exception ; end
 
   module Parsers
-    module RP
+    class RP < Base
       class << self
 
         def process(klass, file, line)
@@ -15,47 +15,46 @@ class SerializableProc
         private
 
           def extract_code_and_sexp
-            sexp_str, remaining, type, marker = extract_sexp_args
+            sexp_str, remaining, @marker = extract_sexp_args
             while frag = remaining[/^([^\)]*\))/,1]
               begin
-                sexp = eval(sexp_str += frag) # this throws SyntaxError if sexp is invalid
-                runnable_code, extracted_code = [
-                  RUBY_2_RUBY.process(Sandboxer.fsexp(sexp)),
-                  RUBY_2_RUBY.process(eval(sexp.inspect))
-                ].map do |code|
-                  unescape_magic_vars(code).sub(/#{marker}\s*;?/m,'').sub(type,'lambda')
-                end
-                return [{:runnable => runnable_code, :extracted => extracted_code}, sexp]
+                sexp = normalized_eval(sexp_str += frag)
+                return sexp_derivatives(sexp){|code| unescape_magic_vars(code) }
               rescue SyntaxError
                 remaining.sub!(frag,'')
               end
             end
           end
 
-          def extract_sexp_args
-            raw, type, marker = raw_sexp_and_marker
-            rq = lambda{|s| Regexp.quote(s) }
-            regexp = Regexp.new([
-              '^(.*(', (
-                case type
-                when /(#{@klass}|Proc)/ then rq["s(:iter, s(:call, s(:const, :#{$1}), :new, s(:arglist)),"]
-                else rq['s(:iter, s(:call, nil, :'] + '(?:proc|lambda)' + rq[', s(:arglist']
-                end
-              ),
-              '.*?',
-              rq["s(:call, nil, :#{marker}, s(:arglist))"],
-              '))(.*)$'
-            ].join, Regexp::MULTILINE)
-            [raw.match(regexp)[2..3], type, marker].flatten
+          def normalized_eval(sexp_str)
+            sexp = eval(sexp_str) # this will fail unless the sexp is valid
+            sexp.delete(marker_sexp = s(:call, nil, :"#{@marker}", s(:arglist)))
+            sexp.find_node(:block).delete(marker_sexp) rescue nil
+            if (block = sexp.find_node(:block)) && block.to_a.size == 2
+              sexp.gsub(block, Sexp.from_array(block.to_a[1]))
+            else
+              sexp
+            end
           end
 
+          def extract_sexp_args
+            raw, marker = raw_sexp_and_marker
+            regexp = Regexp.new(
+              '^(.*(' + Regexp.quote('s(:iter, s(:call, nil, :') +
+              '(?:proc|lambda)' + Regexp.quote(', s(:arglist') +
+              '.*?' + Regexp.quote("s(:call, nil, :#{marker}, s(:arglist))") +
+              '))(.*)$', Regexp::MULTILINE
+            )
+            [raw.match(regexp)[2..3], marker].flatten
+          end
 
           def raw_sexp_and_marker
+            # TODO: Ugly chunk, need some lovely cleanup !!
             %W{#{@klass}\.new lambda|proc|Proc\.new}.each do |declarative|
-              regexp = /^(.*?(#{declarative})\s*(do|\{)\s*(\|([^\|]*)\|\s*)?)/
+              regexp = /^((.*?)(#{declarative})(\s*(?:do|\{)\s*(?:\|(?:[^\|]*)\|\s*)?)(.*)?)$/m
               raw = raw_code
               lines1, lines2 = [(0 .. (@line - 2)), (@line.pred .. -1)].map{|r| raw[r] }
-              match, type = lines2[0].match(regexp)[1..2] rescue next
+              prepend, type, block_start, append = lines2[0].match(regexp)[2..5] rescue next
 
               if lines2[0] =~ /^(.*?\W)?(#{declarative})(\W.*?\W(#{declarative}))+(\W.*)?$/
                 msg = "Static code analysis can only handle single occurrence of '%s' per line !!" %
@@ -63,8 +62,9 @@ class SerializableProc
                 raise CannotAnalyseCodeError.new(msg)
               elsif lines2[0] =~ /^(.*?\W)?(#{declarative})(\W.*)?$/
                 marker = "__serializable_proc_marker_#{@line}__"
-                lines = lines1.join + escape_magic_vars(lines2[0].sub(match, match+marker+';') + lines2[1..-1].join)
-                return [RUBY_PARSER.parse(lines).inspect, type, marker]
+                line = "#{prepend}proc#{block_start} #{marker}; #{append}"
+                lines = lines1.join + escape_magic_vars(line + lines2[1..-1].join)
+                return [RUBY_PARSER.parse(lines).inspect, marker]
               end
             end
             raise CannotAnalyseCodeError.new('Cannot find specified initializer !!')

data/lib/serializable_proc/parsers.rb

@@ -1,6 +1,28 @@
 class SerializableProc
   module Parsers
+
     RUBY_2_RUBY = Ruby2Ruby.new
+
+    class Base
+      class << self
+
+        include Isolatable
+
+        def sexp_derivatives(sexp, &fix_code)
+          isexp = isolated_sexp(sexp)
+          icode, code = [isexp, sexp].map do |_sexp|
+            code = RUBY_2_RUBY.process(Sexp.from_array(_sexp.to_a))
+            block_given? ? fix_code.call(code) : code
+          end
+          [
+            {:runnable => icode, :extracted => code},
+            {:runnable => isexp, :extracted => sexp}
+          ]
+        end
+
+      end
+    end
+
   end
 end
 

data/lib/serializable_proc.rb

@@ -2,9 +2,9 @@ require 'rubygems'
 require 'forwardable'
 require 'ruby2ruby'
 require 'serializable_proc/marshalable'
+require 'serializable_proc/isolatable'
 require 'serializable_proc/parsers'
 require 'serializable_proc/binding'
-require 'serializable_proc/sandboxer'
 require 'serializable_proc/fixes'
 
 begin
@@ -19,9 +19,9 @@ end
 #
 # #1. Isolated variables
 #
-# Upon initializing, all variables (local, instance, class & global) within its context
-# are extracted from the proc's binding, and are isolated from changes outside the
-# proc's scope, thus, achieving a snapshot effect.
+# By default, upon initializing, all variables (local, instance, class & global) within
+# its context are extracted from the proc's binding, and are isolated from changes
+# outside the proc's scope, thus, achieving a snapshot effect.
 #
 #   require 'rubygems'
 #   require 'serializable_proc'
@@ -36,6 +36,24 @@ end
 #   s_proc.call # >> "lx, ix, cx, gx"
 #   v_proc.call # >> "ly, iy, cy, gy"
 #
+# It is possible to fine-tune how variables isolation is being applied by declaring
+# @@_not_isolated_vars within the code block:
+#
+#   x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'
+#
+#   s_proc = SerializableProc.new do
+#     @@_not_isolated_vars = :global, :class, :instance, :local
+#     [x, @x, @@x, $x].join(', ')
+#   end
+#
+#   x, @x, @@x, $x = 'ly', 'iy', 'cy', 'gy'
+#
+#   # Passing Kernel.binding is required to avoid nasty surprises
+#   s_proc.call(binding) # >> "ly, iy, cy, gy"
+#
+# Note that it is strongly-advised to append Kernel.binding as the last parameter when
+# invoking the proc to avoid unnecessary nasty surprises.
+#
 # #2. Marshallable
 #
 # No throwing of TypeError when marshalling a SerializableProc:
@@ -46,7 +64,7 @@ end
 class SerializableProc
 
   include Marshalable
-  marshal_attrs :file, :line, :code, :arity, :binding
+  marshal_attrs :file, :line, :code, :arity, :binding, :sexp
 
   ##
   # Creates a new instance of SerializableProc by passing in a code block, in the process,
@@ -64,11 +82,21 @@ class SerializableProc
   #   def action(&block) ; SerializableProc.new(&block) ; end
   #   action { ... }
   #
+  # Fine-tuning of variables isolation can be done by declaring @@_not_isolated_vars
+  # within the code block:
+  #
+  #   SerializableProc.new do
+  #     @@_not_isolated_vars = :global # don't isolate globals
+  #     $stdout << 'WAKE UP !!'        # $stdout won't be isolated (avoid marshal error)
+  #   end
+  #
+  # (see #call for invoking)
+  #
   def initialize(&block)
     file, line = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(block.inspect)[1..2]
     @file, @line, @arity = File.expand_path(file), line.to_i, block.arity
-    @code, sexp = Parsers::PT.process(block) || Parsers::RP.process(self.class, @file, @line)
-    @binding = Binding.new(block.binding, sexp)
+    @code, @sexp = Parsers::PT.process(block) || Parsers::RP.process(self.class, @file, @line)
+    @binding = Binding.new(block.binding, @sexp[:extracted])
   end
 
   ##
@@ -103,8 +131,12 @@ class SerializableProc
   #   def action(&block) ; yield ; end
   #   action(&s_proc) # >> 'lx, ix, cx, gx'
   #
-  def to_proc
-    @proc ||= eval(@code[:runnable], @binding.eval!, @file, @line)
+  def to_proc(binding = nil)
+    if binding
+      eval(@code[:runnable], @binding.eval!(binding), @file, @line)
+    else
+      @proc ||= eval(@code[:runnable], @binding.eval!, @file, @line)
+    end
   end
 
   ##
@@ -131,6 +163,16 @@ class SerializableProc
     @code[debug ? :runnable : :extracted]
   end
 
+  ##
+  # Returns the sexp representation of this instance. By default, the sexp represents the
+  # extracted code, if +debug+ specified as true, the runnable code version is returned.
+  #
+  #   SerializableProc.new { [x, @x, @@x, $x].join(', ') }.to_sexp
+  #
+  def to_sexp(debug = false)
+    @sexp[debug ? :runnable : :extracted]
+  end
+
   ##
   # Returns the number of arguments accepted when running #call. This is extracted directly
   # from the initializing code block, & is only as accurate as Proc#arity.
@@ -157,8 +199,32 @@ class SerializableProc
   #   SerializableProc.new{|i| (['hello'] * i).join(' ') }.call(2)
   #   # >> 'hello hello'
   #
+  # In the case where variables have been declared not-isolated with @@_not_isolated_vars,
+  # invoking requires passing in +Kernel.binding+ as the last parameter avoid unexpected
+  # surprises:
+  #
+  #   x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'
+  #   s_proc = SerializableProc.new do
+  #     @@_not_isolated_vars = :global, :class, :instance, :local
+  #     [x, @x, @@x, $x].join(', ')
+  #   end
+  #
+  #   s_proc.call
+  #   # >> raises NameError for x
+  #   # >> @x is assumed nil (undefined)
+  #   # >> raises NameError for @@x (actually this depends on if u are using 1.9.* or 1.8.*)
+  #   # >> no issue with $x (since global is, after all, a global)
+  #
+  # To ensure expected results:
+  #
+  #   s_proc.call(binding) # >> 'lx, ix, cx, gx'
+  #
   def call(*params)
-    to_proc.call(*params)
+    if (binding = params[-1]).is_a?(::Binding)
+      to_proc(binding).call(*params[0..-2])
+    else
+      to_proc.call(*params)
+    end
   end
 
   alias_method :[], :call

data/serializable_proc.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{serializable_proc}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["NgTzeYang"]
-  s.date = %q{2010-08-16}
+  s.date = %q{2010-08-18}
   s.description = %q{
       Give & take, serializing a ruby proc is possible, though not a perfect one.
       Requires either ParseTree (faster) or RubyParser (& Ruby2Ruby).
@@ -30,21 +30,36 @@ Gem::Specification.new do |s|
      "lib/serializable_proc.rb",
      "lib/serializable_proc/binding.rb",
      "lib/serializable_proc/fixes.rb",
+     "lib/serializable_proc/isolatable.rb",
      "lib/serializable_proc/marshalable.rb",
      "lib/serializable_proc/parsers.rb",
      "lib/serializable_proc/parsers/pt.rb",
      "lib/serializable_proc/parsers/rp.rb",
-     "lib/serializable_proc/sandboxer.rb",
      "serializable_proc.gemspec",
-     "spec/extracting_bound_variables_spec.rb",
-     "spec/initializing_errors_spec.rb",
-     "spec/marshalling_spec.rb",
-     "spec/multiple_arities_serializable_proc_spec.rb",
-     "spec/one_arity_serializable_proc_spec.rb",
-     "spec/optional_arity_serializable_proc_spec.rb",
-     "spec/proc_like_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/zero_arity_serializable_proc_spec.rb"
+     "spec/bounded_vars/class_vars_spec.rb",
+     "spec/bounded_vars/class_vars_within_block_scope_spec.rb",
+     "spec/bounded_vars/errors_spec.rb",
+     "spec/bounded_vars/global_vars_spec.rb",
+     "spec/bounded_vars/global_vars_within_block_scope_spec.rb",
+     "spec/bounded_vars/instance_vars_spec.rb",
+     "spec/bounded_vars/instance_vars_within_block_scope_spec.rb",
+     "spec/bounded_vars/local_vars_spec.rb",
+     "spec/bounded_vars/local_vars_within_block_scope_spec.rb",
+     "spec/code_block/errors_spec.rb",
+     "spec/code_block/multiple_arities_spec.rb",
+     "spec/code_block/optional_arity_spec.rb",
+     "spec/code_block/renaming_vars_spec.rb",
+     "spec/code_block/single_arity_spec.rb",
+     "spec/code_block/zero_arity_spec.rb",
+     "spec/proc_like/extras_spec.rb",
+     "spec/proc_like/invoking_with_args_spec.rb",
+     "spec/proc_like/invoking_with_class_vars_spec.rb",
+     "spec/proc_like/invoking_with_global_vars_spec.rb",
+     "spec/proc_like/invoking_with_instance_vars_spec.rb",
+     "spec/proc_like/invoking_with_local_vars_spec.rb",
+     "spec/proc_like/marshalling_spec.rb",
+     "spec/proc_like/others_spec.rb",
+     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/ngty/serializable_proc}
   s.post_install_message = %q{
@@ -67,15 +82,30 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Proc that can be serialized (as the name suggests)}
   s.test_files = [
-    "spec/initializing_errors_spec.rb",
-     "spec/extracting_bound_variables_spec.rb",
-     "spec/one_arity_serializable_proc_spec.rb",
-     "spec/zero_arity_serializable_proc_spec.rb",
-     "spec/multiple_arities_serializable_proc_spec.rb",
-     "spec/marshalling_spec.rb",
-     "spec/optional_arity_serializable_proc_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/proc_like_spec.rb"
+    "spec/proc_like/extras_spec.rb",
+     "spec/proc_like/invoking_with_local_vars_spec.rb",
+     "spec/proc_like/invoking_with_instance_vars_spec.rb",
+     "spec/proc_like/invoking_with_class_vars_spec.rb",
+     "spec/proc_like/invoking_with_args_spec.rb",
+     "spec/proc_like/others_spec.rb",
+     "spec/proc_like/invoking_with_global_vars_spec.rb",
+     "spec/proc_like/marshalling_spec.rb",
+     "spec/code_block/multiple_arities_spec.rb",
+     "spec/code_block/zero_arity_spec.rb",
+     "spec/code_block/errors_spec.rb",
+     "spec/code_block/renaming_vars_spec.rb",
+     "spec/code_block/single_arity_spec.rb",
+     "spec/code_block/optional_arity_spec.rb",
+     "spec/bounded_vars/global_vars_within_block_scope_spec.rb",
+     "spec/bounded_vars/instance_vars_within_block_scope_spec.rb",
+     "spec/bounded_vars/errors_spec.rb",
+     "spec/bounded_vars/local_vars_within_block_scope_spec.rb",
+     "spec/bounded_vars/class_vars_spec.rb",
+     "spec/bounded_vars/local_vars_spec.rb",
+     "spec/bounded_vars/global_vars_spec.rb",
+     "spec/bounded_vars/instance_vars_spec.rb",
+     "spec/bounded_vars/class_vars_within_block_scope_spec.rb",
+     "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then