serializable_proc 0.3.1 → 0.4.0

data/spec/proc_like/invoking_with_args_spec.rb

@@ -11,7 +11,9 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
       end
 
       should 'return yield result given single arg' do
-        s_proc = SerializableProc.new {|i| %w{b c}.map{|x| x*i } }
+        s_proc = SerializableProc.new do |i|
+          %w{b c}.map{|x| x*i }
+        end
         s_proc.send(invoke, 2).should.equal(%w{bb cc})
       end
 
@@ -37,7 +39,9 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
       should 'return yield result given single arg' do
         x = 'a'
-        s_proc = SerializableProc.new {|i| %w{b c}.map{|x| x*i } }
+        s_proc = SerializableProc.new do |i|
+          %w{b c}.map{|x| x*i }
+        end
         s_proc.send(invoke, 2, binding).should.equal(%w{bb cc})
       end
 

data/spec/proc_like/others_spec.rb

@@ -76,13 +76,19 @@ describe 'Being proc like' do
   end
 
   describe '>> arity' do
+    block1 = lambda { }
+    block2 = lambda {|x| }
+    block3 = lambda {|x,y| }
+    block4 = lambda {|*x| }
+    block5 = lambda {|x, *y| }
+    block6 = lambda {|(x,y)| }
     {
-      __LINE__ => lambda { },
-      __LINE__ => lambda {|x| },
-      __LINE__ => lambda {|x,y| },
-      __LINE__ => lambda {|*x| },
-      __LINE__ => lambda {|x, *y| },
-      __LINE__ => lambda {|(x,y)| },
+      __LINE__ => block1,
+      __LINE__ => block2,
+      __LINE__ => block3,
+      __LINE__ => block4,
+      __LINE__ => block5,
+      __LINE__ => block6,
     }.each do |debug, block|
       should "return arity of initializing block [##{debug}]" do
         SerializableProc.new(&block).arity.should.equal(block.arity)
@@ -92,7 +98,9 @@ describe 'Being proc like' do
 
   describe '>> binding' do
     should 'raise NotImplementedError' do
-      lambda { SerializableProc.new { x }.binding }.should.raise(NotImplementedError)
+      lambda {
+        SerializableProc.new { x }.binding
+      }.should.raise(NotImplementedError)
     end
     # should 'return binding that contains duplicated contextual reference values' do
     #   x, @x, @@x, $x = 'lx', 'ix', 'cx', 'gx'

data/spec/spec_helper.rb

@@ -2,15 +2,7 @@ require 'rubygems'
 require 'bacon'
 require 'tempfile'
 require 'ruby2ruby'
-
-$parse_tree_installed =
-  begin
-    require 'parse_tree'
-    true
-  rescue LoadError
-    require 'ruby_parser'
-    nil
-  end
+require 'ruby_parser'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -20,7 +12,7 @@ Bacon.summary_on_exit
 
 class SerializableProc
 
-  attr_reader :code, :file, :line
+  attr_reader :codes, :file, :line
 
   def binding_dump
     @binding.instance_variable_get(:@vars)
@@ -32,16 +24,14 @@ class SerializableProc
 
       def having_same_semantics_as(code2)
         to_code = lambda{|sexp| ::Ruby2Ruby.new.process(sexp) }
-        to_sexp = $parse_tree_installed ?
-          lambda{|code| Unifier.new.process(::ParseTree.translate(code)) } :
-          lambda{|code| ::RubyParser.new.parse(code) }
+        to_sexp = lambda{|code| RubyParser.new.parse(code) }
         normalize = lambda{|code| to_code[to_sexp[code]].sub('lambda','proc') }
         lambda {|code1| normalize[code1].should.equal(normalize[code2]) }
       end
 
       def having_runnable_code_as(code)
         lambda do |s_proc|
-          s_proc.code[:runnable].should.be having_same_semantics_as(code)
+          s_proc.codes[:runnable].should.be having_same_semantics_as(code)
         end
       end
 
@@ -51,7 +41,7 @@ class SerializableProc
 
       def having_expected_proc_attrs(file, line, code)
         lambda do |s_proc|
-          s_proc.code[:runnable].should.be having_same_semantics_as(code)
+          s_proc.codes[:runnable].should.be having_same_semantics_as(code)
           s_proc.file.should.equal(file)
           s_proc.line.should.equal(line)
         end
@@ -92,7 +82,7 @@ class SerializableProc
         test_args.each do |line, block|
           should "handle proc variable [##{line}]" do
             s_proc = SerializableProc.new(&block)
-            s_proc.code[:runnable].should.be having_same_semantics_as(code)
+            s_proc.codes[:runnable].should.be having_same_semantics_as(code)
             s_proc.file.should.equal(file)
             s_proc.line.should.equal(line.succ)
           end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: serializable_proc
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - NgTzeYang
@@ -15,29 +15,62 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-18 00:00:00 +08:00
+date: 2010-09-15 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: ruby2ruby
+  name: sourcify
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 85
         segments: 
-        - 1
+        - 0
         - 2
-        - 4
-        version: 1.2.4
+        - 2
+        - 1
+        version: 0.2.2.1
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: bacon
+  name: ruby2ruby
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 2
+        - 5
+        version: 1.2.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sexp_processor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 3
+        - 0
+        - 5
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -47,8 +80,8 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id002
-description: "\n      Give & take, serializing a ruby proc is possible, though not a perfect one.\n      Requires either ParseTree (faster) or RubyParser (& Ruby2Ruby).\n    "
+  version_requirements: *id004
+description: "\n      Give & take, serializing a ruby proc is possible, though not a perfect one (yet).\n    "
 email: ngty77@gmail.com
 executables: []
 
@@ -70,9 +103,6 @@ files:
 - lib/serializable_proc/fixes.rb
 - lib/serializable_proc/isolatable.rb
 - lib/serializable_proc/marshalable.rb
-- lib/serializable_proc/parsers.rb
-- lib/serializable_proc/parsers/dynamic.rb
-- lib/serializable_proc/parsers/static.rb
 - serializable_proc.gemspec
 - spec/bounded_vars/class_vars_spec.rb
 - spec/bounded_vars/class_vars_within_block_scope_spec.rb
@@ -83,22 +113,8 @@ files:
 - 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/magic_vars_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/extending/new_matcher_w_multiple_arities_spec.rb
-- spec/extending/new_matcher_w_optional_arity_spec.rb
-- spec/extending/new_matcher_w_single_arity_spec.rb
-- spec/extending/new_matcher_w_zero_arity_spec.rb
-- spec/extending/spec_helper.rb
-- spec/extending/subclassing_w_multiple_arities_spec.rb
-- spec/extending/subclassing_w_optional_arity_spec.rb
-- spec/extending/subclassing_w_single_arity_spec.rb
-- spec/extending/subclassing_w_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
@@ -112,7 +128,7 @@ has_rdoc: true
 homepage: http://github.com/ngty/serializable_proc
 licenses: []
 
-post_install_message: "\n /////////////////////////////////////////////////////////////////////////////////\n\n  ** SerializableProc **\n\n  You are installing SerializableProc on a ruby platform & version that supports\n  ParseTree. With ParseTree, u can enjoy better performance of SerializableProc,\n  as well as other dynamic code analysis goodness, as compared to the default\n  implementation using RubyParser's less flexible static code analysis.\n\n  Anyway, u have been informed, SerializableProc will fallback on its default\n  implementation using RubyParser.\n\n /////////////////////////////////////////////////////////////////////////////////\n      "
+post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
 require_paths: 
@@ -152,21 +168,7 @@ test_files:
 - spec/proc_like/invoking_with_global_vars_spec.rb
 - spec/proc_like/marshalling_spec.rb
 - spec/code_block/magic_vars_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/extending/subclassing_w_optional_arity_spec.rb
-- spec/extending/subclassing_w_single_arity_spec.rb
-- spec/extending/new_matcher_w_multiple_arities_spec.rb
-- spec/extending/subclassing_w_zero_arity_spec.rb
-- spec/extending/new_matcher_w_single_arity_spec.rb
-- spec/extending/subclassing_w_multiple_arities_spec.rb
-- spec/extending/new_matcher_w_optional_arity_spec.rb
-- spec/extending/new_matcher_w_zero_arity_spec.rb
-- spec/extending/spec_helper.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

data/lib/serializable_proc/parsers/dynamic.rb

@@ -1,13 +0,0 @@
-class SerializableProc
-  module Parsers
-    class Dynamic < Base
-      class << self
-        def process(block)
-          if Object.const_defined?(:ParseTree)
-            sexp_derivatives(block.to_sexp)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serializable_proc/parsers/static.rb

@@ -1,103 +0,0 @@
-class SerializableProc
-
-  class CannotAnalyseCodeError < Exception ; end
-
-  module Parsers
-    class Static < Base
-      class << self
-
-        def process(klass, file, line)
-          const_set(:RUBY_PARSER, RubyParser.new) unless const_defined?(:RUBY_PARSER)
-          @klass, @file, @line = klass, file, line
-          extract_code_and_sexp
-        end
-
-        def matchers
-          @matchers ||= []
-        end
-
-        private
-
-          def extract_code_and_sexp
-            sexp_str, remaining, @marker = extract_sexp_args
-            while frag = remaining[/^([^\)]*\))/,1]
-              begin
-                sexp = normalized_eval(sexp_str += frag)
-                return sexp_derivatives(sexp)
-              rescue SyntaxError
-                remaining.sub!(frag,'')
-              end
-            end
-          end
-
-          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
-            begin
-              raw_sexp_and_marker_by_lineno(@line)
-            rescue CannotAnalyseCodeError
-              # NOTE: Tmp fix for JRuby's buggy line-numbering within Proc#inspect
-              RUBY_PLATFORM =~ /java/i ? (@line += 1 ; retry) : raise($!)
-            ensure
-              @raw_code = nil
-            end
-          end
-
-          def raw_sexp_and_marker_by_lineno(lineno)
-            (%W{#{@klass}\.new lambda|proc|Proc\.new} + matchers).each do |declarative|
-              ensure_no_repeated_occurrence(lineno, declarative)
-              args = raw_sexp_and_marker_args(lineno, declarative) and return args
-            end
-            raise CannotAnalyseCodeError.new('Cannot find specified initializer !!')
-          end
-
-          def ensure_no_repeated_occurrence(lineno, declarative)
-            if raw_code[lineno.pred] =~ /^(.*?\W)?(#{declarative})(\W.*?\W(#{declarative}))+(\W.*)?$/
-              msg = "Static code analysis can only handle single occurrence of '%s' per line !!" %
-                declarative.split('|').join("'/'")
-              raise CannotAnalyseCodeError.new(msg)
-            end
-          end
-
-          def raw_sexp_and_marker_args(lineno, declarative)
-            begin
-              raise if (line = raw_code[lineno.pred]) !~ /^(.*?\W)?(#{declarative})(\W.*)?$/
-              regexp = /^((.*?)(#{declarative})(\s*(?:do|\{)\s*(?:\|(?:[^\|]*)\|\s*)?)(.*)?)$/m
-              prepend, type, block_start, append = line.match(regexp)[2..5]
-              marker = "__serializable_proc_marker_#{lineno}__"
-              raw_code[lineno.pred] = "#{prepend}proc#{block_start} #{marker}; #{append}"
-              [RUBY_PARSER.parse(raw_code.join, @file).inspect, marker]
-            rescue
-              nil
-            end
-          end
-
-          def raw_code
-            @raw_code ||= File.readlines(@file)
-          end
-
-      end
-    end
-  end
-end
-

data/lib/serializable_proc/parsers.rb

@@ -1,30 +0,0 @@
-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
-
-require 'serializable_proc/parsers/dynamic'
-require 'serializable_proc/parsers/static'

data/spec/code_block/errors_spec.rb

@@ -1,65 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe 'SerializableProc::CannotAnalyseCodeError' do
-  unless $parse_tree_installed
-
-    extend SerializableProc::Spec::Helpers
-
-    should "raise if line has more than 1 'SerializableProc.new'" do
-      lambda {
-        SerializableProc.new {} ; SerializableProc.new { |arg| %w{a b}.map{|x| puts x } }
-      }.should.be raising_cannot_analyse_error("'SerializableProc.new'")
-    end
-
-    should "raise if line has more than 1 'Proc.new'" do
-      lambda {
-        p1 = Proc.new {} ; p2 = Proc.new { |arg| %w{a b}.map{|x| puts x } }
-        SerializableProc.new(&p2)
-      }.should.be raising_cannot_analyse_error("'lambda'/'proc'/'Proc.new'")
-    end
-
-    should "raise if line has more than 1 'lambda'" do
-      lambda {
-        p1 = lambda {} ; p2 = lambda { |arg| %w{a b}.map{|x| puts x } }
-        SerializableProc.new(&p2)
-      }.should.be raising_cannot_analyse_error("'lambda'/'proc'/'Proc.new'")
-    end
-
-    should "raise if line has more than 1 'proc'" do
-      lambda {
-        p1 = proc {} ; p2 = proc { |arg| %w{a b}.map{|x| puts x } }
-        SerializableProc.new(&p2)
-      }.should.be raising_cannot_analyse_error("'lambda'/'proc'/'Proc.new'")
-    end
-
-    should "raise if line mixes 'lambda' & 'proc'" do
-      lambda {
-        p1 = lambda {} ; p2 = proc { |arg| %w{a b}.map{|x| puts x } }
-        SerializableProc.new(&p2)
-      }.should.be raising_cannot_analyse_error("'lambda'/'proc'/'Proc.new'")
-    end
-
-    should "raise if line mixes 'Proc.new' & 'proc'" do
-      lambda {
-        p1 = Proc.new {} ; p2 = proc { |arg| %w{a b}.map{|x| puts x } }
-        SerializableProc.new(&p2)
-      }.should.be raising_cannot_analyse_error("'lambda'/'proc'/'Proc.new'")
-    end
-
-    should "raise if line mixes 'Proc.new' & 'lambda'" do
-      lambda {
-        p1 = Proc.new {} ; p2 = lambda { |arg| %w{a b}.map{|x| puts x } }
-        SerializableProc.new(&p2)
-      }.should.be raising_cannot_analyse_error("'lambda'/'proc'/'Proc.new'")
-    end
-
-    should "raise if line does not have lambda, proc, Proc.new or SerializableProc.new" do
-      lambda {
-        def create_serializable_proc(&block) ; SerializableProc.new(&block) ; end
-        create_serializable_proc { %w{a b}.map{|x| puts x } }
-      }.should.raise(SerializableProc::CannotAnalyseCodeError).
-        message.should.equal('Cannot find specified initializer !!')
-    end
-
-  end
-end

data/spec/code_block/multiple_arities_spec.rb

@@ -1,159 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe 'Extracting multiple arities code block' do
-
-  extend SerializableProc::Spec::Helpers
-
-  expected_file = File.expand_path(__FILE__)
-  expected_code = "lambda { |lvar_arg1, lvar_arg2| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
-
-  should_handle_proc_variable expected_file, expected_code, {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |arg1, arg2|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda { |arg1, arg2|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        proc do |arg1, arg2|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        lambda { |arg1, arg2|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-      __LINE__ =>
-        Proc.new do |arg1, arg2|
-          %w{a b}.map do |x|
-            puts x
-          end
-        end,
-      __LINE__ =>
-        Proc.new { |arg1, arg2|
-          %w{a b}.map{|x|
-            puts x
-          }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |arg1, arg2|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda { |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        proc do |arg1, arg2|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        lambda { |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        },
-      __LINE__ =>
-        Proc.new do |arg1, arg2|
-          %w{a b}.map do |x| puts x end
-        end,
-      __LINE__ =>
-        Proc.new { |arg1, arg2|
-          %w{a b}.map{|x| puts x }
-        },
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ =>
-        lambda do |arg1, arg2| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { |arg1, arg2| %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        proc do |arg1, arg2| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        lambda { |arg1, arg2| %w{a b}.map{|x| puts x } },
-      __LINE__ =>
-        Proc.new do |arg1, arg2| %w{a b}.map do |x| puts x end end,
-      __LINE__ =>
-        Proc.new { |arg1, arg2| %w{a b}.map{|x| puts x } },
-    }
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new do |arg1, arg2|
-        %w{a b}.map{|x| puts x }
-      end
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using do ... end [##{__LINE__}]" do
-    (SerializableProc.new do |arg1, arg2| %w{a b}.map{|x| puts x } end).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (
-      SerializableProc.new { |arg1, arg2|
-        %w{a b}.map{|x| puts x }
-      }
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle block using { ... } [##{__LINE__}]" do
-    (SerializableProc.new { |arg1, arg2| %w{a b}.map{|x| puts x } }).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(lambda { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with lambda do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(lambda do |arg1, arg2|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with proc { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(proc { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with proc do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(proc do |arg1, arg2|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new { ... } [##{__LINE__}]" do
-    (SerializableProc.new(&(Proc.new { |arg1, arg2| %w{a b}.map{|x| puts x } }))).
-      should.be having_expected_proc_attrs(expected_file, __LINE__.pred, expected_code)
-  end
-
-  should "handle fanciful initializing with Proc.new do ... end [##{__LINE__}]" do
-    (
-      SerializableProc.new(&(Proc.new do |arg1, arg2|
-        %w{a b}.map{|x| puts x }
-      end))
-    ).should.be having_expected_proc_attrs(expected_file, __LINE__ - 3, expected_code)
-  end
-
-end