rspec-power_assert 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f985fde5f03e7787b91ad69cf8849ceb7083d227
-  data.tar.gz: fe7c3b67f117838f0e1d0abae1367a5aa2fc5108
+  metadata.gz: 5693810a622bd1930d357d53d757219f3f1f0659
+  data.tar.gz: b31892819f2ad71874546590b8c856b51e9a0cd1
 SHA512:
-  metadata.gz: f2e0b10de6fc623cf9e4ac01a42eeee3f524a0e5774b0eacd4093237686d2fa5947591bdc7509593a918797ce6e30791b06db6026d38df29f3ca344215b17205
-  data.tar.gz: 1801ce6325718bfd027579ee8514ee784d79fe137aa4efbad5aa943bd27d86dc317e499de68f2a75356693106a4c15358d32ef95de5a61cba2e5c7d1e2b8d706
+  metadata.gz: f9756ee18ab14800437c0fad0e43f9aa08a089d74760a5b711efa6480c8e69567107262a94f820e91e3bc4d3a81e096611cd9208417fd257fa5bab7b7bd15432
+  data.tar.gz: db669065a59ce0894ee10f9dcdf99c0551824cb0af74dc0cafbbcd8ac4a1efc184250c3361082d633f437794c111b91dd01b9fab92647be2a47f6a5e921541ee

data/.rspec

@@ -1,2 +1,3 @@
+-r power_assert
 --format documentation
 --color

data/README.md

@@ -1,4 +1,8 @@
 # Rspec::PowerAssert
+[![Gem Version](https://badge.fury.io/rb/rspec-power_assert.svg)](http://badge.fury.io/rb/rspec-power_assert)
+
+## Support
+- RSpec 2.14 or later
 
 ## Installation
 
@@ -18,53 +22,137 @@ Or install it yourself as:
 
 ## Usage
 
-### spec
+First, add require option to `.rspec`
+
+```
+-r power_assert
+```
+
+Use `ExampleGroup.it_is_asserted_by` or `ExampleGroup#is_asserted_by`
+
 ```ruby
-describe Array do
-  describe "#map" do
-    let(:array) { [1, 2, 3] }
-    subject { %w(a b c) }
+describe Object do
+  it_is_asserted_by { a == b }
 
-    before do
-      @array = [1, 2, 3]
-    end
+  it do
+    is_asserted_by { a == b }
+  end
+end
+```
 
-    it do
-      is_asserted_by { subject.map(&:upcase) == array }
-    end
+## Config
 
-    it do
-      upcased = subject.map(&:upcase)
-      upcased.pop
-      is_asserted_by { upcased == @array }
-    end
+### verbose_successful_report
 
-    it do
-      is_expected.to eq %w(a b c)
-      is_asserted_by { subject.map(&:upcase) == %w(A B C) }
-    end
+```ruby
+RSpec::PowerAssert.verbose_successful_report = true
+```
+
+If it set true, Successful Example reports with `power_assert` outputs.
+If it set false, Successful Example reports without `power_assert` outputs.
+
+Default is *true*.
 
-    it "should transform array" do
-      is_expected.to eq %w(a b c)
-      is_asserted_by { subject.map(&:upcase) == %w(A B C) }
+## Sample
+### spec sample
+```ruby
+describe Rspec::PowerAssert do
+  describe Array do
+    describe "#map" do
+      let(:array) { [1, 2, 3] }
+      subject { %w(a b c) }
+
+      before do
+        @array = [1, 2, 3]
+      end
+
+      it do
+        is_asserted_by { subject.map(&:upcase) == array }
+      end
+
+      it do
+        is_asserted_by {
+          subject.map(&:upcase) == array
+        }
+      end
+
+      it do
+        is_asserted_by { subject.map(&:upcase) == %w(A B C) }
+      end
+
+      it do
+        is_asserted_by {
+          subject.map(&:upcase) == %w(A B C)
+        }
+      end
+
+      it do
+        upcased = subject.map(&:upcase)
+        upcased.pop
+        is_asserted_by { upcased == @array }
+      end
+
+      it "should transform array" do
+        is_expected.to eq %w(a b c)
+        is_asserted_by { subject.map(&:upcase) == %w(A B C) }
+      end
+
+      it "should transform array (failed)" do
+        is_asserted_by { subject.map(&:upcase) == %w(A B) }
+      end
+
+      it_is_asserted_by { subject.map(&:upcase) == %w(A B C) }
+
+      it_is_asserted_by { subject.map(&:upcase) == %w(A B) }
+
+      it_is_asserted_by do
+        subject.map(&:upcase) == %w(A B C)
+      end
+
+      it_is_asserted_by "succ each element" do
+        subject.map(&:succ) == ["b", "c", "e"] + @array
+      end
     end
   end
 end
 ```
 
-### output
+### output sample
 ```
 Rspec::PowerAssert
   Array
     #map
       example at ./spec/rspec/power_assert_spec.rb:13 (FAILED - 1)
       example at ./spec/rspec/power_assert_spec.rb:17 (FAILED - 2)
-      is_asserted_by { subject.map(&:upcase) == %w(A B C) }
+      should
+        be asserted by { subject.map(&:upcase) == %w(A B C) }
+                         |       |             |
+                         |       |             true
+                         |       ["A", "B", "C"]
+                         ["a", "b", "c"]
+      should
+        be asserted by { subject.map(&:upcase) == %w(A B C) }
                          |       |             |
                          |       |             true
                          |       ["A", "B", "C"]
                          ["a", "b", "c"]
+      example at ./spec/rspec/power_assert_spec.rb:33 (FAILED - 3)
       should transform array
+      should transform array (failed) (FAILED - 4)
+      should
+        be asserted by { subject.map(&:upcase) == %w(A B C) }
+                         |       |             |
+                         |       |             true
+                         |       ["A", "B", "C"]
+                         ["a", "b", "c"]
+      example at ./spec/rspec/power_assert_spec.rb:50 (FAILED - 5)
+      should
+        be asserted by { subject.map(&:upcase) == %w(A B C) }
+                         |       |             |
+                         |       |             true
+                         |       ["A", "B", "C"]
+                         ["a", "b", "c"]
+      succ each element (FAILED - 6)
 
 Failures:
 
@@ -76,26 +164,78 @@ Failures:
                                 |       |             false
                                 |       ["A", "B", "C"]
                                 ["a", "b", "c"]
-     # ./lib/rspec/power_assert.rb:19:in `is_asserted_by'
+     # ./lib/rspec/power_assert.rb:57:in `handle_result_and_message'
+     # ./lib/rspec/power_assert.rb:31:in `is_asserted_by'
      # ./spec/rspec/power_assert_spec.rb:14:in `block (4 levels) in <top (required)>'
 
   2) Rspec::PowerAssert Array#map
+     Failure/Error: is_asserted_by {
+                 subject.map(&:upcase) == array
+                 |       |             |  |
+                 |       |             |  [1, 2, 3]
+                 |       |             false
+                 |       ["A", "B", "C"]
+                 ["a", "b", "c"]
+     # ./lib/rspec/power_assert.rb:57:in `handle_result_and_message'
+     # ./lib/rspec/power_assert.rb:31:in `is_asserted_by'
+     # ./spec/rspec/power_assert_spec.rb:18:in `block (4 levels) in <top (required)>'
+
+  3) Rspec::PowerAssert Array#map
      Failure/Error: is_asserted_by { upcased == @array }
                is_asserted_by { upcased == @array }
                                 |       |  |
                                 |       |  [1, 2, 3]
                                 |       false
                                 ["A", "B"]
-     # ./lib/rspec/power_assert.rb:19:in `is_asserted_by'
-     # ./spec/rspec/power_assert_spec.rb:20:in `block (4 levels) in <top (required)>'
-
-Finished in 0.00455 seconds (files took 0.10298 seconds to load)
-4 examples, 2 failures
+     # ./lib/rspec/power_assert.rb:57:in `handle_result_and_message'
+     # ./lib/rspec/power_assert.rb:31:in `is_asserted_by'
+     # ./spec/rspec/power_assert_spec.rb:36:in `block (4 levels) in <top (required)>'
+
+  4) Rspec::PowerAssert Array#map should transform array (failed)
+     Failure/Error: is_asserted_by { subject.map(&:upcase) == %w(A B) }
+               is_asserted_by { subject.map(&:upcase) == %w(A B) }
+                                |       |             |
+                                |       |             false
+                                |       ["A", "B", "C"]
+                                ["a", "b", "c"]
+     # ./lib/rspec/power_assert.rb:57:in `handle_result_and_message'
+     # ./lib/rspec/power_assert.rb:31:in `is_asserted_by'
+     # ./spec/rspec/power_assert_spec.rb:45:in `block (4 levels) in <top (required)>'
+
+  5) Rspec::PowerAssert Array#map
+     Failure/Error: it_is_asserted_by { subject.map(&:upcase) == %w(A B) }
+             it_is_asserted_by { subject.map(&:upcase) == %w(A B) }
+                                 |       |             |
+                                 |       |             false
+                                 |       ["A", "B", "C"]
+                                 ["a", "b", "c"]
+     # ./lib/rspec/power_assert.rb:57:in `handle_result_and_message'
+     # ./lib/rspec/power_assert.rb:44:in `evaluate_example'
+     # ./spec/rspec/power_assert_spec.rb:50:in `block in it_is_asserted_by'
+
+  6) Rspec::PowerAssert Array#map succ each element
+     Failure/Error: it_is_asserted_by "succ each element" do
+               subject.map(&:succ) == ["b", "c", "e"] + @array
+               |       |           |                    |
+               |       |           |                    [1, 2, 3]
+               |       |           false
+               |       ["b", "c", "d"]
+               ["a", "b", "c"]
+     # ./lib/rspec/power_assert.rb:57:in `handle_result_and_message'
+     # ./lib/rspec/power_assert.rb:44:in `evaluate_example'
+     # ./spec/rspec/power_assert_spec.rb:56:in `block in it_is_asserted_by'
+
+Finished in 0.01725 seconds (files took 0.12235 seconds to load)
+11 examples, 6 failures
 
 Failed examples:
 
 rspec ./spec/rspec/power_assert_spec.rb:13 # Rspec::PowerAssert Array#map
 rspec ./spec/rspec/power_assert_spec.rb:17 # Rspec::PowerAssert Array#map
+rspec ./spec/rspec/power_assert_spec.rb:33 # Rspec::PowerAssert Array#map
+rspec ./spec/rspec/power_assert_spec.rb:44 # Rspec::PowerAssert Array#map should transform array (failed)
+rspec ./spec/rspec/power_assert_spec.rb:50 # Rspec::PowerAssert Array#map
+rspec ./spec/rspec/power_assert_spec.rb:56 # Rspec::PowerAssert Array#map succ each element
 ```
 
 ## Contributing

data/lib/rspec/power_assert.rb

@@ -2,21 +2,64 @@ require "rspec/power_assert/version"
 require "rspec/core"
 require "power_assert"
 
+module PowerAssert
+  class << self
+    def rspec_start(assertion_proc, assertion_method: nil)
+      yield RSpecContext.new(assertion_proc, assertion_method)
+    end
+  end
+
+  class RSpecContext < Context
+    # hack for context changing
+    def do_yield
+      @trace.enable do
+        @base_caller_length = caller_locations.length + 2
+        yield
+      end
+    end
+  end
+  private_constant :RSpecContext
+end
+
 module RSpec
   module PowerAssert
+    @verbose_successful_report = true
+
+    def self.verbose_successful_report
+      !!@verbose_successful_report
+    end
+
+    def self.verbose_successful_report=(verbose)
+      @verbose_successful_report = verbose
+    end
+
     def is_asserted_by(&blk)
-      result = nil
-      msg = nil
-      ::PowerAssert.start(blk, assertion_method: __method__) do |tp|
-        result = tp.yield
-        msg = tp.message_proc.call
+      result, msg = ::PowerAssert.start(blk, assertion_method: __method__) do |tp|
+        [tp.yield, tp.message_proc.call]
+      end
+
+      handle_result_and_message(result, msg, __method__)
+    end
+
+    private
+
+    def evaluate_example(method_name, &blk)
+      # hack for context changing
+      pr = -> { self.instance_exec(&blk) }
+
+      result, msg = ::PowerAssert.rspec_start(pr, assertion_method: method_name) do |tp|
+        [tp.yield, tp.message_proc.call]
       end
 
+      handle_result_and_message(result, msg, method_name)
+    end
+
+    def handle_result_and_message(result, msg, method_name)
       if result
-        RSpec::Matchers.last_matcher = DummyAssertionMatcher.new(msg)
+        RSpec::Matchers.last_matcher = DummyAssertionMatcher.new(msg, method_name.to_s)
 
         if RSpec::Matchers.respond_to?(:last_should=)
-          RSpec::Matchers.last_should = "" # for RSpec 2
+          RSpec::Matchers.last_should = :should # for RSpec 2
         else
           RSpec::Matchers.last_expectation_handler = DummyExpectationHandler # for RSpec 3
         end
@@ -28,23 +71,66 @@ module RSpec
     # for generating description
     class DummyExpectationHandler
       def self.verb
-        ""
+        "should"
       end
     end
+    private_constant :DummyExpectationHandler
 
-    # for generating description
     class DummyAssertionMatcher
-      def initialize(msg)
+      INDENT_LEVEL = 12
+
+      def initialize(msg, method_name)
         @msg = msg
+        @assertion_method = method_name
       end
 
       def description
-        "\n#{@msg}"
+        if @msg =~ /^(\s*)#{@assertion_method}/
+          output = @msg.sub(/^(\s*#{@assertion_method})/, "#{display_message}")
+          offset = display_message.length - $1.length
+        else
+          output = @msg.sub(/^(\s*)(\S.*?)$/, "#{display_message} { \\2 }")
+          offset = display_message.length + 3 - $1.length
+        end
+
+        "#{$/}#{build_message(output, offset)}"
+      end
+
+      private
+
+      def build_message(output, offset)
+        if RSpec::PowerAssert.verbose_successful_report
+          output.each_line.with_index.map do |l, idx|
+            next l if idx == 0
+
+            if offset > 1
+              " " * offset + l
+            else
+              l.each_char.drop(offset.abs).join
+            end
+          end.join
+        else
+          output.each_line.first
+        end
       end
+
+      def display_message
+        " " * INDENT_LEVEL + "be asserted by"
+      end
+    end
+    private_constant :DummyAssertionMatcher
+  end
+
+  module PowerAssertExtensions
+    def it_is_asserted_by(description = nil, &blk)
+      file, lineno = blk.source_location
+      cmd = description ? "it(description)" : "specify"
+      eval %{#{cmd} do evaluate_example("#{__method__}", &blk) end}, binding, file, lineno
     end
   end
 end
 
 RSpec.configure do |config|
+  config.extend RSpec::PowerAssertExtensions
   config.include RSpec::PowerAssert
 end

data/lib/rspec/power_assert/version.rb

@@ -1,5 +1,5 @@
 module Rspec
   module PowerAssert
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/spec/rspec/power_assert_spec.rb

@@ -15,20 +15,47 @@ describe Rspec::PowerAssert do
       end
 
       it do
-        upcased = subject.map(&:upcase)
-        upcased.pop
-        is_asserted_by { upcased == @array }
+        is_asserted_by {
+          subject.map(&:upcase) == array
+        }
       end
 
       it do
-        is_expected.to eq %w(a b c)
         is_asserted_by { subject.map(&:upcase) == %w(A B C) }
       end
 
+      it do
+        is_asserted_by {
+          subject.map(&:upcase) == %w(A B C)
+        }
+      end
+
+      it do
+        upcased = subject.map(&:upcase)
+        upcased.pop
+        is_asserted_by { upcased == @array }
+      end
+
       it "should transform array" do
         is_expected.to eq %w(a b c)
         is_asserted_by { subject.map(&:upcase) == %w(A B C) }
       end
+
+      it "should transform array (failed)" do
+        is_asserted_by { subject.map(&:upcase) == %w(A B) }
+      end
+
+      it_is_asserted_by { subject.map(&:upcase) == %w(A B C) }
+
+      it_is_asserted_by { subject.map(&:upcase) == %w(A B) }
+
+      it_is_asserted_by do
+        subject.map(&:upcase) == %w(A B C)
+      end
+
+      it_is_asserted_by "succ each element" do
+        subject.map(&:succ) == ["b", "c", "e"] + @array
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-power_assert
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - joker1007
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-27 00:00:00.000000000 Z
+date: 2014-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: power_assert