power_assert 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7444d3904ad2148eb3fc1f836d721d28f1c59fe4
+  data.tar.gz: 6aade4c736ebba939973db85fc33f9e276daf010
+SHA512:
+  metadata.gz: 948cfe90a83135a15de3b7ac7d4dbdec085c352a2b04857b1e3e22e878a69eac63f54ca16d389aa6134037387b667e6ff8f7f3db3a94aeb3513f91c60d6e7f41
+  data.tar.gz: 666404c70ed0c62857490819241e169b994163d23972a62ff6f22b89372c47932aaec1647018d39f1824b823c1ea47a08a4db843816ad379499c41979d22c09b

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.1
+  - ruby-head

data/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 2014 Kazuki Tsujimoto, All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/COPYING

@@ -0,0 +1,57 @@
+Copyright (C) 2014 Kazuki Tsujimoto, All rights reserved.
+
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.rdoc

@@ -0,0 +1,8 @@
+= power_assert
+== About
+Power Assert for Ruby.
+
+== Related Projects
+* {test-unit-power_assert}[https://github.com/k-tsj/test-unit-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

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+task :default => :test
+Rake::TestTask.new do |t|
+  t.ruby_opts = ["-rpower_assert"]
+  t.test_files = FileList["test/test_*.rb"]
+end

data/lib/power_assert/version.rb

@@ -0,0 +1,3 @@
+module PowerAssert
+  VERSION = "0.1.0"
+end

data/lib/power_assert.rb

@@ -0,0 +1,224 @@
+# power_assert.rb
+#
+# Copyright (C) 2014 Kazuki Tsujimoto, All rights reserved.
+
+require 'power_assert/version'
+
+require 'ripper'
+require 'pattern-match'
+
+# NB: API is not fixed
+
+module PowerAssert
+  class Context
+    Value = Struct.new(:name, :value, :column)
+    Ident = Struct.new(:type, :name, :column)
+
+    TARGET_CALLER_DIFF = {return: 5, c_return: 4}
+    TARGET_CALLER_INDEX = {return: 3, c_return: 2}
+
+    attr_reader :message_proc
+
+    def initialize(assertion_proc, assertion_method)
+      path = nil
+      lineno = nil
+      line = nil
+      methods = nil
+      refs = nil
+      method_ids = nil
+      return_values = []
+      @base_caller_length = -1
+      @assertion_proc = assertion_proc
+      @message_proc = -> {
+        @assertion_message ||=
+          @base_caller_length > 0 ? assertion_message(line, methods, return_values, refs, @assertion_proc.binding).freeze : nil
+      }
+      @proc_local_variables = assertion_proc ? assertion_proc.binding.eval('local_variables').map(&:to_s) : []
+      @trace = TracePoint.new(:return, :c_return) do |tp|
+        next if method_ids and ! method_ids.include?(tp.method_id)
+        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)
+            methods, refs = idents.partition {|i| i.type == :method }
+          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
+        end
+      end
+    end
+
+    def yield
+      do_yield(&@assertion_proc)
+    end
+
+    private
+
+    def do_yield
+      @trace.enable do
+        @base_caller_length = caller_locations.length
+        yield
+      end
+    end
+
+    def assertion_message(line, methods, return_values, refs, proc_binding)
+      set_column(line, methods, return_values)
+      ref_values = refs ? refs.map {|i| Value[i.name, proc_binding.eval(i.name), i.column] } : []
+      vals = (return_values + ref_values).find_all(&:column).sort_by(&:column).reverse
+      if vals.empty?
+        return line || ''
+      end
+      fmt = (vals[0].column + 1).times.map {|i| vals.find {|v| v.column == i } ? "%<#{i}>s" : ' '  }.join
+      ret = []
+      ret << line.chomp
+      ret << sprintf(fmt, vals.each_with_object({}) {|v, h| h[v.column.to_s.to_sym] = '|' }).chomp
+      vals.each do |i|
+        ret << sprintf(fmt,
+                       vals.each_with_object({}) do |j, h|
+                         h[j.column.to_s.to_sym] = [i.value.inspect, '|', ' '][i.column <=> j.column]
+                       end).rstrip
+      end
+      ret.join("\n")
+    end
+
+    def set_column(line, methods, return_values)
+      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)
+        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
+          ss.flat_map {|s| extract_idents(s) }
+        end
+        with(_[:program, _[s, *_]]) do
+          extract_idents(s)
+        end
+        with(_[:method_add_arg, s0, s1]) do
+          s0_methods = extract_idents(s0)
+          s0_methods[0..-2] + extract_idents(s1) + [s0_methods[-1]]
+        end
+        with(_[:arg_paren, s]) do
+          extract_idents(s)
+        end
+        with(_[:args_add_block, _[:args_add_star, ss0, *ss1], _]) do
+          (ss0 + ss1).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
+          [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
+        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
+          [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
+          []
+        end
+      end
+    end
+  end
+  private_constant :Context
+
+  def start(assertion_proc, assertion_method: nil)
+    yield Context.new(assertion_proc, assertion_method)
+  end
+  module_function :start
+end
+
+RubyVM::InstructionSequence.compile_option = {
+  specialized_instruction: false
+}

data/power_assert.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'power_assert/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'power_assert'
+  s.version     = PowerAssert::VERSION
+  s.authors     = ['Kazuki Tsujimoto']
+  s.email       = ['kazuki@callcc.net']
+  s.homepage    = 'https://github.com/k-tsj/power_assert'
+  s.summary     = %q{Power Assert for Ruby}
+  s.description = %q{Power Assert for Ruby}
+
+  s.files            = `git ls-files`.split("\n")
+  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'
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'rake'
+  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options     = ['--main', 'README.rdoc']
+end

data/test/test_power_assert.rb

@@ -0,0 +1,149 @@
+require 'test/unit'
+require 'power_assert'
+require 'ripper'
+require 'set'
+
+class TestPowerAssert < Test::Unit::TestCase
+  EXTRACT_METHODS_TEST = [
+    [[[:method, "c", 4], [:method, "b", 2], [:method, "d", 8], [:method, "a", 0]],
+      'a(b(c), d))'],
+
+    [[[:method, "a", 0], [:method, "b", 2], [:method, "d", 6], [:method, "c", 4]],
+      'a.b.c(d)'],
+
+    [[[:method, "b", 2], [:method, "a", 0], [:method, "c", 5], [:method, "e", 9], [:method, "d", 7]],
+      'a(b).c.d(e)'],
+
+    [[[:method, "b", 4], [:method, "a", 2], [:method, "c", 7], [:method, "e", 13], [:method, "g", 11], [:method, "d", 9], [:method, "f", 0]],
+      'f(a(b).c.d(g(e)))'],
+
+    [[[:method, "c", 5], [:method, "e", 11], [:method, "a", 0]],
+      'a(b: c, d: e)'],
+
+    [[[:method, "b", 2], [:method, "c", 7], [:method, "d", 10], [:method, "e", 15], [:method, "a", 0]],
+      'a(b => c, d => e)'],
+
+    [[[:method, "b", 4], [:method, "d", 10]],
+      '{a: b, c: d}'],
+
+    [[[:method, "a", 1], [:method, "b", 6], [:method, "c", 9], [:method, "d", 14]],
+      '{a => b, c => d}'],
+
+    [[[:method, "a", 2], [:method, "b", 5], [:method, "c", 10], [:method, "d", 13]],
+      '[[a, b], [c, d]]'],
+
+    [[[:method, "a", 0], [:method, "b", 2], [:method, "c", 5]],
+      'a b, c { d }'],
+
+    [[[:method, "a", 20]],
+      'assertion_message { a }'],
+
+    [[[:method, "a", 0]],
+      'a { b }'],
+
+    [[[:method, "c", 4], [:method, "B", 2], [:method, "d", 8], [:method, "A", 0]],
+      'A(B(c), d)'],
+
+    [[[:method, "c", 6], [:method, "f", 17], [:method, "h", 25], [:method, "a", 0]],
+      'a(b = c, (d, e = f), G = h)'],
+
+    [[[: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]],
+      'a == b + c'],
+
+    [[[:ref, "var", 0], [:ref, "var", 8], [:method, "var", 4]],
+      'var.var(var)'],
+
+    [[[:ref, "B", 2], [:ref, "@c", 5], [:ref, "@@d", 9], [:ref, "$e", 14], [:method, "f", 18], [:method, "self", 20], [:ref, "self", 26], [:method, "a", 0]],
+      'a(B, @c, @@d, $e, f.self, self)'],
+
+    [[[:method, "a", 0], [:method, "c", 4], [:method, "b", 2]],
+      'a.b c'],
+
+    [[[:method, "b", 4]],
+      '"a#{b}c"'],
+
+    [[[:method, "b", 4]],
+      '/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
+    end
+  end
+
+  def assertion_message(&blk)
+    ::PowerAssert.start(blk, assertion_method: __method__) do |pa|
+      pa.yield
+      pa.message_proc.()
+    end
+  end
+
+  def test_assertion_message
+    a = 0
+    @b = 1
+    @@c = 2
+    $d = 3
+    assert_equal <<END.chomp, assertion_message {
+      String(a) + String(@b) + String(@@c) + String($d)
+      |      |  | |      |   | |      |    | |      |
+      |      |  | |      |   | |      |    | |      3
+      |      |  | |      |   | |      |    | "3"
+      |      |  | |      |   | |      |    "0123"
+      |      |  | |      |   | |      2
+      |      |  | |      |   | "2"
+      |      |  | |      |   "012"
+      |      |  | |      1
+      |      |  | "1"
+      |      |  "01"
+      |      0
+      "0"
+END
+      String(a) + String(@b) + String(@@c) + String($d)
+    }
+
+
+    assert_equal <<END.chomp, assertion_message {
+      "0".class == "3".to_i.times.map {|i| i + 1 }.class
+          |     |      |    |     |                |
+          |     |      |    |     |                Array
+          |     |      |    |     [1, 2, 3]
+          |     |      |    #<Enumerator: 3:times>
+          |     |      3
+          |     false
+          String
+END
+      "0".class == "3".to_i.times.map {|i| i + 1 }.class
+    }
+
+
+    assert_equal '', assertion_message {
+      false
+    }
+
+
+    assert_equal <<END.chomp,
+    assertion_message { "0".class }
+                            |
+                            String
+END
+    assertion_message { "0".class }
+
+
+    assert_equal <<END.chomp, assertion_message {
+      Set.new == Set.new([0])
+      |   |   |  |   |
+      |   |   |  |   #<Set: {0}>
+      |   |   |  Set
+      |   |   false
+      |   #<Set: {}>
+      Set
+END
+      Set.new == Set.new([0])
+    }
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: power_assert
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kazuki Tsujimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pattern-match
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Power Assert for Ruby
+email:
+- kazuki@callcc.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- ".gitignore"
+- ".travis.yml"
+- BSDL
+- COPYING
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/power_assert.rb
+- lib/power_assert/version.rb
+- power_assert.gemspec
+- test/test_power_assert.rb
+homepage: https://github.com/k-tsj/power_assert
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Power Assert for Ruby
+test_files: []