power_assert 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99b3895797c266648105fc96abdc122df93537d1
-  data.tar.gz: a9af7c357642b19eadeace43da8ba2f1ee17d9fe
+  metadata.gz: c655c4859384e9b6f80ca57638052de99d3d8a9d
+  data.tar.gz: d6ece1d15b1e83133b2e77eef2c03b2ed1b441fe
 SHA512:
-  metadata.gz: ae79bba8eb3a079bcf30df88ef0109be3de8848a2d5dcd4f7d1d5fdee731dcc20150a21e272ec54c7c19f70200c684df6972c23ee0c835113be6985c143f6f63
-  data.tar.gz: 4f0f959d1a16f3ba502adfe0c73f92909d2c78a3383a2bbb9044e886d6c3e0c06a41dbf2b9a572b5bd6e8a411e5c060bd3e3e305d682428d0645dd321cd4b662
+  metadata.gz: 0f7e60fc27d31672583e8e9916192165bbb05e495ffb3a283a8d37012b136efab29a6acd36412450057bcaa1b19cf7bff5fa323092bf4e6a96dd1c94e044a940
+  data.tar.gz: 8df7fa120664045dcbae9fad42b8babd4c744daa76d50990cd35642b1e9c3c51b605f72940a3ce0400cd2ee7c0da0a051fec29d56bba2a6729356e3e44a28ed5

data/.gitignore

@@ -1,4 +1,5 @@
 .bundle
+coverage
 Gemfile.lock
 pkg/*
 vendor/*

data/README.rdoc

@@ -4,5 +4,6 @@ Power Assert for Ruby.
 
 == Related Projects
 * {test-unit-power_assert}[https://github.com/k-tsj/test-unit-power_assert]
+* {minitest-power_assert}[https://github.com/hsbt/minitest-power_assert]
 
 == Travis Build Status {<img src="https://secure.travis-ci.org/k-tsj/power_assert.png"/>}[http://travis-ci.org/k-tsj/power_assert]

data/Rakefile

@@ -3,6 +3,7 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 task :default => :test
 Rake::TestTask.new do |t|
-  t.ruby_opts = ["-rpower_assert"]
+  # helper(simplecov) must be required before loading power_assert
+  t.ruby_opts = ["-r./test/helper", "-rpower_assert"]
   t.test_files = FileList["test/test_*.rb"]
 end

data/lib/power_assert.rb

@@ -2,8 +2,13 @@
 #
 # Copyright (C) 2014 Kazuki Tsujimoto, All rights reserved.
 
+begin
+  TracePoint.new(:return, :c_return) {}
+rescue
+  raise LoadError, 'Fully compatible TracePoint API required'
+end
+
 require 'power_assert/version'
-require 'power_assert/pattern_match'
 
 require 'ripper'
 
@@ -22,16 +27,22 @@ module PowerAssert
     def initialize(assertion_proc, assertion_method)
       path = nil
       lineno = nil
-      line = nil
+      @line = nil
       methods = nil
       refs = nil
       method_ids = nil
       return_values = []
       @base_caller_length = -1
       @assertion_proc = assertion_proc
+      @assertion_method_name = assertion_method.to_s
       @message_proc = -> {
         @assertion_message ||=
-          @base_caller_length > 0 ? assertion_message(line || '', methods || [], return_values, refs || [], assertion_proc.binding).freeze : nil
+          @base_caller_length > 0 ? assertion_message(@line || '',
+                                                      methods || [],
+                                                      return_values,
+                                                      refs || [],
+                                                      assertion_proc.binding).freeze :
+                                    nil
       }
       @proc_local_variables = assertion_proc.binding.eval('local_variables').map(&:to_s)
       @trace = TracePoint.new(:return, :c_return) do |tp|
@@ -39,14 +50,14 @@ module PowerAssert
         locs = tp.binding.eval('caller_locations')
         if locs.length - @base_caller_length == TARGET_CALLER_DIFF[tp.event]
           idx = TARGET_CALLER_INDEX[tp.event]
-          path ||= locs[idx].path
-          lineno ||= locs[idx].lineno
-          line ||= open(path).each_line.drop(lineno - 1).first
-          unless methods
-            idents = extract_idents(Ripper.sexp(line), assertion_method)
+          unless path
+            path = locs[idx].path
+            lineno = locs[idx].lineno
+            @line = open(path).each_line.drop(lineno - 1).first
+            idents = extract_idents(Ripper.sexp(@line))
             methods, refs = idents.partition {|i| i.type == :method }
+            method_ids = methods.map(&:name).map(&:to_sym).uniq
           end
-          method_ids ||= methods.map(&:name).map(&:to_sym).uniq
           if path == locs[idx].path and lineno == locs[idx].lineno
             return_values << Value[tp.method_id.to_s, tp.return_value, nil]
           end
@@ -91,123 +102,118 @@ module PowerAssert
       methods = methods.dup
       return_values.each do |val|
         idx = methods.index {|method| method.name == val.name }
-        if idx and (m = methods.delete_at(idx)).column
-          val.column = m.column
-        else
-          ridx = return_values.rindex {|i| i.name == val.name and i.column }
-          method_name = val.name
-          re = /
-            #{'\b' if /\A\w/ =~ method_name}
-            #{Regexp.escape(method_name)}
-            #{'\b' if /\w\z/ =~ method_name}
-          /x
-          val.column = line.index(re, ridx ? return_values[ridx].column + 1 : 0)
+        if idx
+          val.column = methods.delete_at(idx).column
         end
       end
     end
 
-    def extract_idents(sexp, assertion_method = nil)
-      match(sexp) do
-        with(_[:program,
-               _[_[:method_add_block,
-                   _[:method_add_arg, _[:fcall, _[:@ident, assertion_method.to_s, _]], _],
-                   _[Or(:brace_block, :do_block), _, ss]]]]) do
+    def extract_idents(sexp)
+      tag, * = sexp
+      case tag
+      when :arg_paren, :assoc_splat, :fcall, :hash, :method_add_block, :string_literal
+        extract_idents(sexp[1])
+      when :assign, :massign
+        extract_idents(sexp[2])
+      when :assoclist_from_args, :bare_assoc_hash, :dyna_symbol, :paren, :string_embexpr,
+        :regexp_literal, :xstring_literal
+        sexp[1].flat_map {|s| extract_idents(s) }
+      when :assoc_new, :command, :dot2, :dot3, :string_content
+        sexp[1..-1].flat_map {|s| extract_idents(s) }
+      when :unary
+        handle_columnless_ident([], sexp[1], extract_idents(sexp[2]))
+      when :binary
+        handle_columnless_ident(extract_idents(sexp[1]), sexp[2], extract_idents(sexp[3]))
+      when :call
+        [sexp[1], sexp[3]].flat_map {|s| extract_idents(s) }
+      when :array
+        sexp[1] ? sexp[1].flat_map {|s| extract_idents(s) } : []
+      when :command_call
+        [sexp[1], sexp[4], sexp[3]].flat_map {|s| extract_idents(s) }
+      when :aref
+        handle_columnless_ident(extract_idents(sexp[1]), :[], extract_idents(sexp[2]))
+      when :program
+        _, ((tag0, (tag1, (tag2, (tag3, mname, _)), _), (tag4, _, ss))) = sexp
+        if tag0 == :method_add_block and tag1 == :method_add_arg and tag2 == :fcall and
+            tag3 == :@ident and mname == @assertion_method_name and (tag4 == :brace_block or tag4 == :do_block)
           ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:program, _[s, *_]]) do
-          extract_idents(s)
-        end
-        with(_[:method_add_arg, s0, s1]) do
-          s0_idents = extract_idents(s0)
-          s0_idents[0..-2] + extract_idents(s1) + [s0_idents[-1]]
-        end
-        with(_[:arg_paren, s]) do
+        else
+          _, (s, *) = sexp
           extract_idents(s)
         end
-        with(_[:args_add_block, _[:args_add_star, ss0, *ss1], _]) do
+      when :method_add_arg
+        idents = extract_idents(sexp[1])
+        idents[0..-2] + extract_idents(sexp[2]) + [idents[-1]]
+      when :args_add_block
+        _, (tag, ss0, *ss1), _ = sexp
+        if tag == :args_add_star
           (ss0 + ss1).flat_map {|s| extract_idents(s) }
+        else
+          sexp[1].flat_map {|s| extract_idents(s) }
         end
-        with(_[:args_add_block, ss, _]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:vcall, _[:@ident, name, _[_, column]]]) do
+      when :vcall
+        _, (tag, name, (_, column)) = sexp
+        if tag == :@ident
           [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
+        else
+          []
         end
-        with(_[:fcall, s]) do
-          extract_idents(s)
-        end
-        with(_[:binary, *ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:call, s0, _, s1]) do
-          [s0, s1].flat_map {|s| extract_idents(s) }
-        end
-        with(_[:method_add_block, s, _]) do
-          extract_idents(s)
-        end
-        with(_[:hash, s]) do
-          extract_idents(s)
-        end
-        with(_[:assoclist_from_args, ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:bare_assoc_hash, ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:assoc_new, *ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:assoc_splat, s]) do
-          extract_idents(s)
-        end
-        with(_[:array, ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:string_literal, s]) do
-          extract_idents(s)
-        end
-        with(_[:string_content, *ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:string_embexpr, _[*ss]]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:regexp_literal, ss, _]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:command, *ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:command_call, s0, _, s1, s2]) do
-          [s0, s2, s1].flat_map {|s| extract_idents(s) }
-        end
-        with(_[:assign, _, s]) do
-          extract_idents(s)
-        end
-        with(_[:massign, _, s]) do
-          extract_idents(s)
-        end
-        with(_[:paren, ss]) do
-          ss.flat_map {|s| extract_idents(s) }
-        end
-        with(_[:var_ref, _[:@kw, "self", _[_, column]]]) do
-          [Ident[:ref, "self", column]]
-        end
-        with(_[:var_ref, _[Or(:@const, :@cvar, :@ivar, :@gvar), ref_name, _[_, column]]]) do
+      when :var_ref
+        _, (tag, ref_name, (_, column)) = sexp
+        case tag
+        when :@kw
+          if ref_name == 'self'
+            [Ident[:ref, 'self', column]]
+          else
+            []
+          end
+        when :@const, :@cvar, :@ivar, :@gvar
           [Ident[:ref, ref_name, column]]
-        end
-        with(_[:@ident, method_name, _[_, column]]) do
-          [Ident[:method, method_name, column]]
-        end
-        with(_[:@const, method_name, _[_, column]]) do
-          [Ident[:method, method_name, column]]
-        end
-        with(s & Symbol) do
-          [Ident[:method, s.to_s, nil]]
-        end
-        with(_) do
+        else
           []
         end
+      when :@ident, :@const
+        _, method_name, (_, column) = sexp
+        [Ident[:method, method_name, column]]
+      else
+        []
+      end
+    end
+
+    def str_indices(str, re, offset, limit)
+      idx = str.index(re, offset)
+      if idx and idx <= limit
+        [idx, *str_indices(str, re, idx + 1, limit)]
+      else
+        []
+      end
+    end
+
+    MID2SRCTXT = {
+      :[] => '[',
+      :+@ => '+',
+      :-@ => '-'
+    }
+
+    def handle_columnless_ident(left_idents, mid, right_idents)
+      left_max = left_idents.max_by(&:column)
+      right_min = right_idents.min_by(&:column)
+      bg = left_max ? left_max.column + left_max.name.length : 0
+      ed = right_min ? right_min.column - 1 : @line.length - 1
+      mname = mid.to_s
+      srctxt = MID2SRCTXT[mid] || mname
+      re = /
+        #{'\b' if /\A\w/ =~ srctxt}
+        #{Regexp.escape(srctxt)}
+        #{'\b' if /\w\z/ =~ srctxt}
+      /x
+      indices = str_indices(@line, re, bg, ed)
+      if left_idents.empty? and right_idents.empty?
+        left_idents + right_idents
+      elsif left_idents.empty?
+        left_idents + right_idents + [Ident[:method, mname, indices.last]]
+      else
+        left_idents + right_idents + [Ident[:method, mname, indices.first]]
       end
     end
   end
@@ -219,6 +225,8 @@ module PowerAssert
   module_function :start
 end
 
-RubyVM::InstructionSequence.compile_option = {
-  specialized_instruction: false
-}
+if defined? RubyVM
+  RubyVM::InstructionSequence.compile_option = {
+    specialized_instruction: false
+  }
+end

data/lib/power_assert/version.rb

@@ -1,3 +1,3 @@
 module PowerAssert
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/power_assert.gemspec

@@ -14,9 +14,9 @@ Gem::Specification.new do |s|
   s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables      = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
   s.require_paths    = ['lib']
-  s.add_runtime_dependency 'pattern-match', '>= 0.5.1'
   s.add_development_dependency 'test-unit'
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
   s.extra_rdoc_files = ['README.rdoc']
   s.rdoc_options     = ['--main', 'README.rdoc']
 end

data/test/helper.rb

@@ -0,0 +1,10 @@
+begin
+  if ENV['COVERAGE']
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/test/'
+      add_filter '/vendor/'
+    end
+  end
+rescue LoadError
+end

data/test/test_power_assert.rb

@@ -50,7 +50,7 @@ class TestPowerAssert < Test::Unit::TestCase
     [[[:method, "b", 2], [:method, "c", 6], [:method, "d", 9], [:method, "e", 12], [:method, "g", 18], [:method, "i", 24], [:method, "j", 29], [:method, "a", 0]],
       'a(b, *c, d, e, f: g, h: i, **j)'],
 
-    [[[:method, "a", 0], [:method, "==", nil], [:method, "b", 5], [:method, "+", nil], [:method, "c", 9]],
+    [[[:method, "a", 0], [:method, "b", 5], [:method, "c", 9], [:method, "+", 7], [:method, "==", 2]],
       'a == b + c'],
 
     [[[:ref, "var", 0], [:ref, "var", 8], [:method, "var", 4]],
@@ -67,17 +67,58 @@ class TestPowerAssert < Test::Unit::TestCase
 
     [[[:method, "b", 4]],
       '/a#{b}c/'],
+
+    [[],
+      '[]'],
+
+    [[[:method, "a", 0], [:method, "[]", 1]],
+      'a[0]'],
+
+    # not supported
+    [[],
+      '[][]'],
+
+    # not supported
+    [[],
+      '{}[]'],
+
+    [[[:method, "a", 1], [:method, "!", 0]],
+      '!a'],
+
+    [[[:method, "a", 1], [:method, "+@", 0]],
+      '+a'],
+
+    [[[:method, "a", 1], [:method, "-@", 0]],
+      '-a'],
+
+    [[[:method, "a", 2], [:method, "!", 0], [:method, "b", 9], [:method, "+@", 8], [:method, "c", 15], [:method, "-@", 14],
+        [:method, "==", 11], [:method, "==", 4]],
+      '! a == (+b == -c)'],
+
+    [[[:method, "b", 6]],
+      '%x{a#{b}c}'],
+
+    [[[:method, "a", 0], [:method, "b", 3]],
+      "a..b"],
+
+    [[[:method, "a", 0], [:method, "b", 4]],
+      "a...b"],
+
+    [[[:method, "b", 5]],
+      ':"a#{b}c"'],
   ]
 
   EXTRACT_METHODS_TEST.each_with_index do |(expect, source), idx|
     define_method("test_extract_methods_#{'%03d' % idx}") do
       pa = PowerAssert.const_get(:Context).new(-> { var = nil; -> {} }.(), nil)
-      assert_equal expect, pa.send(:extract_idents, Ripper.sexp(source), :assertion_message).map(&:to_a), source
+      pa.instance_variable_set(:@line, source)
+      pa.instance_variable_set(:@assertion_method_name, 'assertion_message')
+      assert_equal expect, pa.send(:extract_idents, Ripper.sexp(source)).map(&:to_a), source
     end
   end
 
   def assertion_message(&blk)
-    ::PowerAssert.start(blk, assertion_method: __method__) do |pa|
+    ::PowerAssert.start(blk, assertion_method: __callee__) do |pa|
       pa.yield
       pa.message_proc.()
     end
@@ -145,5 +186,33 @@ END
 END
       Set.new == Set.new([0])
     }
+
+
+    var = [10,20]
+    assert_equal <<END.chomp, assertion_message {
+      var[0] == 0
+      |  |   |
+      |  |   false
+      |  10
+      [10, 20]
+END
+      var[0] == 0
+    }
+
+    a = 1
+    assert_equal <<END.chomp, assertion_message {
+      ! a != (+a == -a)
+      | | |   || |  ||
+      | | |   || |  |1
+      | | |   || |  -1
+      | | |   || false
+      | | |   |1
+      | | |   1
+      | | false
+      | 1
+      false
+END
+      ! a != (+a == -a)
+    }
   end
 end

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: power_assert
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Kazuki Tsujimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-01 00:00:00.000000000 Z
+date: 2014-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pattern-match
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -68,9 +68,9 @@ files:
 - README.rdoc
 - Rakefile
 - lib/power_assert.rb
-- lib/power_assert/pattern_match.rb
 - lib/power_assert/version.rb
 - power_assert.gemspec
+- test/helper.rb
 - test/test_power_assert.rb
 homepage: https://github.com/k-tsj/power_assert
 licenses: []

data/lib/power_assert/pattern_match.rb

@@ -1,16 +0,0 @@
-require 'pattern-match/core'
-
-class << Array
-  include PatternMatch::Deconstructable
-
-  def deconstruct(val)
-    accept_self_instance_only(val)
-    val
-  end
-
-  private
-
-  def accept_self_instance_only(val)
-    raise PatternMatch::PatternNotMatch unless val.kind_of?(self)
-  end
-end