serializable_proc 0.2.0 → 0.3.0

data/HISTORY.txt

@@ -1,3 +1,12 @@
+=== 0.3.0 (Aug 18, 2010)
+
+* added support for defining of custom matchers that enhances static parser to handle
+  more initializing cases, other than the current SerializableProc.new, Proc.new, proc
+  & lambda [#ngty]
+* ensured subclasses of SerializableProc behaves exactly like SerializableProc [#ngty]
+* partially implemented workaround to ensure the more conservative usages work, quite a
+  number of specs still failing though [#ngty]
+
 === 0.2.0 (Aug 18, 2010)
 
 * added SerializableProc#to_sexp to facilitate retrieving of sexp representation of the

data/README.rdoc

@@ -42,7 +42,7 @@ 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:
@@ -77,15 +77,18 @@ to its static analysis nature (see 'Gotchas' section).
 
 SerializableProc relies on ParseTree or RubyParser to do code extraction. While running
 in ParseTree mode, thanks to the goodness of dynamic code analysis, SerializableProc
-performs faster by a magnitude of abt 7.5 times for the same ruby, as illustrated with
-the following benchmark results (obtained from running the specs suite):
+performs faster by a magnitude of abt 6 times for the same ruby, as illustrated with
+the following benchmark results:
 
-  MRI & implementation    user      system    total     real
-  1.8.7p299 (ParseTree)   0.000000  0.000000  1.310000  1.312676
-  1.8.7p299 (RubyParser)  0.000000  0.010000  9.560000  9.706455
-  1.9.1p376 (RubyParser)  0.010000  0.010000  8.240000  8.288799
+  MRI & implementation    user      system    total      real
+  1.8.7p299 (ParseTree)   0.000000  0.000000  3.510000   3.660623
+  1.8.7p299 (RubyParser)  0.000000  0.000000  20.780000  21.328566
+  1.9.1p376 (RubyParser)  0.010000  0.000000  16.990000  17.370586
 
-(the above is run on my x86_64-linux):
+Note:
+* the above are obtained from running the specs suite of 393 specifications with 1330
+  requirements
+* hardware & OS specs: x86_64 Intel(R) Core(TM)2 Duo CPU P8600 @ 2.40GHz
 
 == Gotchas
 
@@ -98,14 +101,14 @@ perfect (yet), pls take note of the following:
 The following initializations throw SerializableProc::CannotAnalyseCodeError:
 
   # Multiple SerializableProc.new per line
-  SerializableProc.new { x } ; SerializableProc.new { y }
+  SerializableProc.new { ... } ; SerializableProc.new { ... }
 
   # Multiple lambda per line (the same applies to proc & Proc.new)
-  x_proc = lambda { x } ; y_proc = lambda { y }
+  x_proc = lambda { ... } ; y_proc = lambda { ... }
   SerializableProc.new(&x_proc)
 
   # Mixed lambda, proc & Proc.new per line
-  x_proc = proc { x } ; y_proc = lambda { y }
+  x_proc = proc { ... } ; y_proc = lambda { ... }
   SerializableProc.new(&x_proc)
 
 === 2. Limited ways to initialize code blocks
@@ -113,29 +116,79 @@ The following initializations throw SerializableProc::CannotAnalyseCodeError:
 Code block must be initialized with lambda, proc, Proc.new & SerializableProc.new,
 the following will throw SerializableProc::CannotAnalyseCodeError:
 
-  def create_serializable_proc(&block)
+  def create_magic_proc(&block)
     SerializableProc.new(&block)
   end
 
-  create_serializable_proc { x }
+  create_magic_proc { ... }
 
 But the following will work as expected:
 
-  x_proc = lambda { x }
-  create_serializable_proc(&x_proc)
+  x_proc = lambda { ... }
+  create_magic_proc(&x_proc)
+
+There are several strategies to workaround this limitation:
+
+==== 2.1. Subclassing SerializableProc
+
+Any subclass of SerializableProc shows traits of a SerializableProc:
+
+  class MagicProc < SerializableProc ; end
+  m_proc = MagicProc.new { ... } # m_proc walks & quacks like a SerializableProc
+
+==== 2.2. Adding custom matcher(s)
+
+To support more match cases, we can declare new matchers:
+
+  def work(&block)
+    s_proc = SerializableProc.new(&block)
+    ...
+  end
+
+  SerializableProc::Parsers::Static.matchers << 'create_magic_proc'
+  work { ... }
+
+Or if the method above takes arguments:
+
+  def create_magic_proc(*args, &block)
+    s_proc = SerializableProc.new(&block)
+    ...
+  end
+
+  SerializableProc::Parsers::Static.matchers << 'create_magic_proc\W+.*?\W+'
+  create_magic_proc(1, :a => 2, :b => 3) { ... }
+
+=== 3. One liner for ...
+
+This is embarassing, but being flexible can aggrevates performance even more.
+Currently, the declarative (eg. lambda, proc, SerializableProc.new, Proc.new,
+subclasses of SerializableProc, & any user-defined matcher(s)), & the start of
+the code-block (the 'do' & '{' chars) must be on the same line. Meaning the
+following won't work:
+
+  SerializableProc.new \
+    do
+      ...
+    end
+
+  create_magic_proc(
+    1, :a => 2
+  ) { ... }
 
 == Supported Rubies
 
 SerializableProc has been tested to work on the following rubies:
 
 1. MRI 1.8.6, 1.8.7 & 1.9.1
+2. JRuby (partial, the more conservative usages work, quite abit of the specs are failing
+   due to JRuby's bug in dumping a proc's line number when we do Proc#inspect)
 
 == TODO (just brain-dumping)
 
 1. The RubyParser-based implementation probably need alot more optimization to catch up
    on ParseTree-based one
-2. Implementing alternative means of extracting the code block without requiring help
-   of ParseTree or RubyParser
+2. Implementing alternative means (if possible) of extracting the code block without
+   requiring help of ParseTree or RubyParser
 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 &

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/serializable_proc/parsers/{pt.rb → dynamic.rb}

@@ -1,6 +1,6 @@
 class SerializableProc
   module Parsers
-    class PT < Base
+    class Dynamic < Base
       class << self
         def process(block)
           if Object.const_defined?(:ParseTree)

data/lib/serializable_proc/parsers/{rp.rb → static.rb}

@@ -3,7 +3,7 @@ class SerializableProc
   class CannotAnalyseCodeError < Exception ; end
 
   module Parsers
-    class RP < Base
+    class Static < Base
       class << self
 
         def process(klass, file, line)
@@ -12,6 +12,10 @@ class SerializableProc
           extract_code_and_sexp
         end
 
+        def matchers
+          @matchers ||= []
+        end
+
         private
 
           def extract_code_and_sexp
@@ -19,7 +23,7 @@ class SerializableProc
             while frag = remaining[/^([^\)]*\))/,1]
               begin
                 sexp = normalized_eval(sexp_str += frag)
-                return sexp_derivatives(sexp){|code| unescape_magic_vars(code) }
+                return sexp_derivatives(sexp)
               rescue SyntaxError
                 remaining.sub!(frag,'')
               end
@@ -49,11 +53,25 @@ class SerializableProc
           end
 
           def raw_sexp_and_marker
+            line = @line
+            begin
+              raw_sexp_and_marker_by_lineno(@line = line)
+            rescue CannotAnalyseCodeError
+              if RUBY_PLATFORM =~ /java/i
+                line += 1
+                retry
+              else
+                raise $!
+              end
+            end
+          end
+
+          def raw_sexp_and_marker_by_lineno(lineno)
             # TODO: Ugly chunk, need some lovely cleanup !!
-            %W{#{@klass}\.new lambda|proc|Proc\.new}.each do |declarative|
+            (%W{#{@klass}\.new lambda|proc|Proc\.new} + matchers).each do |declarative|
               regexp = /^((.*?)(#{declarative})(\s*(?:do|\{)\s*(?:\|(?:[^\|]*)\|\s*)?)(.*)?)$/m
               raw = raw_code
-              lines1, lines2 = [(0 .. (@line - 2)), (@line.pred .. -1)].map{|r| raw[r] }
+              lines1, lines2 = [(0 .. (lineno - 2)), (lineno.pred .. -1)].map{|r| raw[r] }
               prepend, type, block_start, append = lines2[0].match(regexp)[2..5] rescue next
 
               if lines2[0] =~ /^(.*?\W)?(#{declarative})(\W.*?\W(#{declarative}))+(\W.*)?$/
@@ -61,27 +79,15 @@ class SerializableProc
                   declarative.split('|').join("'/'")
                 raise CannotAnalyseCodeError.new(msg)
               elsif lines2[0] =~ /^(.*?\W)?(#{declarative})(\W.*)?$/
-                marker = "__serializable_proc_marker_#{@line}__"
+                marker = "__serializable_proc_marker_#{lineno}__"
                 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]
+                lines = lines1.join + line + lines2[1..-1].join
+                return [RUBY_PARSER.parse(lines, @file).inspect, marker]
               end
             end
             raise CannotAnalyseCodeError.new('Cannot find specified initializer !!')
           end
 
-          def escape_magic_vars(s)
-            %w{__FILE__ __LINE__}.inject(s) do |s, var|
-              s.gsub(var, "__serializable_proc_#{var.downcase}__")
-            end
-          end
-
-          def unescape_magic_vars(s)
-            %w{__FILE__ __LINE__}.inject(s) do |s, var|
-              s.gsub("__serializable_proc_#{var.downcase}__", var)
-            end
-          end
-
           def raw_code
             File.readlines(@file)
           end

data/lib/serializable_proc/parsers.rb

@@ -26,5 +26,5 @@ class SerializableProc
   end
 end
 
-require 'serializable_proc/parsers/pt'
-require 'serializable_proc/parsers/rp'
+require 'serializable_proc/parsers/dynamic'
+require 'serializable_proc/parsers/static'

data/lib/serializable_proc.rb

@@ -95,7 +95,7 @@ class SerializableProc
   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)
+    @code, @sexp = Parsers::Dynamic.process(block) || Parsers::Static.process(self.class, file, @line)
     @binding = Binding.new(block.binding, @sexp[:extracted])
   end
 

data/serializable_proc.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{serializable_proc}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["NgTzeYang"]
@@ -33,8 +33,8 @@ Gem::Specification.new do |s|
      "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/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",
@@ -46,11 +46,21 @@ Gem::Specification.new do |s|
      "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",
@@ -62,27 +72,13 @@ Gem::Specification.new do |s|
      "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/ngty/serializable_proc}
-  s.post_install_message = %q{
- /////////////////////////////////////////////////////////////////////////////////
-
-  ** SerializableProc **
-
-  You are installing SerializableProc on a ruby platform & version that supports
-  ParseTree. With ParseTree, u can enjoy better performance of SerializableProc,
-  as well as other dynamic code analysis goodness, as compared to the default
-  implementation using RubyParser's less flexible static code analysis.
-
-  Anyway, u have been informed, SerializableProc will fallback on its default
-  implementation using RubyParser.
-
- /////////////////////////////////////////////////////////////////////////////////
-      }
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Proc that can be serialized (as the name suggests)}
   s.test_files = [
-    "spec/proc_like/extras_spec.rb",
+    "spec/spec_helper.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",
@@ -90,12 +86,22 @@ Gem::Specification.new do |s|
      "spec/proc_like/others_spec.rb",
      "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",
@@ -104,15 +110,14 @@ Gem::Specification.new do |s|
      "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"
+     "spec/bounded_vars/class_vars_within_block_scope_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<ruby2ruby>, [">= 1.2.4"])
       s.add_development_dependency(%q<bacon>, [">= 0"])
     else

data/spec/code_block/magic_vars_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe 'Handling magic vars' do
+
+  extend SerializableProc::Spec::Helpers
+
+  should 'convert __FILE__' do
+    SerializableProc.new { __FILE__ }.should.be \
+      having_runnable_code_as('proc { "%s" }' % __FILE__)
+  end
+
+  should 'convert __LINE__' do
+    SerializableProc.new { __LINE__ }.should.be \
+      having_runnable_code_as('proc { %s }' % __LINE__.pred)
+  end
+
+end

data/spec/extending/new_matcher_w_multiple_arities_spec.rb

@@ -0,0 +1,152 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'New matcher w multiple arities' do
+
+  expected_file = File.expand_path(__FILE__)
+  expected_code = "lambda { |lvar_arg1, lvar_arg2| [\"a\", \"b\"].map { |lvar_x| puts(lvar_x) } }"
+
+  describe '>> wo args' do
+
+    extend SerializableProc::Spec::Helpers
+    behaves_like 'has support for parsing Otaky.work (wo args)'
+
+    should "handle block using do ... end [##{__LINE__}]" do
+      (
+        Otaky.work 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
+      (Otaky.work 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
+      (
+        Otaky.work { |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
+      (Otaky.work { |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
+      (Otaky.work(&(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
+      (
+        Otaky.work(&(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
+      (Otaky.work(&(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
+      (
+        Otaky.work(&(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
+      (Otaky.work(&(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
+      (
+        Otaky.work(&(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
+
+  describe '>> w args' do
+
+    extend SerializableProc::Spec::Helpers
+    behaves_like 'has support for parsing Otaky.work (w args)'
+
+    should "handle block using do ... end [##{__LINE__}]" do
+      (
+        Otaky.work(1, :a => 2, :b => 3) 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
+      (Otaky.work(1, :a => 2, :b => 3) 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
+      (
+        Otaky.work(1, :a => 2, :b => 3) { |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
+      (Otaky.work(1, :a => 2, :b => 3) { |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
+      (Otaky.work(1, {:a => 2, :b => 3} , &(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
+      (
+        Otaky.work(1, {:a => 2, :b => 3}, &(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
+      (Otaky.work(1, {:a => 2, :b => 3}, &(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
+      (
+        Otaky.work(1, {:a => 2, :b => 3}, &(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
+      (Otaky.work(1, {:a => 2, :b => 3}, &(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
+      (
+        Otaky.work(1, {:a => 2, :b => 3}, &(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
+
+end