cross-stub 0.1.4 → 0.2.0

data/rails_generators/cross_stub/cross_stub_generator.rb

@@ -4,7 +4,7 @@ class CrossStubGenerator < Rails::Generator::Base
     record do |m|
       m.file 'config/initializers/cross-stub.rb', 'config/initializers/cross-stub.rb'
       m.file 'features/support/cross-stub.rb', 'features/support/cross-stub.rb'
-      m.gsub_file 'config/environments/cucumber.rb', /\z/, "config.gem 'cross-stub', :version => '>=0.1.4'\n"
+      m.gsub_file 'config/environments/cucumber.rb', /\z/, "config.gem 'cross-stub', :version => '>=0.2.0'\n"
     end
   end
 

data/rails_generators/cross_stub/templates/config/initializers/cross-stub.rb

@@ -1,7 +1,15 @@
 if ENV['RAILS_ENV'] == 'cucumber'
   class ActionController::Dispatcher
     def refresh_stubs
-      CrossStub.refresh :file => File.join(RAILS_ROOT, 'tmp', 'cross-stub.cache')
+      # /////////////////////////////////////////////////////////////////////////////////
+      # NOTE: By default, we use file-based cache store for cross-stub. Alternatively,
+      # u may wanna try out the other cache stores. Adding new cache store support is
+      # super easy, w.r.t actual implementation & testing, just drop me a note at
+      # http://github.com/ngty/cross-stub & i'll do it for u, of course FOC lah !!
+      # /////////////////////////////////////////////////////////////////////////////////
+      #CrossStub.refresh :redis => 'localhost:6379/xstub.cache' # requires *redis* gem
+      #CrossStub.refresh :memcache => 'localhost:11211/xstub.cache' # requires *memcache-client* gem
+      CrossStub.refresh :file => File.join(RAILS_ROOT, 'tmp', 'xstub.cache')
     end
     before_dispatch :refresh_stubs
   end

data/rails_generators/cross_stub/templates/features/support/cross-stub.rb

@@ -1,3 +1,17 @@
 require 'cross-stub'
-Before { CrossStub.setup :file => File.join(RAILS_ROOT, 'tmp', 'cross-stub.cache') }
-After  { CrossStub.clear }
+
+Before do
+  # /////////////////////////////////////////////////////////////////////////////////
+  # NOTE: By default, we use file-based cache store for cross-stub. Alternatively,
+  # u may wanna try out the other cache stores. Adding new cache store support is
+  # super easy, w.r.t actual implementation & testing, just drop me a note at
+  # http://github.com/ngty/cross-stub & i'll do it for u, of course FOC lah !!
+  # /////////////////////////////////////////////////////////////////////////////////
+  #CrossStub.setup :redis => 'localhost:6379/xstub.cache' # requires *redis* gem
+  #CrossStub.setup :memcache => 'localhost:11211/xstub.cache' # requires *memcache-client* gem
+  CrossStub.setup :file => File.join(RAILS_ROOT, 'tmp', 'xstub.cache')
+end
+
+After do
+  CrossStub.clear
+end

data/spec/arguments/proc_spec.rb

@@ -0,0 +1,689 @@
+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