cross-stub 0.2.0 → 0.2.1

data/HISTORY.txt

@@ -1,3 +1,9 @@
+=== 0.2.1 2010-09-16
+
+= House-Keeping
+* use sourcify to extract proc code, instead of handrolled solution [#ngty]
+* use Otaku instead of handrolled EchoServer [#ngty]
+
 === 0.2.0 2010-07-16
 
 = New Features
@@ -6,7 +12,6 @@
 * officially support MRI-1.8.7, MRI-1.9.1, JRUBY-1.5.1 & REE-1.8.7 [#ngty]
 
 = House-Keeping
-
 * dropped ParseTree dependency, use RubyParser instead [#ngty]
 * complete rewrite to have cleaner implementation (hopefully) [#ngty]
 

data/README.rdoc

@@ -2,15 +2,21 @@
 
 == Introduction
 
-Existing mocking/stubbing frameworks support only stubbing in the current process. This is OK most of the time. However, when running cucumber integration test suite in another process, these in-process stubbing frameworks simply doesn't help. Eg. I want Time.now to always return a timing that should be a Sunday, how do I do that when running cucumber using selenium, culerity, steam, blah, blah driver? It doesn't seem straight-forward me.
+Existing mocking/stubbing frameworks support only stubbing in the current process.
+This is OK most of the time. However, when running cucumber integration test suite
+in another process, these in-process stubbing frameworks simply doesn't help. Eg.
+I want Time.now to always return a timing that should be a Sunday, how do I do that
+when running cucumber using selenium, culerity, steam, blah, blah driver? It doesn't
+seem straight-forward me.
 
-(Let's not argue whether stubbing should be encouraged. It is an itch, the poor itch needs to be scratched.)
+(Let's not argue whether stubbing should be encouraged. It is an itch, the poor itch
+needs to be scratched.)
 
 == Getting Started
 
 It's hosted on gemcutter.org.
 
-  $ sudo gem install cross-stub
+  $ gem install cross-stub
 
 == Setting Up
 
@@ -31,7 +37,8 @@ It's hosted on gemcutter.org.
   # point where all request handling starts:
   CrossStub.refresh :file => <CACHE_FILE>
 
-For a full list of available cache stores, scroll down to take a look at the 'Cache Stores' section.
+For a full list of available cache stores, scroll down to take a look at the
+'Cache Stores' section.
 
 == Using It
 
@@ -83,8 +90,6 @@ Cross-stubbing is simple:
 
   Someone.new.say('HELLO') # yields: 'saying "HELLO"'
 
-IMPORTANT: Since switching from ParseTree to RubyParser, dynamic code analysis is no longer possible. When defining methods in the proc, fanciful coding is strongly discouraged, pls follow the conservative style suggested above.
-
 === #3. Something more complicated:
 
   something = 'hello'
@@ -96,7 +101,8 @@ IMPORTANT: Since switching from ParseTree to RubyParser, dynamic code analysis i
 
   Someone.say # failure !!
 
-The above fails as a result of undefined variable/method 'something', to workaround we can have:
+The above fails as a result of undefined variable/method 'something', to workaround
+we can have:
 
   Someone.xstub(:something => 'HELLO') do
     def say
@@ -108,7 +114,8 @@ The above fails as a result of undefined variable/method 'something', to workaro
 
 == Cache Stores
 
-Cache stores are needed to allow stubs to be made available for different processes. The following describes all cache stores available:
+Cache stores are needed to allow stubs to be made available for different processes.
+The following describes all cache stores available:
 
 === #1. File
 
@@ -134,17 +141,22 @@ Cache stores are needed to allow stubs to be made available for different proces
   # Refreshing (other process)
   CrossStub.refresh :redis => 'localhost:6379/<CACHE_ID>'
 
-Adding new store is super easy (w.r.t testing & actual implementation), let me know if u need more :]
+Adding new store is super easy (w.r.t testing & actual implementation), let me know
+if u need more :]
 
 == Caveats
 
-#1. Cross-stub uses ruby's Marshal class to dump & load the stubs, thus it has the same limitations as Marshal
+#1. CrossStub uses ruby's Marshal class to dump & load the stubs, thus it has the
+    same limitations as Marshal (pls note abt a 1.9.1 specific marshal bug at
+    http://redmine.ruby-lang.org/issues/show/3729)
 
-#2. Having switched from ParseTree to RubyParser, dynamic code analysis is no longer available, the proc taken by xstub no longer supports fanciful coding, pls follow the conservative style suggested in this README.
+#2. Under the hood, CrossStub uses Sourcify (http://github.com/ngty/sourcify) for
+    extracting the methods defined within the proc, u may wish to read Sourcify's
+    gotchas to avoid unnecessary headaches.
 
 == TODO(s)
 
-#1. We can possibly use Hijack (http://github.com/ileitch/hijack) within the current test process to trigger refreshing of stubs in the other process, thus using cross-stub no longer requires changing of any existing application code to insert CrossStub.refresh(...). This has in fact been our original intended strategy, however, we have not been able to do so as Hijack currently hangs on starting up on our development machines.
+#1. Is there any better serialization strategy instead of the current Marshal load/dump?
 
 == Contacts
 

data/Rakefile

@@ -4,6 +4,7 @@ require 'rake'
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
     gem.name = "cross-stub"
     gem.summary = %Q{Simple cross process stubbing}
     gem.description = %Q{}
@@ -11,17 +12,14 @@ begin
     gem.homepage = "http://github.com/ngty/cross-stub"
     gem.authors = ["NgTzeYang"]
     gem.add_development_dependency "bacon", ">= 0.0.0"
-    gem.add_development_dependency "eventmachine", ">= 0.0.0"
-    gem.add_dependency "ruby2ruby", "= 1.2.4"
-    gem.add_dependency "ruby_parser", "= 2.0.4"
+    gem.add_development_dependency "otaku", ">= 0.4.0"
+    gem.add_dependency "ruby2ruby", ">= 1.2.5"
+    gem.add_dependency "sexp_processor", ">= 3.0.5"
+    gem.add_dependency "sourcify", ">= 0.2.3"
     gem.required_ruby_version = '>= 1.8.7'
-    # ##
     # TODO: How do we declare the following optional dependencies ??
     # 1. gem.add_dependency "memcache-client", "= 1.8.5"
     # 2. gem.add_dependency "redis", "= 2.0.3"
-    # ##
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-    #
   end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/cross-stub.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cross-stub}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["NgTzeYang"]
-  s.date = %q{2010-07-16}
+  s.date = %q{2010-09-15}
   s.description = %q{}
   s.email = %q{ngty77@gmail.com}
   s.extra_rdoc_files = [
@@ -41,7 +41,6 @@ Gem::Specification.new do |s|
      "rails_generators/cross_stub/templates/config/initializers/cross-stub.rb",
      "rails_generators/cross_stub/templates/features/support/cross-stub.rb",
      "spec/.bacon",
-     "spec/arguments/proc_spec.rb",
      "spec/includes.rb",
      "spec/integration/clearing_instance_stubs_spec.rb",
      "spec/integration/clearing_stubs_spec.rb",
@@ -61,7 +60,6 @@ Gem::Specification.new do |s|
   s.summary = %q{Simple cross process stubbing}
   s.test_files = [
     "spec/includes.rb",
-     "spec/arguments/proc_spec.rb",
      "spec/service.rb",
      "spec/integration/stubbing_error_spec.rb",
      "spec/integration/creating_instance_stubs_spec.rb",
@@ -78,20 +76,23 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<bacon>, [">= 0.0.0"])
-      s.add_development_dependency(%q<eventmachine>, [">= 0.0.0"])
-      s.add_runtime_dependency(%q<ruby2ruby>, ["= 1.2.4"])
-      s.add_runtime_dependency(%q<ruby_parser>, ["= 2.0.4"])
+      s.add_development_dependency(%q<otaku>, [">= 0.4.0"])
+      s.add_runtime_dependency(%q<ruby2ruby>, [">= 1.2.5"])
+      s.add_runtime_dependency(%q<sexp_processor>, [">= 3.0.5"])
+      s.add_runtime_dependency(%q<sourcify>, [">= 0.2.3"])
     else
       s.add_dependency(%q<bacon>, [">= 0.0.0"])
-      s.add_dependency(%q<eventmachine>, [">= 0.0.0"])
-      s.add_dependency(%q<ruby2ruby>, ["= 1.2.4"])
-      s.add_dependency(%q<ruby_parser>, ["= 2.0.4"])
+      s.add_dependency(%q<otaku>, [">= 0.4.0"])
+      s.add_dependency(%q<ruby2ruby>, [">= 1.2.5"])
+      s.add_dependency(%q<sexp_processor>, [">= 3.0.5"])
+      s.add_dependency(%q<sourcify>, [">= 0.2.3"])
     end
   else
     s.add_dependency(%q<bacon>, [">= 0.0.0"])
-    s.add_dependency(%q<eventmachine>, [">= 0.0.0"])
-    s.add_dependency(%q<ruby2ruby>, ["= 1.2.4"])
-    s.add_dependency(%q<ruby_parser>, ["= 2.0.4"])
+    s.add_dependency(%q<otaku>, [">= 0.4.0"])
+    s.add_dependency(%q<ruby2ruby>, [">= 1.2.5"])
+    s.add_dependency(%q<sexp_processor>, [">= 3.0.5"])
+    s.add_dependency(%q<sourcify>, [">= 0.2.3"])
   end
 end
 

data/lib/cross-stub.rb

@@ -1,8 +1,10 @@
 require 'rubygems'
 require 'base64'
 require 'ruby2ruby'
-require 'ruby_parser'
+require 'sexp_processor'
+require 'sourcify'
 require 'forwardable'
+
 require 'cross-stub/cache'
 require 'cross-stub/stubber'
 require 'cross-stub/arguments'

data/lib/cross-stub/arguments/proc.rb

@@ -1,72 +1,18 @@
 module CrossStub
   module Arguments #:nodoc:
     module Proc
-
       class << self
-        def parse(&block)
-          CodeBlock.new(&block).methods_hash
-        end
-      end
-
-      class CodeBlock
 
-        RUBY_PARSER = RubyParser.new
         RUBY_2_RUBY = Ruby2Ruby.new
 
-        def initialize(&block)
-          @block = block
-          @methods_hash = ref_methods.inject({}) do |memo, method|
-            memo.merge(:"#{method}" => extract_code(method))
+        def parse(&block)
+          methods = {}
+          block.to_sexp.each_of_type(:defn) do |_sexp|
+            methods[_sexp.to_a[1]] = RUBY_2_RUBY.process(_sexp)
           end
+          methods
         end
 
-        attr_reader :methods_hash
-
-        private
-
-          def extract_code(method)
-            ignore, _, code = source_code.match(code_regexp(method))[1..3]
-            remaining = source_code.sub(ignore,'')
-            while frag = remaining[/^(.*?\Wend)/m,1]
-              begin
-                sexp = RUBY_PARSER.parse(code += frag)
-                return RUBY_2_RUBY.process(sexp) if sexp.inspect =~ sexp_regexp(method)
-              rescue SyntaxError, Racc::ParseError, NoMethodError
-                remaining.sub!(frag,'')
-              end
-            end
-          end
-
-          def ref_methods
-            @ref_methods ||= (
-              (object = Minimalist.new).__instance_eval__(&@block)
-              object.__methods__ - Minimalist.instance_methods
-            )
-          end
-
-          def source_code
-            @source_code ||= (
-              file, line_no = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(@block.inspect)[1..2]
-              File.readlines(file)[line_no.to_i.pred .. -1].join
-            )
-          end
-
-          def code_regexp(method)
-            /^(.*?(do|\{)\s*.*?(def\s*#{method}\W))/m
-          end
-
-          def sexp_regexp(method)
-            /^(s\(:defn,\ :#{method},\ s\(:args.*\),\ s\(:scope,\ s\(:block,\ .*\))$/
-          end
-
-          class Minimalist
-            orig_verbosity, $VERBOSE = $VERBOSE, nil
-            alias_method :__instance_eval__, :instance_eval
-            alias_method :__methods__, :methods
-            instance_methods.each{|meth| undef_method(meth) if meth.to_s !~ /^__.*?__$/ }
-            $VERBOSE = orig_verbosity
-          end
-
       end
     end
   end

data/spec/includes.rb

@@ -10,7 +10,7 @@ RUBY_VM = [
   RUBY_DESCRIPTION =~ /enterprise/i ? 'e' : ''
 ].join
 
-PROJECT_ROOT = File.join(File.dirname(__FILE__), '..')
+PROJECT_ROOT = File.join(File.dirname(File.expand_path(__FILE__)), '..')
 PROJECT_FILE = lambda{|*args| File.join(*[PROJECT_ROOT, *args]) }
 
 CACHE_STORES = {
@@ -19,10 +19,14 @@ CACHE_STORES = {
   :redis => "localhost:6379/stubbing-#{RUBY_VM}.cache",
 }
 
-ECHO_SERVER_INIT_WAIT_TIME = RUBY_VM.end_with?('j') ? 10 : 2
-ECHO_SERVER_LOG = PROJECT_FILE['tmp', "echoserver-#{RUBY_VM}.log"]
-ECHO_SERVER_HOST = '127.0.0.1'
-ECHO_SERVER_PORT = 10000 + RUBY_VM[/(\d+)/,1].to_i + ({'j' => 7, 'e' => 17}[RUBY_VM[-1..-1]] || 0)
+# /////////////////////////////////////////////////////////////////////////////////////////
+# Configuring otaku service
+# /////////////////////////////////////////////////////////////////////////////////////////
+
+require 'otaku' unless Object.const_defined?('Otaku')
+Otaku.configure do |config|
+  config.log_file = PROJECT_FILE['tmp', "otaku-#{RUBY_VM}.log"]
+end
 
 # /////////////////////////////////////////////////////////////////////////////////////////
 # Useful methods
@@ -51,7 +55,7 @@ def parse_call_args(klass_and_method_and_args)
 end
 
 def do_remote_method_call(store_type_and_klass_and_method_and_args)
-  (value = EchoClient.get(store_type_and_klass_and_method_and_args)) !~ /^undefined method/ ?
+  (value = Otaku.process(store_type_and_klass_and_method_and_args)) !~ /^undefined method/ ?
     value : Object.we_just_wanna_trigger_no_method_error_with_this_weird_method!
 end
 

data/spec/integration/shared_spec.rb

@@ -1,6 +1,5 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 require File.join(File.dirname(__FILE__), '..', 'includes')
-require File.join(File.dirname(__FILE__), '..', 'service')
 
 shared 'has standard setup' do
   before { CrossStub.setup(cache_store(@store_type)) }
@@ -17,19 +16,25 @@ shared 'has other process setup' do
   behaves_like 'has standard setup'
 
   before do
-    @call = lambda do |klass_and_method_and_args|
-      do_remote_method_call("%s/%s" % [@store_type, klass_and_method_and_args])
+    @call = lambda do |method_call_args|
+      do_remote_method_call("%s/%s" % [@store_type, method_call_args])
     end
     $service_started ||= (
-      EchoServer.start if ENV['ECHO_SERVER'] != 'false'
-      true
+      ENV['FORK_SERVER'] != 'false' && (
+        Otaku.start do |data|
+          @@_not_isolated_vars = :all # we don't wanna isolate any contextual references
+          require File.join(File.dirname(__FILE__), '..', 'includes')
+          store_type, method_call_args = data.match(/^(.*?)\/(.*)$/)[1..2]
+          CrossStub.refresh(cache_store($prev_store_type)) if $prev_store_type
+          CrossStub.refresh(cache_store($prev_store_type = store_type))
+          do_local_method_call(method_call_args) rescue $!.message
+        end
+      ) ; true
     )
   end
 
 end
 
 at_exit do
-  $service_started && (
-    EchoServer.stop unless ENV['ECHO_SERVER'] == 'false'
-  )
+  ENV['FORK_SERVER'] != 'false' && $service_started && Otaku.stop
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cross-stub
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - NgTzeYang
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-16 00:00:00 +08:00
+date: 2010-09-15 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,19 +35,19 @@ dependencies:
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: eventmachine
+  name: otaku
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 15
         segments: 
         - 0
+        - 4
         - 0
-        - 0
-        version: 0.0.0
+        version: 0.4.0
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -56,32 +56,48 @@ dependencies:
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 21
         segments: 
         - 1
         - 2
-        - 4
-        version: 1.2.4
+        - 5
+        version: 1.2.5
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: ruby_parser
+  name: sexp_processor
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 13
         segments: 
-        - 2
+        - 3
         - 0
-        - 4
-        version: 2.0.4
+        - 5
+        version: 3.0.5
   type: :runtime
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sourcify
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 2
+        - 3
+        version: 0.2.3
+  type: :runtime
+  version_requirements: *id005
 description: ""
 email: ngty77@gmail.com
 executables: []
@@ -116,7 +132,6 @@ files:
 - rails_generators/cross_stub/templates/config/initializers/cross-stub.rb
 - rails_generators/cross_stub/templates/features/support/cross-stub.rb
 - spec/.bacon
-- spec/arguments/proc_spec.rb
 - spec/includes.rb
 - spec/integration/clearing_instance_stubs_spec.rb
 - spec/integration/clearing_stubs_spec.rb
@@ -165,7 +180,6 @@ specification_version: 3
 summary: Simple cross process stubbing
 test_files: 
 - spec/includes.rb
-- spec/arguments/proc_spec.rb
 - spec/service.rb
 - spec/integration/stubbing_error_spec.rb
 - spec/integration/creating_instance_stubs_spec.rb

data/spec/arguments/proc_spec.rb

@@ -1,689 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe 'Extracting methods from proc' do
-
-  extract = CrossStub::Arguments::Proc.method(:parse)
-
-  describe '>> proc with single method (wo argument)' do
-
-    expected = {:bang => "def bang\n  \"oops\"\nend"}
-
-    {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def bang
-            'oops'
-          end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def bang
-            'oops'
-          end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def bang
-            'oops'
-          end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def bang
-            'oops'
-          end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def bang
-            'oops'
-          end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def bang
-            'oops'
-          end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def bang ; 'oops' ; end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def bang ; 'oops' ; end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def bang ; 'oops' ; end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def bang ; 'oops' ; end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def bang ; 'oops' ; end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def bang ; 'oops' ; end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do def bang ; 'oops' ; end end
-      ),
-      __LINE__ => (
-        lambda { def bang ; 'oops' ; end }
-      ),
-      __LINE__ => (
-        proc do def bang ; 'oops' ; end end
-      ),
-      __LINE__ => (
-        proc { def bang ; 'oops' ; end }
-      ),
-      __LINE__ => (
-        Proc.new do def bang ; 'oops' ; end end
-      ),
-      __LINE__ => (
-        Proc.new { def bang ; 'oops' ; end }
-      ),
-    }.each do |debug, block|
-      should "handle proc as variable [##{debug}]" do
-        extract.call(&block).should.equal(expected)
-      end
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang
-          'oops'
-        end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang ; 'oops' ; end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do def bang ; 'oops' ; end ; end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang
-          'oops'
-        end
-      end.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def bang
-          'oops'
-        end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def bang ; 'oops' ; end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call { def bang ; 'oops' ; end }.should.equal(expected)
-    end
-
-  end
-
-  describe '>> proc with single method (w argument)' do
-
-    expected = {:shout => "def shout(wat)\n  wat\nend"}
-
-    {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def shout(wat)
-            wat
-          end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def shout(wat)
-            wat
-          end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def shout(wat)
-            wat
-          end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def shout(wat)
-            wat
-          end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def shout(wat)
-            wat
-          end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def shout(wat)
-            wat
-          end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def shout(wat) ; wat ; end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def shout(wat) ; wat ; end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def shout(wat) ; wat ; end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def shout(wat) ; wat ; end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def shout(wat) ; wat ; end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def shout(wat) ; wat ; end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do def shout(wat) ; wat ; end end
-      ),
-      __LINE__ => (
-        lambda { def shout(wat) ; wat ; end }
-      ),
-      __LINE__ => (
-        proc do def shout(wat) ; wat ; end end
-      ),
-      __LINE__ => (
-        proc { def shout(wat) ; wat ; end }
-      ),
-      __LINE__ => (
-        Proc.new do def shout(wat) ; wat ; end end
-      ),
-      __LINE__ => (
-        Proc.new { def shout(wat) ; wat ; end }
-      ),
-    }.each do |debug, block|
-      should "handle proc as variable [##{debug}]" do
-        extract.call(&block).should.equal(expected)
-      end
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def shout(wat)
-          wat
-        end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def shout(wat) ; wat ; end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do def shout(wat) ; wat ; end end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def shout(wat)
-          wat
-        end
-      end.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def shout(wat)
-          wat
-        end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def shout(wat) ; wat ; end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call { def shout(wat) ; wat ; end }.should.equal(expected)
-    end
-
-  end
-
-  describe '>> proc with multiple methods (wo argument)' do
-
-    expected = {
-      :bang => "def bang\n  \"oops\"\nend",
-      :shout => "def shout\n  \"hello\"\nend"
-    }
-
-    {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def bang
-            'oops'
-          end
-          def shout
-            'hello'
-          end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def bang
-            'oops'
-          end
-          def shout
-            'hello'
-          end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def bang
-            'oops'
-          end
-          def shout
-            'hello'
-          end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def bang
-            'oops'
-          end
-          def shout
-            'hello'
-          end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def bang
-            'oops'
-          end
-          def shout
-            'hello'
-          end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def bang
-            'oops'
-          end
-          def shout
-            'hello'
-          end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def bang ; 'oops' ; end
-          def shout ; 'hello' ; end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def bang ; 'oops' ; end
-          def shout ; 'hello' ; end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def bang ; 'oops' ; end
-          def shout ; 'hello' ; end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def bang ; 'oops' ; end
-          def shout ; 'hello' ; end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def bang ; 'oops' ; end
-          def shout ; 'hello' ; end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def bang ; 'oops' ; end
-          def shout ; 'hello' ; end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do def bang ; 'oops' ; end ; def shout ; 'hello' ; end end
-      ),
-      __LINE__ => (
-        lambda { def bang ; 'oops' ; end ; def shout ; 'hello' ; end }
-      ),
-      __LINE__ => (
-        proc do def bang ; 'oops' ; end ; def shout ; 'hello' ; end end
-      ),
-      __LINE__ => (
-        proc { def bang ; 'oops' ; end ; def shout ; 'hello' ; end }
-      ),
-      __LINE__ => (
-        Proc.new do def bang ; 'oops' ; end ; def shout ; 'hello' ; end end
-      ),
-      __LINE__ => (
-        Proc.new { def bang ; 'oops' ; end ; def shout ; 'hello' ; end }
-      ),
-    }.each do |debug, block|
-      should "handle proc as variable [##{debug}]" do
-        extract.call(&block).should.equal(expected)
-      end
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang
-          'oops'
-        end
-        def shout
-          'hello'
-        end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang ; 'oops' ; end
-        def shout ; 'hello' ; end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do def bang ; 'oops' ; end ; def shout ; 'hello' ; end end.
-        should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def bang
-          'oops'
-        end
-        def shout
-          'hello'
-        end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def bang ; 'oops' ; end
-        def shout ; 'hello' ; end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call { def bang ; 'oops' ; end ; def shout ; 'hello' ; end }.
-        should.equal(expected)
-    end
-
-  end
-
-  describe '>> proc with multiple methods (w argument)' do
-
-    expected = {
-      :bang => "def bang(wat)\n  wat\nend",
-      :shout => "def shout(wat)\n  wat\nend"
-    }
-
-    {
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Always newlinling
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def bang(wat)
-            wat
-          end
-          def shout(wat)
-            wat
-          end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def bang(wat)
-            wat
-          end
-          def shout(wat)
-            wat
-          end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def bang(wat)
-            wat
-          end
-          def shout(wat)
-            wat
-          end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def bang(wat)
-            wat
-          end
-          def shout(wat)
-            wat
-          end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def bang(wat)
-            wat
-          end
-          def shout(wat)
-            wat
-          end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def bang(wat)
-            wat
-          end
-          def shout(wat)
-            wat
-          end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> Partial newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do
-          def bang(wat) ; wat ; end
-          def shout(wat) ; wat ; end
-        end
-      ),
-      __LINE__ => (
-        lambda {
-          def bang(wat) ; wat ; end
-          def shout(wat) ; wat ; end
-        }
-      ),
-      __LINE__ => (
-        proc do
-          def bang(wat) ; wat ; end
-          def shout(wat) ; wat ; end
-        end
-      ),
-      __LINE__ => (
-        proc {
-          def bang(wat) ; wat ; end
-          def shout(wat) ; wat ; end
-        }
-      ),
-      __LINE__ => (
-        Proc.new do
-          def bang(wat) ; wat ; end
-          def shout(wat) ; wat ; end
-        end
-      ),
-      __LINE__ => (
-        Proc.new {
-          def bang(wat) ; wat ; end
-          def shout(wat) ; wat ; end
-        }
-      ),
-    # ////////////////////////////////////////////////////////////////////////
-    # >> No newlining
-    # ////////////////////////////////////////////////////////////////////////
-      __LINE__ => (
-        lambda do def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end end
-      ),
-      __LINE__ => (
-        lambda { def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end }
-      ),
-      __LINE__ => (
-        proc do def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end end
-      ),
-      __LINE__ => (
-        proc { def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end }
-      ),
-      __LINE__ => (
-        Proc.new do def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end end
-      ),
-      __LINE__ => (
-        Proc.new { def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end }
-      ),
-    }.each do |debug, block|
-      should "handle proc as variable [##{debug}]" do
-        extract.call(&block).should.equal(expected)
-      end
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang(wat)
-          wat
-        end
-        def shout(wat)
-          wat
-        end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do
-        def bang(wat) ; wat ; end
-        def shout(wat) ; wat ; end
-      end.should.equal(expected)
-    end
-
-    should "handle block using do ... end [##{__LINE__}]" do
-      extract.call do def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end end.
-        should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def bang(wat)
-          wat
-        end
-        def shout(wat)
-          wat
-        end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call {
-        def bang(wat) ; wat ; end
-        def shout(wat) ; wat ; end
-      }.should.equal(expected)
-    end
-
-    should "handle block using { ... } [##{__LINE__}]" do
-      extract.call { def bang(wat) ; wat ; end ; def shout(wat) ; wat ; end }.
-        should.equal(expected)
-    end
-
-  end
-
-end