warp 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3ced099297c6651735bef5b460ba7d59ca44ea7
-  data.tar.gz: a358f43f18681cd99088c1669ba3ff9dfdc8f98f
+  metadata.gz: a26f9c24ab61368b029824ef4d7da7224830142b
+  data.tar.gz: 1b26fa712ddd38e5e70ee757920f4ee8a2e89ed0
 SHA512:
-  metadata.gz: e256fafcd4a89e333ee478fdff1a8fbc3c5fca8bb6cd84e666db9279bf1f0339d3cb8c3541b61d0b738051e6357a5c470bd60fc7b524875baad3fd63cea7ad3d
-  data.tar.gz: 4163e2f6b8e369414508e0b0b59b160a316deaa5f0c5fda5a10ef4097299482221bf492c4cdbb563ac69f1da5af001b6084ccf58b196b2966e84b76cb0fc1de4
+  metadata.gz: 2a851430a6ff0293d2e4ed1978aae6afc1111af4a826ea7ce0fe006bcf64eea0279c2de0dd9f523b17df122f495a53a4427d3b5a3d87b3c0781aad9e05f82160
+  data.tar.gz: 13504117019ea432a0947c9b6601c8ace8d90d9113a001f33becd1103e03b5b18aec2495d2959dd9f8d53f705cb41e96012f2d0822082e300b6e265e92f8029e

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+- 1.0.1
+  - Fixed issue where matchers would error unless explicitly passed the controller object.
+
+- 1.0.0
+  - Initial release

data/README.md

@@ -1,6 +1,8 @@
 # Warp
 
 [![Build Status](https://travis-ci.org/thomasfedb/warp.png)](https://travis-ci.org/thomasfedb/warp)
+[![Gem Version](https://badge.fury.io/rb/warp.png)](http://rubygems.org/gems/warp)
+[![Code Climate](https://codeclimate.com/github/thomasfedb/warp.png)](https://codeclimate.com/github/thomasfedb/warp)
 
 RSpec Matchers to simplify writing unit and feature tests for your Rails applications.
 
@@ -18,7 +20,7 @@ And then execute:
 
 ## Usage
 
-### assigns(:key)
+### assigns(key)
 
 Ensures that the specific assign is set:
 
@@ -26,7 +28,7 @@ Ensures that the specific assign is set:
 specify { expect(controller).to assign(:posts) }
 ```
 
-### assigns(:key).with
+### assigns(key).with(object)
 
 Ensures that the specific assign is set with the specified value:
 
@@ -34,7 +36,7 @@ Ensures that the specific assign is set with the specified value:
 specify { expect(controller).to assign(:posts).with(posts) }
 ```
 
-### assigns(:key).with_a
+### assigns(key).with_a(klass)
 
 Ensures that the specific assign is set with an instance of the specified class:
 
@@ -42,7 +44,7 @@ Ensures that the specific assign is set with an instance of the specified class:
 specify { expect(controller).to assign(:post).with_a(Post) }
 ```
 
-### assigns(:key).with_a_new
+### assigns(key).with_a_new(klass)
 
 Ensures that the specific assign is set with a instance of the specified class that is not persisted:
 
@@ -50,14 +52,14 @@ Ensures that the specific assign is set with a instance of the specified class t
 specify { expect(controller).to assign(:post).with_a_new(Post) }
 ```
 
-### set_flash(:key)
+### set_flash(key)
 
 Ensure that the specific flash key is set:
 
 ```ruby
 specify { expect(controller).to set_flash(:notice) }
 ```
-### set_flash(:key).to("expected value")
+### set_flash(key).to(value)
 
 Ensure that the specific flash key is set:
 

data/lib/warp/controller_matchers/assign_matcher.rb

@@ -6,8 +6,9 @@ module Warp
       attr_reader :assign_key, :assign_with, :assign_with_a, :assign_with_a_new
       attr_reader :controller, :failure_message, :failure_message_when_negated, :description
 
-      def initialize(assign_key)
+      def initialize(assign_key, controller)
         @assign_key = assign_key
+        @controller = controller
       end
 
       def with(assign_eq)
@@ -25,8 +26,8 @@ module Warp
         self
       end
       
-      def matches?(controller)
-        @controller = controller
+      def matches?(actual)
+        @controller = actual if actual.is_a?(ActionController::Metal)
 
         if multiple_assertions?
           raise "Only one of .with, .with_a, and .with_a_new can be used with the assigns matcher."
@@ -49,9 +50,9 @@ module Warp
       end
 
       def check_assign_with
-        @description = "assign @#{assign_key} with #{assign_with.inspect}"
-        @failure_message = "expected @#{assign_key} to be assigned with #{assign_with.inspect} but was assigned with #{assign_value.inspect}"
-        @failure_message_when_negated = "expected @#{assign_key} to not be assigned with #{assign_with.inspect}"
+        @description = "assign @#{assign_key} with #{description_of(assign_with)}"
+        @failure_message = "expected @#{assign_key} to be assigned with #{description_of(assign_with)} but was assigned with #{assign_value.inspect}"
+        @failure_message_when_negated = "expected @#{assign_key} to not be assigned with #{description_of(assign_with)}"
 
         values_match?(assign_with, assign_value)
       end
@@ -61,7 +62,7 @@ module Warp
         @failure_message = "expected @#{assign_key} to be assigned with an instance of #{assign_with_a.name} but was assigned with an instance of #{assign_value.class.name}"
         @failure_message_when_negated = "expected @#{assign_key} to not be assigned with an instance of #{assign_with_a.name}"
 
-        has_ancestor?(assign_value, assign_with_a)
+        has_ancestor?(assign_with_a, assign_value)
       end
 
       def check_assign_with_a_new
@@ -69,7 +70,7 @@ module Warp
         @failure_message = "expected @#{assign_key} to be assigned with a new instance of #{assign_with_a_new.name} but was assigned with a #{assign_value.persisted? ? "persisted" : "new"} instance of #{assign_value.class.name}"
         @failure_message_when_negated = "expected @#{assign_key} to not be assigned with a new instance of #{assign_with_a_new.name}"
 
-        has_ancestor?(assign_value, assign_with_a_new) && values_match?(false, assign_value.persisted?)
+        has_ancestor?(assign_with_a_new, assign_value) && values_match?(false, assign_value.persisted?)
       end
 
       def assign_value
@@ -80,13 +81,13 @@ module Warp
         [@assign_with, @assign_with_a, @assign_with_a_new].compact.size > 1
       end
 
-      def has_ancestor?(object, klass)
-        object.class.ancestors.any? {|ancestor| values_match?(klass, ancestor) }
+      def has_ancestor?(expected_class, actual)
+        actual.class.ancestors.any? {|ancestor| values_match?(expected_class, ancestor) }
       end
     end
 
     def assign(assign_key)
-      AssignMatcher.new(assign_key)
+      AssignMatcher.new(assign_key, controller)
     end
   end
 end

data/lib/warp/controller_matchers/set_flash_matcher.rb

@@ -6,8 +6,9 @@ module Warp
       attr_reader :flash_key, :expected_flash_value
       attr_reader :controller, :failure_message, :failure_message_when_negated, :description
 
-      def initialize(flash_key)
+      def initialize(flash_key, controller)
         @flash_key = flash_key
+        @controller = controller
       end
 
       def to(expected_flash_value)
@@ -15,8 +16,8 @@ module Warp
         self
       end
 
-      def matches?(controller)
-        @controller = controller
+      def matches?(actual)
+        @controller = actual if actual.is_a?(ActionController::Metal)
 
         if expected_flash_value
           @description = "set flash[:#{flash_key}] to #{expected_flash_value.inspect}"
@@ -43,7 +44,7 @@ module Warp
     end
 
     def set_flash(flash_key)
-      SetFlashMatcher.new(flash_key)
+      SetFlashMatcher.new(flash_key, controller)
     end
   end
 end

data/lib/warp/version.rb

@@ -1,3 +1,3 @@
 module Warp
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/spec_helper.rb

@@ -17,4 +17,5 @@ RSpec.configure do |config|
   config.order = 'random'
 
   config.extend ControllerHelpers
+  config.extend WithContextsHelpers
 end

data/spec/support/controller_helpers.rb

@@ -1,5 +1,7 @@
 module ControllerHelpers
-  def build_controller
+  def build_controller(name = :controller)
+    let(:controller_name) { name }
+
     let(:controller_class) do
       Class.new(ActionController::Metal).tap do |klass|
         klass.instance_eval do
@@ -26,7 +28,7 @@ module ControllerHelpers
       end
     end
 
-    let(:controller) do
+    let(name) do
       controller_class.new.tap do |controller|
         controller.instance_variable_set(:@_request, request)
       end
@@ -40,7 +42,7 @@ module ControllerHelpers
         render text: ""
       end
 
-      controller.dispatch(:index, request)
+      send(controller_name).dispatch(:index, request)
     end
   end
 end

data/spec/support/with_contexts_helpers.rb

@@ -0,0 +1,32 @@
+module WithContextsHelpers
+  class WithContextsBuilder
+    attr_accessor :contexts, :examples, :group
+
+    def initialize(group)
+      @contexts = {}
+      @group = group
+    end
+
+    def context(name, &blk)
+      self.contexts[name] = blk
+    end
+
+    def behaviour(&blk)
+      self.examples = blk
+    end
+
+    def execute
+      contexts.each do |name, blk|
+        context = group.context(name)
+        context.instance_eval(&blk)
+        context.instance_eval(&examples)
+      end
+    end
+  end
+
+  def with_contexts(&blk)
+    builder = WithContextsBuilder.new(self)
+    builder.instance_eval(&blk)
+    builder.execute
+  end
+end

data/spec/warp/controller_matchers/assign_matcher_spec.rb

@@ -1,211 +1,230 @@
 require "spec_helper"
 
 describe Warp::ControllerMatchers::AssignMatcher do
-  build_controller
-
-  subject { assign(:assign) }
-
-  describe "#description" do
-    subject { super().matches?(controller); super().description }
-
-    specify { expect(subject).to eq "assign @assign" }
-  end
-
-  context "when assigned" do
-    controller_action do
-      @assign = Object.new
-    end
-
-    specify { expect(subject).to match(controller) }
-  
-    describe "#failure_message_when_negated" do
-      subject { super().matches?(controller); super().failure_message_when_negated }
-
-      specify { expect(subject).to eq "expected @assign to not be assigned" }
-    end
-  end
+  with_contexts do
+    context "with implicit controller" do
+      build_controller(:controller)
+      
+      let(:_controller) { controller }
 
-  context "when not assigned" do
-    controller_action do
-      # no assign
+      subject { matcher.tap {|m| m.matches?(Object.new) } }
     end
-
-    specify { expect(subject).to_not match(controller) }
     
-    describe "#failure_message" do
-      subject { super().matches?(controller); super().failure_message }
+    context "with explicit controller" do
+      build_controller(:other_controller)
+      let(:controller) { double("fake controller") }
 
-      specify { expect(subject).to eq "expected @assign to be assigned" }
-    end
-  end
+      let(:_controller) { other_controller }
 
-  describe "#with" do
-    controller_action do
-      @assign = spec.actual_assign_value
+      subject { matcher.tap {|m| m.matches?(other_controller) } }
     end
+    
+    behaviour do
+      let(:matcher) { assign(:assign) }
 
-    let(:actual_assign_value) { "foobar" }
-    let(:expected_assign_value) { "foobar" }
-
-    subject { super().with(expected_assign_value) }
+      describe "#description" do
+        subject { super().description }
 
-    describe "#description" do
-      subject { super().matches?(controller); super().description }
+        specify { expect(subject).to eq "assign @assign" }
+      end
 
-      specify { expect(subject).to eq "assign @assign with #{expected_assign_value.inspect}" }
-    end
+      context "when assigned" do
+        controller_action do
+          @assign = Object.new
+        end
 
-    context "with the right value" do
-      specify { expect(subject).to match(controller) }
-    
-      describe "#failure_message_when_negated" do
-        subject { super().matches?(controller); super().failure_message_when_negated }
+        specify { expect(subject).to match(_controller) }
+      
+        describe "#failure_message_when_negated" do
+          subject { super().failure_message_when_negated }
 
-        specify { expect(subject).to eq "expected @assign to not be assigned with #{expected_assign_value.inspect}" }
+          specify { expect(subject).to eq "expected @assign to not be assigned" }
+        end
       end
-    end
 
-    context "with the wrong value" do
-      let(:expected_assign_value) { "foobaz" }
+      context "when not assigned" do
+        controller_action do
+          # no assign
+        end
 
-      specify { expect(subject).to_not match(controller) }
-      
-      describe "#failure_message" do
-        subject { super().matches?(controller); super().failure_message }
+        specify { expect(subject).to_not match(_controller) }
+        
+        describe "#failure_message" do
+          subject { super().failure_message }
 
-        specify { expect(subject).to eq "expected @assign to be assigned with #{expected_assign_value.inspect} but was assigned with #{actual_assign_value.inspect}" }
+          specify { expect(subject).to eq "expected @assign to be assigned" }
+        end
       end
-    end
-  end
 
-  describe "#with_a" do
-    controller_action do
-      @assign = spec.actual_assign_class.new
-    end
+      describe "#with" do
+        controller_action do
+          @assign = spec.actual_assign_value
+        end
 
-    let(:actual_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "FooClass" } } }
-    let(:expected_assign_class) { actual_assign_class }
+        let(:actual_assign_value) { "foobar" }
+        let(:expected_assign_value) { "foobar" }
 
-    subject { assign(:assign).with_a(expected_assign_class) }
+        let(:matcher) { super().with(expected_assign_value) }
 
-    describe "#description" do
-      subject { super().matches?(controller); super().description }
+        describe "#description" do
+          subject { super().description }
 
-      specify { expect(subject).to eq "assign @assign with an instance of #{expected_assign_class.name}" }
-    end
+          specify { expect(subject).to eq "assign @assign with #{expected_assign_value.inspect}" }
+        end
 
-    context "with the right class" do
-      specify { expect(subject).to match(controller) }
+        context "with the right value" do
+          specify { expect(subject).to match(_controller) }
         
-      describe "#failure_message_when_negated" do
-        subject { super().matches?(controller); super().failure_message_when_negated }
+          describe "#failure_message_when_negated" do
+            subject { super().failure_message_when_negated }
 
-        specify { expect(subject).to eq "expected @assign to not be assigned with an instance of #{expected_assign_class.name}" }
-      end
-    end
+            specify { expect(subject).to eq "expected @assign to not be assigned with #{expected_assign_value.inspect}" }
+          end
+        end
 
-    context "with the wrong class" do
-      let(:expected_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "BarClass" } } }
+        context "with the wrong value" do
+          let(:expected_assign_value) { "foobaz" }
 
-      specify { expect(subject).to_not match(controller) }
-      
-      describe "#failure_message" do
-        subject { super().matches?(controller); super().failure_message }
+          specify { expect(subject).to_not match(_controller) }
+          
+          describe "#failure_message" do
+            subject { super().failure_message }
 
-        specify { expect(subject).to eq "expected @assign to be assigned with an instance of #{expected_assign_class.name} but was assigned with an instance of #{actual_assign_class.name}"
- }
+            specify { expect(subject).to eq "expected @assign to be assigned with #{expected_assign_value.inspect} but was assigned with #{actual_assign_value.inspect}" }
+          end
+        end
       end
-    end
-  end
 
-  describe "#with_a_new" do
-    controller_action do
-      @assign = spec.actual_assign_class.new
-    end
+      describe "#with_a" do
+        controller_action do
+          @assign = spec.actual_assign_class.new
+        end
 
-    let(:actual_persisted?) { false }
-    let(:actual_assign_class) do
-      Class.new.tap do |klass| 
-        allow(klass).to receive(:name) { "FooClass" }
-        allow_any_instance_of(klass).to receive(:persisted?) { actual_persisted? }
-      end
-    end
+        let(:actual_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "FooClass" } } }
+        let(:expected_assign_class) { actual_assign_class }
 
-    let(:expected_assign_class) { actual_assign_class }
+        let(:matcher) { super().with_a(expected_assign_class) }
 
-    subject { assign(:assign).with_a_new(expected_assign_class) }
+        describe "#description" do
+          subject { super().description }
 
-    describe "#description" do
-      subject { super().matches?(controller); super().description }
+          specify { expect(subject).to eq "assign @assign with an instance of #{expected_assign_class.name}" }
+        end
 
-      specify { expect(subject).to eq "assign @assign with a new instance of #{expected_assign_class.name}" }
-    end
+        context "with the right class" do
+          specify { expect(subject).to match(_controller) }
+            
+          describe "#failure_message_when_negated" do
+            subject { super().failure_message_when_negated }
 
-    context "with a new object" do
-      let(:actual_persisted?) { false }
+            specify { expect(subject).to eq "expected @assign to not be assigned with an instance of #{expected_assign_class.name}" }
+          end
+        end
 
-      context "with the right class" do
-        specify { expect(subject).to match(controller) }
+        context "with the wrong class" do
+          let(:expected_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "BarClass" } } }
 
-        describe "#failure_message_when_negated" do
-          subject { super().matches?(controller); super().failure_message_when_negated }
+          specify { expect(subject).to_not match(_controller) }
+          
+          describe "#failure_message" do
+            subject { super().failure_message }
 
-          specify { expect(subject).to eq "expected @assign to not be assigned with a new instance of #{expected_assign_class.name}" }
+            specify { expect(subject).to eq "expected @assign to be assigned with an instance of #{expected_assign_class.name} but was assigned with an instance of #{actual_assign_class.name}"
+     }
+          end
         end
       end
 
-      context "with a descendant class" do
+      describe "#with_a_new" do
+        controller_action do
+          @assign = spec.actual_assign_class.new
+        end
+
+        let(:actual_persisted?) { false }
         let(:actual_assign_class) do
-          Class.new(super())
+          Class.new.tap do |klass| 
+            allow(klass).to receive(:name) { "FooClass" }
+            allow_any_instance_of(klass).to receive(:persisted?) { actual_persisted? }
+          end
         end
 
-        specify { expect(subject).to match(controller) }
+        let(:expected_assign_class) { actual_assign_class }
 
-        describe "#failure_message_when_negated" do
-          subject { super().matches?(controller); super().failure_message_when_negated }
+        let(:matcher) { super().with_a_new(expected_assign_class) }
 
-          specify { expect(subject).to eq "expected @assign to not be assigned with a new instance of #{expected_assign_class.name}" }
-        end 
-      end
+        describe "#description" do
+          subject { super().description }
 
-      context "with the wrong class" do
-        let(:expected_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "BarClass" } } }
+          specify { expect(subject).to eq "assign @assign with a new instance of #{expected_assign_class.name}" }
+        end
 
-        specify { expect(subject).to_not match(controller) }
-        
-        describe "#failure_message" do
-          subject { super().matches?(controller); super().failure_message }
+        context "with a new object" do
+          let(:actual_persisted?) { false }
 
-          specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a new instance of #{actual_assign_class.name}"
-   }
-        end
-      end
-    end
+          context "with the right class" do
+            specify { expect(subject).to match(_controller) }
 
-    context "with a persisted object" do
-      let(:actual_persisted?) { true }
+            describe "#failure_message_when_negated" do
+              subject { super().failure_message_when_negated }
 
-      context "with the right class" do
-        specify { expect(subject).to_not match(controller) }
-        
-        describe "#failure_message" do
-          subject { super().matches?(controller); super().failure_message }
+              specify { expect(subject).to eq "expected @assign to not be assigned with a new instance of #{expected_assign_class.name}" }
+            end
+          end
+
+          context "with a descendant class" do
+            let(:actual_assign_class) do
+              Class.new(super())
+            end
+
+            specify { expect(subject).to match(_controller) }
+
+            describe "#failure_message_when_negated" do
+              subject { super().failure_message_when_negated }
 
-          specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a persisted instance of #{actual_assign_class.name}"
-   }
+              specify { expect(subject).to eq "expected @assign to not be assigned with a new instance of #{expected_assign_class.name}" }
+            end 
+          end
+
+          context "with the wrong class" do
+            let(:expected_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "BarClass" } } }
+
+            specify { expect(subject).to_not match(_controller) }
+            
+            describe "#failure_message" do
+              subject { super().failure_message }
+
+              specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a new instance of #{actual_assign_class.name}"
+       }
+            end
+          end
         end
-      end
 
-      context "with the wrong class" do
-        let(:expected_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "BarClass" } } }
+        context "with a persisted object" do
+          let(:actual_persisted?) { true }
 
-        specify { expect(subject).to_not match(controller) }
-        
-        describe "#failure_message" do
-          subject { super().matches?(controller); super().failure_message }
+          context "with the right class" do
+            specify { expect(subject).to_not match(_controller) }
+            
+            describe "#failure_message" do
+              subject { super().failure_message }
+
+              specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a persisted instance of #{actual_assign_class.name}"
+       }
+            end
+          end
+
+          context "with the wrong class" do
+            let(:expected_assign_class) { Class.new.tap {|klass| allow(klass).to receive(:name) { "BarClass" } } }
+
+            specify { expect(subject).to_not match(_controller) }
+            
+            describe "#failure_message" do
+              subject { super().failure_message }
 
-          specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a persisted instance of #{actual_assign_class.name}"
-   }
+              specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a persisted instance of #{actual_assign_class.name}"
+       }
+            end
+          end
         end
       end
     end

data/spec/warp/controller_matchers/set_flash_matcher_spec.rb

@@ -1,80 +1,99 @@
 require "spec_helper"
 
 describe Warp::ControllerMatchers::SetFlashMatcher do
-  build_controller
+  with_contexts do
+    context "with implicit controller" do
+      build_controller(:controller)
+      
+      let(:_controller) { controller }
 
-  let(:flash_key) { [:notice, :error].sample }
+      subject { matcher.tap {|m| m.matches?(Object.new) } }
+    end
+    
+    context "with explicit controller" do
+      build_controller(:other_controller)
+      let(:controller) { double("fake controller") }
 
-  subject { set_flash(flash_key) }
+      let(:_controller) { other_controller }
 
-  describe "#description" do
-    subject { super().matches?(controller); super().description }
+      subject { matcher.tap {|m| m.matches?(other_controller) } }
+    end
 
-    specify { expect(subject).to eq "set flash[:#{flash_key}]" }
-  end
+    behaviour do
+      let(:flash_key) { [:notice, :error].sample }
 
-  context "with a flash set" do
-    let(:actual_flash_value) { Object.new }
+      let(:matcher) { set_flash(flash_key) }
 
-    controller_action do
-      flash[spec.flash_key] = spec.actual_flash_value
-    end
+      describe "#description" do
+        subject { super().description }
 
-    specify { expect(subject).to match(controller) }
-  
-    describe "#failure_message_when_negated" do
-      subject { super().matches?(controller); super().failure_message_when_negated }
+        specify { expect(subject).to eq "set flash[:#{flash_key}]" }
+      end
 
-      specify { expect(subject).to eq "expected flash[:#{flash_key}] to not be set" }
-    end
-  end
+      context "with a flash set" do
+        let(:actual_flash_value) { Object.new }
 
-  context "with no flash set" do
-    specify { expect(subject).to_not match(controller) }
-  
-    describe "#failure_message" do
-      subject { super().matches?(controller); super().failure_message }
+        controller_action do
+          flash[spec.flash_key] = spec.actual_flash_value
+        end
 
-      specify { expect(subject).to eq "expected flash[:#{flash_key}] to be set" }
-    end
-  end
+        specify { expect(subject).to match(_controller) }
+      
+        describe "#failure_message_when_negated" do
+          subject { super().failure_message_when_negated }
 
-  describe "#to" do
-    let(:expected_flash_value) { Object.new }
+          specify { expect(subject).to eq "expected flash[:#{flash_key}] to not be set" }
+        end
+      end
 
-    subject { set_flash(flash_key).to(expected_flash_value) }
+      context "with no flash set" do
+        specify { expect(subject).to_not match(_controller) }
+      
+        describe "#failure_message" do
+          subject { super().failure_message }
 
-    describe "#description" do
-      subject { super().matches?(controller); super().description }
+          specify { expect(subject).to eq "expected flash[:#{flash_key}] to be set" }
+        end
+      end
 
-      specify { expect(subject).to eq "set flash[:#{flash_key}] to #{expected_flash_value.inspect}" }
-    end
+      describe "#to" do
+        let(:expected_flash_value) { Object.new }
 
-    context "with expexted flash value" do
-      let(:actual_flash_value) { expected_flash_value }
+        let(:matcher) { super().to(expected_flash_value) }
 
-      controller_action do
-        flash[spec.flash_key] = spec.actual_flash_value
-      end
+        describe "#description" do
+          subject { super().description }
 
-      specify { expect(subject).to match(controller) }
-    
-      describe "#failure_message_when_negated" do
-        subject { super().matches?(controller); super().failure_message_when_negated }
+          specify { expect(subject).to eq "set flash[:#{flash_key}] to #{expected_flash_value.inspect}" }
+        end
 
-        specify { expect(subject).to eq "expected flash[:#{flash_key}] to not be set to #{expected_flash_value.inspect}" }
-      end
-    end
+        context "with expexted flash value" do
+          let(:actual_flash_value) { expected_flash_value }
 
-    context "with unexpexted flash value" do
-      let(:actual_flash_value) { Object.new }
+          controller_action do
+            flash[spec.flash_key] = spec.actual_flash_value
+          end
 
-      specify { expect(subject).to_not match(controller) }
-    
-      describe "#failure_message" do
-        subject { super().matches?(controller); super().failure_message }
+          specify { expect(subject).to match(_controller) }
+        
+          describe "#failure_message_when_negated" do
+            subject { super().failure_message_when_negated }
+
+            specify { expect(subject).to eq "expected flash[:#{flash_key}] to not be set to #{expected_flash_value.inspect}" }
+          end
+        end
+
+        context "with unexpexted flash value" do
+          let(:actual_flash_value) { Object.new }
+
+          specify { expect(subject).to_not match(_controller) }
+        
+          describe "#failure_message" do
+            subject { super().failure_message }
 
-        specify { expect(subject).to eq "expected flash[:#{flash_key}] to be set to #{expected_flash_value.inspect}" }
+            specify { expect(subject).to eq "expected flash[:#{flash_key}] to be set to #{expected_flash_value.inspect}" }
+          end
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: warp
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Thomas Drake-Brockman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-05 00:00:00.000000000 Z
+date: 2014-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,6 +91,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE
@@ -107,6 +108,7 @@ files:
 - spec/spec_helper.rb
 - spec/support/controller_helpers.rb
 - spec/support/match_helpers.rb
+- spec/support/with_contexts_helpers.rb
 - spec/warp/controller_matchers/assign_matcher_spec.rb
 - spec/warp/controller_matchers/set_flash_matcher_spec.rb
 - warp.gemspec
@@ -138,5 +140,6 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/controller_helpers.rb
 - spec/support/match_helpers.rb
+- spec/support/with_contexts_helpers.rb
 - spec/warp/controller_matchers/assign_matcher_spec.rb
 - spec/warp/controller_matchers/set_flash_matcher_spec.rb