power_assert 1.1.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07f2f2b9a7929fed3e16cadeba67319c6e9145c8426d07c4b9294b7f03898a9a
-  data.tar.gz: 8064ab656664de1990131a17d85acb16ddab86ecff89758bb1733a23eb64abd9
+  metadata.gz: 3d3d0e5985a6bb521449ef71f42225297f74cd879017bc0fa9fc43e1c7a612f4
+  data.tar.gz: 63dbbb1eb926c54fcefc1fb3933f2a5bd7970d3e98a9074d103d378492581d49
 SHA512:
-  metadata.gz: 6152b43a6692614b979763d426f48039f1b428375b2d5a0e9f3d2776f4c5b90129ce439ec0325c2f0dd6d027da2e719a1681b33a9d1b1f3da68fb2df55bf321c
-  data.tar.gz: 72744598d1a357cea0b4fac9629bdbbc513fdfe8290c6bc4bf5399cbe2f96421172bcf10edc46ebba2f24852ff5d1ce5c3e13e8d3449141a92834dabdfe3f96a
+  metadata.gz: 72392cf0e4ab54507b191a3552664531933c554f3aa94883d75cea07b3c37d49c969ec6c06c0ff37b8704e7d7de5b5e500dc251d8de8f17561253e635dfc2f45
+  data.tar.gz: f6b2be0b7dfa3e06a6f28bdec0dae7b63150cffc9f47a5499f07ffd94f1cf7b332d5d2b2796946cbddded9931676263a8064874697dbc9ee026e6a05b46eb7f4

data/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+on: [ push, pull_request ]
+
+jobs:
+  test:
+    name: >-
+      Test (${{ matrix.ruby-version }} / ${{ matrix.os }} / TEST_SYMLINK: ${{ matrix.TEST_SYMLINK }})
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: [ '3.0', 2.7, 2.6, 2.5, head ]
+        os: [ ubuntu-latest, macos-latest ]
+        TEST_SYMLINK: [ yes, no ]
+    runs-on: ${{ matrix.os }}
+    env:
+      TEST_SYMLINK: ${{ matrix.TEST_SYMLINK }}
+    continue-on-error: ${{ matrix.ruby-version == 'head' }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run before_script
+        run: |
+          bundle exec rake before_script
+      - name: Run the test suite
+        run: |
+          bundle exec rake
+      - name: Run after_script
+        run: |
+          bundle exec rake after_script

data/README.md

@@ -0,0 +1,96 @@
+# power_assert
+## About
+Power Assert shows each value of variables and method calls in the expression.
+It is useful for testing, providing which value wasn't correct when the condition is not satisfied.
+
+    Failure:
+       assert { 3.times.to_a.include?(3) }
+                  |     |    |
+                  |     |    false
+                  |     [0, 1, 2]
+                  #<Enumerator: 3:times>
+
+## Related Projects
+In general, you don't need to use this library directly.
+Use following test frameworks or extensions instead.
+
+* [test-unit](https://github.com/test-unit/test-unit)(>= 3.0.0)
+  * [Document](http://test-unit.github.io/test-unit/en/Test/Unit/Assertions.html#assert-instance_method)
+* [minitest-power_assert](https://github.com/hsbt/minitest-power_assert)
+* [rspec-power_assert](https://github.com/joker1007/rspec-power_assert)
+* [pry-power_assert](https://github.com/yui-knk/pry-power_assert)
+* [pry-byebug-power_assert](https://github.com/k-tsj/pry-byebug-power_assert)
+* [power_p](https://github.com/k-tsj/power_p)
+
+## Requirement
+* CRuby 2.5+
+
+## Configuration
+To colorize output messages, add <code>require "power_assert/colorize"</code> to your code.
+(It requires CRuby 3.0.1+ or irb 1.3.1+)
+
+## Known Limitations
+* Expressions must be put in one line. Expressions with folded long lines produce nothing report, e.g.:
+
+```ruby
+assert do
+  # reported
+  func(foo: 0123456789, bar: "abcdefg")
+end
+
+assert do
+  # won't be reported
+  func(foo: 0123456789,
+       bar: "abcdefg")
+end
+```
+
+* Expressions must have one or more method call. Expressions with no method call produce nothing report, e.g.:
+
+```ruby
+val = false
+assert do
+  # reported
+  val == true
+end
+
+assert do
+  # won't be reported
+  val
+end
+```
+
+* Returned values from accessor methods, method missing, or "super" produce nothing report, e.g:
+
+```ruby
+class Foo
+  attr_accessor :val
+end
+foo = Foo.new
+foo.val = false
+
+assert do
+  # reported (only the value of "foo" and the literal "true")
+  foo.val == true
+end
+
+assert do
+  # won't be reported
+  foo.val
+end
+```
+
+* Expressions should not have conditional branches. Expressions with such conditional codes may produce nothing report, e.g.:
+
+```ruby
+condition = true
+expected = false
+actual = true
+assert do
+  # this will fail but nothing reported
+  condition ? expected == actual : expected == actual
+end
+```
+
+## Reference
+* [Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck](https://speakerdeck.com/k_tsj/power-assert-in-ruby)

data/lib/power_assert.rb

@@ -7,7 +7,7 @@ begin
     captured = false
     TracePoint.new(:return, :c_return) do |tp|
       captured = true
-      unless tp.binding and tp.return_value
+      unless tp.binding and tp.return_value and tp.callee_id
         raise ''
       end
     end.enable { __id__ }
@@ -17,22 +17,15 @@ rescue
   raise LoadError, 'Fully compatible TracePoint API required'
 end
 
-require 'power_assert/version'
-require 'power_assert/configuration'
 require 'power_assert/context'
+require 'power_assert/configuration'
+require 'power_assert/version'
 
 module PowerAssert
   POWER_ASSERT_LIB_DIR = File.dirname(caller_locations(1, 1).first.path)
   INTERNAL_LIB_DIRS = {PowerAssert => POWER_ASSERT_LIB_DIR}
   private_constant :POWER_ASSERT_LIB_DIR, :INTERNAL_LIB_DIRS
 
-  # For backward compatibility
-  IGNORED_LIB_DIRS = INTERNAL_LIB_DIRS
-  private_constant :IGNORED_LIB_DIRS
-  if respond_to?(:deprecate_constant)
-    deprecate_constant :IGNORED_LIB_DIRS
-  end
-
   class << self
     def start(assertion_proc_or_source, assertion_method: nil, source_binding: TOPLEVEL_BINDING)
       if respond_to?(:clear_global_method_cache, true)

data/lib/power_assert/colorize.rb

@@ -1,9 +1,7 @@
-warn 'power_assert/colorize is experimental'
-
 require 'power_assert/configuration'
 
 PowerAssert.configure do |c|
   c.lazy_inspection = true
-  c._colorize_message = true
-  c._use_pp = true
+  c.colorize_message = true
+  c.inspector = :pp
 end

data/lib/power_assert/configuration.rb

@@ -1,7 +1,7 @@
 module PowerAssert
   class << self
     def configuration
-      @configuration ||= Configuration[false, false, true, false, false]
+      @configuration ||= Configuration[false, true, false, :p]
     end
 
     def configure
@@ -9,35 +9,35 @@ module PowerAssert
     end
   end
 
-  SUPPORT_ALIAS_METHOD = TracePoint.public_method_defined?(:callee_id)
-  private_constant :SUPPORT_ALIAS_METHOD
-
-  class Configuration < Struct.new(:lazy_inspection, :_trace_alias_method, :_redefinition, :_colorize_message, :_use_pp)
-    def _trace_alias_method=(bool)
-      super
-      if SUPPORT_ALIAS_METHOD
-        warn 'power_assert: _trace_alias_method option is obsolete. You no longer have to set it.'
-      end
-    end
-
-    def _colorize_message=(bool)
+  class Configuration < Struct.new(:lazy_inspection, :_redefinition, :colorize_message, :inspector)
+    def colorize_message=(bool)
       if bool
-        require 'pry'
+        require 'irb/color'
+        if inspector == :pp
+          require 'irb/color_printer'
+        end
       end
       super
     end
 
     def lazy_inspection=(bool)
       unless bool
-        raise 'lazy_inspection option must be enabled when using pp' if _use_pp
+        raise 'lazy_inspection option must be enabled when using pp' if inspector == :pp
       end
       super
     end
 
-    def _use_pp=(bool)
-      if bool
+    def inspector=(inspector)
+      case inspector
+      when :pp
         raise 'lazy_inspection option must be enabled when using pp' unless lazy_inspection
         require 'pp'
+        if colorize_message
+          require 'irb/color_printer'
+        end
+      when :p
+      else
+        raise ArgumentError, "unknown inspector: #{inspector}"
       end
       super
     end

data/lib/power_assert/context.rb

@@ -12,32 +12,30 @@ module PowerAssert
       @target_thread = Thread.current
       method_id_set = nil
       @return_values = []
-      trace_alias_method = PowerAssert.configuration._trace_alias_method
       @trace_return = TracePoint.new(:return, :c_return) do |tp|
-        begin
-          unless method_id_set
-            next unless Thread.current == @target_thread
-            method_id_set = @parser.method_id_set
-          end
-          method_id = SUPPORT_ALIAS_METHOD                      ? tp.callee_id :
-                      trace_alias_method && tp.event == :return ? tp.binding.eval('::Kernel.__callee__') :
-                                                                  tp.method_id
-          next if ! method_id_set[method_id]
-          next if tp.event == :c_return and
-                  not (@parser.lineno == tp.lineno and @parser.path == tp.path)
-          locs = PowerAssert.app_caller_locations
-          diff = locs.length - base_caller_length
-          if (tp.event == :c_return && diff == 1 || tp.event == :return && diff <= 2) and Thread.current == @target_thread
-            idx = -(base_caller_length + 1)
-            if @parser.path == locs[idx].path and @parser.lineno == locs[idx].lineno
-              val = PowerAssert.configuration.lazy_inspection ?
-                tp.return_value :
-                InspectedValue.new(SafeInspectable.new(tp.return_value).inspect)
-              @return_values << Value[method_id.to_s, val, locs[idx].lineno, nil]
-            end
+        unless method_id_set
+          next unless Thread.current == @target_thread
+          method_id_set = @parser.method_id_set
+        end
+        method_id = tp.callee_id
+        next if ! method_id_set[method_id]
+        next if tp.event == :c_return and
+                not (@parser.lineno == tp.lineno and @parser.path == tp.path)
+        locs = PowerAssert.app_caller_locations
+        diff = locs.length - base_caller_length
+        if (tp.event == :c_return && diff == 1 || tp.event == :return && diff <= 2) and Thread.current == @target_thread
+          idx = -(base_caller_length + 1)
+          if @parser.path == locs[idx].path and @parser.lineno == locs[idx].lineno
+            val = PowerAssert.configuration.lazy_inspection ?
+              tp.return_value :
+              InspectedValue.new(SafeInspectable.new(tp.return_value).inspect)
+            @return_values << Value[method_id.to_s, val, locs[idx].lineno, nil]
           end
-        rescue Exception => e
-          warn "power_assert: [BUG] Failed to trace: #{e.class}: #{e.message}"
+        end
+      rescue Exception => e
+        warn "power_assert: [BUG] Failed to trace: #{e.class}: #{e.message}"
+        if e.respond_to?(:full_message)
+          warn e.full_message.gsub(/^/, 'power_assert:     ')
         end
       end
     end
@@ -58,8 +56,8 @@ module PowerAssert
     end
 
     def build_assertion_message(parser, return_values)
-      if PowerAssert.configuration._colorize_message
-        line = Pry::Code.new(parser.line).highlighted
+      if PowerAssert.configuration.colorize_message
+        line = IRB::Color.colorize_code(parser.line, ignore_error: true)
       else
         line = parser.line
       end
@@ -90,12 +88,12 @@ module PowerAssert
       end.join
       lines = []
       lines << line.chomp
-      lines << sprintf(fmt, vals.each_with_object({}) {|v, h| h[v.display_offset.to_s.to_sym] = '|' }).chomp
+      lines << sprintf(fmt, vals.each_with_object({}) {|v, h| h[:"#{v.display_offset}"] = '|' }).chomp
       vals.each do |i|
-        inspected_val = SafeInspectable.new(Formatter.new(i.value, i.display_offset)).inspect
+        inspected_val = SafeInspectable.new(Inspector.new(i.value, i.display_offset)).inspect
         inspected_val.each_line do |l|
           map_to = vals.each_with_object({}) do |j, h|
-            h[j.display_offset.to_s.to_sym] = [l, '|', ' '][i.display_offset <=> j.display_offset]
+            h[:"#{j.display_offset}"] = [l, '|', ' '][i.display_offset <=> j.display_offset]
           end
           lines << encoding_safe_rstrip(sprintf(fmt, map_to))
         end

data/lib/power_assert/enable_tracepoint_events.rb

@@ -2,85 +2,52 @@ require 'power_assert/configuration'
 
 if defined?(RubyVM)
   if PowerAssert.configuration._redefinition
-    if RUBY_VERSION == '2.3.2'
-      warn 'power_assert: It is strongly recommended that you use Ruby 2.3.3 or later which fixes regression on 2.3.2.'
-      warn 'power_assert: See https://www.ruby-lang.org/en/news/2016/11/21/ruby-2-3-3-released/ for more details.'
-    end
-
-    verbose = $VERBOSE
-    begin
-      $VERBOSE = nil
-      module PowerAssert
-        # set redefined flag
-        basic_classes = [
-          Fixnum, Float, String, Array, Hash, Bignum, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
-        ]
-
-        basic_operators = [
-          :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=,
-          :length, :size, :empty?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min
-        ]
-
-        bug11182 = Class.new do
-          def fixed?
-            true
-          end
-        end
-
-        refine bug11182 do
-          def fixed?
+    module PowerAssert
+      # set redefined flag
+      basic_classes = [
+        Integer, Float, String, Array, Hash, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
+      ]
+
+      verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        [:Fixnum, :Bignum].each do |c|
+          if Object.const_defined?(c) and (c = Object.const_get(c)) != Integer
+            basic_classes << c
           end
         end
+      ensure
+        $VERBOSE = verbose
+      end
 
-        _ = Class.new(bug11182) do
-          alias _fixed? fixed?
-          protected :_fixed?
-        end
-
-        if (bug11182.new.fixed? rescue false)
-          basic_classes.each do |klass|
-            basic_operators.each do |bop|
-              if klass.public_method_defined?(bop)
-                refine(klass) do
-                  define_method(bop) {}
-                end
-              end
-            end
-          end
-        else
-          # workaround for https://bugs.ruby-lang.org/issues/11182
-          basic_classes.each do |klass|
-            basic_operators.each do |bop|
-              if klass.public_method_defined?(bop)
-                klass.ancestors.find {|i| i.instance_methods(false).index(bop) }.module_eval do
-                  public bop
-                end
-              end
-            end
-          end
+      basic_operators = [
+        :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=,
+        :length, :size, :empty?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min, :nil?
+      ]
 
-          refine Symbol do
-            def ==
+      basic_classes.each do |klass|
+        basic_operators.each do |bop|
+          if klass.public_method_defined?(bop)
+            refine(klass) do
+              define_method(bop) {}
             end
           end
         end
+      end
 
-        # bypass check_cfunc
-        refine BasicObject do
-          def !
-          end
+      # bypass check_cfunc
+      refine BasicObject do
+        def !
+        end
 
-          def ==
-          end
+        def ==
         end
+      end
 
-        refine Module do
-          def ==
-          end
+      refine Module do
+        def ==
         end
       end
-    ensure
-      $VERBOSE = verbose
     end
   end
 

data/lib/power_assert/inspector.rb

@@ -1,4 +1,5 @@
 require 'power_assert/configuration'
+require 'io/console/size'
 
 module PowerAssert
   class InspectedValue
@@ -34,22 +35,22 @@ module PowerAssert
   end
   private_constant :SafeInspectable
 
-  class Formatter
+  class Inspector
     def initialize(value, indent)
       @value = value
       @indent = indent
     end
 
     def inspect
-      if PowerAssert.configuration._colorize_message
-        if PowerAssert.configuration._use_pp
-          width = [Pry::Terminal.width! - 1 - @indent, 10].max
-          Pry::ColorPrinter.pp(@value, '', width)
+      if PowerAssert.configuration.colorize_message
+        if PowerAssert.configuration.inspector == :pp
+          width = [IO.console_size[1] - 1 - @indent, 10].max
+          IRB::ColorPrinter.pp(@value, '', width)
         else
-          Pry::Code.new(@value.inspect).highlighted
+          IRB::Color.colorize_code(@value.to_s, ignore_error: true)
         end
       else
-        if PowerAssert.configuration._use_pp
+        if PowerAssert.configuration.inspector == :pp
           PP.pp(@value, '')
         else
           @value.inspect
@@ -57,5 +58,5 @@ module PowerAssert
       end
     end
   end
-  private_constant :Formatter
+  private_constant :Inspector
 end

data/lib/power_assert/version.rb

@@ -1,3 +1,3 @@
 module PowerAssert
-  VERSION = "1.1.4"
+  VERSION = "2.0.0"
 end

data/power_assert.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |s|
   s.version     = PowerAssert::VERSION
   s.authors     = ['Kazuki Tsujimoto']
   s.email       = ['kazuki@callcc.net']
-  s.homepage    = 'https://github.com/k-tsj/power_assert'
+  s.homepage    = 'https://github.com/ruby/power_assert'
   s.summary     = "Power Assert for Ruby"
-  s.description = "Power Assert for Ruby. Power Assert shows each value of variables and method calls in the expression. It is useful for testing, providing which value wasn't correct when the condition is not satisfied."
+  s.description = "Power Assert shows each value of variables and method calls in the expression. It is useful for testing, providing which value wasn't correct when the condition is not satisfied."
 
   s.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features|benchmark)/})
@@ -22,10 +22,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'bundler'
-  s.add_development_dependency 'pry'
+  s.add_development_dependency 'irb', '>= 1.3.1'
   s.add_development_dependency 'byebug'
   s.add_development_dependency 'benchmark-ips'
-  s.extra_rdoc_files = ['README.rdoc']
-  s.rdoc_options     = ['--main', 'README.rdoc']
-  s.licenses         = ['2-clause BSDL', "Ruby's"]
+  s.extra_rdoc_files = ['README.md']
+  s.rdoc_options     = ['--main', 'README.md']
+  s.licenses         = ['BSD-2-Clause', "Ruby"]
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: power_assert
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Kazuki Tsujimoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-24 00:00:00.000000000 Z
+date: 2021-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -67,19 +67,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: irb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.1
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -108,23 +108,23 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Power Assert for Ruby. Power Assert shows each value of variables and
-  method calls in the expression. It is useful for testing, providing which value
-  wasn't correct when the condition is not satisfied.
+description: Power Assert shows each value of variables and method calls in the expression.
+  It is useful for testing, providing which value wasn't correct when the condition
+  is not satisfied.
 email:
 - kazuki@callcc.net
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
 - BSDL
 - COPYING
 - Gemfile
 - LEGAL
-- README.rdoc
+- README.md
 - Rakefile
 - bin/console
 - bin/setup
@@ -137,15 +137,15 @@ files:
 - lib/power_assert/parser.rb
 - lib/power_assert/version.rb
 - power_assert.gemspec
-homepage: https://github.com/k-tsj/power_assert
+homepage: https://github.com/ruby/power_assert
 licenses:
-- 2-clause BSDL
-- Ruby's
+- BSD-2-Clause
+- Ruby
 metadata: {}
 post_install_message: 
 rdoc_options:
 - "--main"
-- README.rdoc
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -159,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Power Assert for Ruby

data/.travis.yml

@@ -1,24 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.0.0-p648
-  - 2.1.10
-  - 2.2.10
-  - 2.3.8
-  - 2.4.5
-  - 2.5.3
-  - 2.6.0
-  - ruby-head
-env:
-  - TEST_SYMLINK="no"
-  - TEST_SYMLINK="yes"
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-before_install:
-  - gem install rubygems-update -v '<3' && update_rubygems
-  - gem update bundler
-before_script:
-  - bundle exec rake before_script
-after_script:
-  - bundle exec rake after_script

data/README.rdoc

@@ -1,81 +0,0 @@
-= power_assert
-== About
-Power Assert for Ruby.
-
-Power Assert shows each value of variables and method calls in the expression.
-It is useful for testing, providing which value wasn't correct when the condition is not satisfied.
-
-    Failure:
-       assert { 3.times.to_a.include?(3) }
-                  |     |    |
-                  |     |    false
-                  |     [0, 1, 2]
-                  #<Enumerator: 3:times>
-
-== Related Projects
-In general, you don't need to use this library directly.
-Use following test frameworks or extensions instead.
-
-* {test-unit}[https://github.com/test-unit/test-unit](>= 3.0.0)
-  * {Document}[http://test-unit.github.io/test-unit/en/Test/Unit/Assertions.html#assert-instance_method]
-* {minitest-power_assert}[https://github.com/hsbt/minitest-power_assert]
-* {rspec-power_assert}[https://github.com/joker1007/rspec-power_assert]
-* {pry-power_assert}[https://github.com/yui-knk/pry-power_assert]
-* {pry-byebug-power_assert}[https://github.com/k-tsj/pry-byebug-power_assert]
-* {power_p}[https://github.com/k-tsj/power_p]
-
-== Requirement
-* CRuby 2.0.0 or later
-
-== Reference
-* {Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck}[https://speakerdeck.com/k_tsj/power-assert-in-ruby]
-
-== Known Limitations
-* Expressions must be put in one line. Expressions with folded long lines produce nothing report, e.g.:
-    assert do
-      # reported
-      func(foo: 0123456789, bar: "abcdefg")
-    end
-
-    assert do
-      # won't be reported
-      func(foo: 0123456789,
-           bar: "abcdefg")
-    end
-* Expressions must have one or more method call. Expressions with no method call produce nothing report, e.g.:
-    val = false
-    assert do
-      # reported
-      val == true
-    end
-
-    assert do
-      # won't be reported
-      val
-    end
-* Returned values from accessor methods, method missing, or "super" produce nothing report, e.g:
-    class Foo
-      attr_accessor :val
-    end
-    foo = Foo.new
-    foo.val = false
-
-    assert do
-      # reported (only the value of "foo" and the literal "true")
-      foo.val == true
-    end
-
-    assert do
-      # won't be reported
-      foo.val
-    end
-* Expressions should not have conditional branches. Expressions with such conditional codes may produce nothing report, e.g.:
-    condition = true
-    expected = false
-    actual = true
-    assert do
-      # this will fail but nothing reported
-      condition ? expected == actual : expected == actual
-    end
-
-== Travis Build Status {<img src="https://secure.travis-ci.org/k-tsj/power_assert.png?branch=master"/>}[http://travis-ci.org/k-tsj/power_assert]