xmp2assert 6 → 8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a3d094937f1507beb58f9131f1779863df91f7e
-  data.tar.gz: cc3f457c3d31739bc235222aa6b9fa1adbdd5287
+  metadata.gz: 14c558b16e211cc2198f003c708b87acebe83406
+  data.tar.gz: ed3a7c00a1d6b5bda7e734b00d0cd43ba1954acb
 SHA512:
-  metadata.gz: 8b86def4caf24dfc2a2e656f3359bd66b77ebf1a3d6b5507b06d05435ba4e6e4692d0d601e6a2ba733fe0cce4f2a42f1d5ac729d5c3a8e0442d279666184ea14
-  data.tar.gz: e1d3a2fdb734ba4d1f653c40d0ff727d006bc332370d4ebd713d8d664a0ba24a2e739639086e21ab58ab3cd01d9d30f99a24e2d6f1520e5b884c26cd410ca2df
+  metadata.gz: ff38753c94e6c2b553efca12c639c77d91c4872cb5d539f26bb862e92dba881288e469c7fd67063a055b884b0f94863aed614befe7693aa61b74728c12bdaefe
+  data.tar.gz: ce410e98585873f3064f901d6803a86b69f1af44aa0053017b429f7ef8d01e2ef713ab883142d5a06f2fbbe49604fdfe3b39451dd42667b0fbd0e61afdbe8af3

data/.rubocop.yml

@@ -26,6 +26,7 @@ AllCops:
   DisplayCopNames: true
   Exclude:
     - "vendor/**/*"
+    - "samples/**/*"
   TargetRubyVersion: 2.2 # 2.3 # 2.4 # 2.5
 
 Lint/AmbiguousBlockAssociation:
@@ -34,9 +35,19 @@ Lint/AmbiguousBlockAssociation:
 Lint/EmptyWhen:
   Enabled: false
 
+Metrics/ParameterLists:
+  Enabled: false
+
 Rails:
   Enabled: false
 
+Security/Eval:
+  # I KNOW WHAT I DO. Please stop annoying me.
+  Enabled: false
+
+Security/MarshalLoad:
+  Enabled: false
+
 Style/Alias:
   Enabled: false
 
@@ -94,6 +105,9 @@ Style/FormatString:
 Style/GuardClause:
   Enabled: false
 
+Style/IdenticalConditionalBranches:
+  Enabled: false
+
 Style/IndentHash:
   Enabled: false
 
@@ -115,6 +129,9 @@ Style/MultilineIfThen:
 Style/MultilineMethodCallIndentation:
   Enabled: false
 
+Style/Not:
+  Enabled: false
+
 Style/ParallelAssignment:
   Enabled: false
 
@@ -154,6 +171,9 @@ Style/StringLiteralsInInterpolation:
 Style/SymbolArray:
   Enabled: false
 
+Style/TernaryParentheses:
+  Enabled: false
+
 Style/TrailingCommaInLiteral:
   Enabled: false
 
@@ -175,9 +195,16 @@ Style/WhileUntilDo:
 Style/WhileUntilModifier:
   Enabled: false
 
+Lint/AssignmentInCondition:
+  Exclude:
+    # I know what I do.
+    - 'lib/xmp2assert/assertions.rb'
+    - 'lib/xmp2assert/converter.rb'
+
 Lint/UselessAccessModifier:
   Exclude:
-    # I think detecting this file is a rubocop bug.
+    # I think detecting these files is a rubocop bug.
+    - 'lib/xmp2assert/renderer.rb'
     - 'lib/xmp2assert/validator.rb'
 
 Lint/UselessAssignment:

data/README.md

@@ -26,6 +26,54 @@ It automatically checks for those comments and see if they are right.
 
 Really sorry but we have no dedicated document than the YARD. Pro-tip: look at `XMP2Assert::Assertions`
 
+## Languages understood by this library
+
+- Everything but comments are passed verbatimly to underlying ruby interpreter.  We don't go deep in this area.
+- There are currently four kinds of special comments that make sense.  All other comments are verbatimly passed to the underlying ruby interpreter (and then, silently ignored there).
+- The most basic `=>` comment describes the value of an expression that is immediately leading the comment.
+
+    ```ruby
+	1 + 2 # => 3
+	```
+
+- An exceptions is described by a `~>` comment.  Because exceptions are kind of control flows, the thing the comment describes tends to be a statement, not expression-in-general.
+
+    ```ruby
+	raise "foo" # ~> foo
+	```
+
+- Outputs are also described.  There are two kinds of IO comments; `>>` for stdout and `!>` for stderr.  Note however that They are checked buffered, not line-by-line.
+
+    ```ruby
+	puts "foo" # >> foo
+	```
+
+- Comments are not mixed i.e. you can't describe stderr and stdout in a same line.  You have to separate them in dedicated lines.
+
+    ```ruby
+	STDOUT.puts "foo"; STDERR.puts "bar"
+	# => nil
+	# >> foo
+	# ~> bar
+	```
+
+- The "expression that is immediately leading the comment" is not that obvious than you think.  For instance,
+
+    ```ruby
+	<<END + <<END.lines.length
+	foo
+	END
+	#{<<END}
+	bar
+	END
+	END
+	# => ...?
+	```
+
+	This is a valid ruby script but extraordinary complicated.  What is the expression that the comment at the last line describes?  It is strongly advised that you should not write such things and go concise.
+
+	Understanding of non-comment ruby expression is best effort; done using heuritics.
+
 ## What if I want to contribute?
 
 Before proceeding any further, you have to take this action:

data/exe/xmpcheck.rb

@@ -44,9 +44,7 @@ class TC_Main < Test::Unit::TestCase
       end
     else
       test f.__FILE__ do
-        t, o = XMP2Assert::Converter.convert f
-        t.eval binding        if k.include? :'=>'
-        assert_capture2e o, f if k.include? :'>>'
+        assert_xmp f
       end
     end
   end

data/lib/xmp2assert.rb

@@ -25,8 +25,5 @@
 
 require_relative 'xmp2assert/namespace' # needs be first
 require_relative 'xmp2assert/version'
-require_relative 'xmp2assert/prettier_inspect'
-require_relative 'xmp2assert/quasifile'
-require_relative 'xmp2assert/converter'
 require_relative 'xmp2assert/classifier'
 require_relative 'xmp2assert/assertions'

data/lib/xmp2assert/assertions.rb

@@ -23,69 +23,70 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-require 'rbconfig'
-require 'open3'
-require 'tempfile'
-require 'erb'
 require 'test/unit'
 require 'test/unit/assertions'
 require 'test/unit/assertion-failed-error'
 require_relative 'namespace'
 require_relative 'quasifile'
 require_relative 'xmp2rexp'
+require_relative 'renderer'
+require_relative 'spawn'
 
 # Helper module that implements assertions.
 module XMP2Assert::Assertions
   include Test::Unit::Assertions
   include XMP2Assert::XMP2Rexp
+  include XMP2Assert::Renderer
 
-  # Run a ruby script and assert for its output.
+  # Run a ruby script and assert for its comment.  This is the main API.
   #
   # ```ruby
-  # assert_capture2e "foo\n", Quasifile.new("puts 'foo'")
+  # assert_xmp "1 + 2 # => 3"
   # ```
   #
-  # @param expected [String]               expected output.
-  # @param script   [Quasifile]            a ruby script.
-  # @param message  [String]               extra failure message.
-  # @param rubyopts [Array<String>]        extra opts to pass to ruby process.
-  # @param opts     [Hash{Symbol=>Object}] extra opts to pass to spawn.
-  # @note
-  #   As the method name implies the assertion is against both stdin and stderr
-  #   at once.  This is for convenience.
-  def assert_capture2e expected, script, message = nil, rubyopts: nil, **opts
-    qscript = XMP2Assert::Quasifile.new script
-    actual, _ = ruby qscript, rubyopts: rubyopts, **opts
-    actual.force_encoding expected.encoding
-    return assert_xmp_raw expected, actual, message
-  end
-
-  # Assert if the given expression is in the same form of xmp.
-  #
-  # ```ruby
-  # assert_xmp '#<Object:0x007f896c9b49c8>', Object.new
-  # ```
-  #
-  # @param xmp      [String] expected pattern of inspect.
-  # @param expr     [Object] object to check.
-  # @param message  [String] extra failure message.
-  def assert_xmp xmp, expr, message = nil
-    assert_xmp_raw xmp, expr.inspect, message
+  # @param script     [Quasifile]     a ruby script.
+  # @param message    [String]        extra failure message.
+  # @param rubyopts   [Array<String>] extra opts to pass to ruby process.
+  # @param stdin_data [String]        extra stdin to pass to ruby process.
+  # @param opts       [Hash]          extra opts to pass to Kernel.spawn.
+  def assert_xmp script, message = nil, stdin_data: '', **opts
+    qscript        = XMP2Assert::Quasifile.new script
+    qf, qo, qe, qx = XMP2Assert::Converter.convert qscript
+    render qf, qx do |f|
+      XMP2Assert::Spawn.new f, **opts do |_, i, o, e, r, t|
+        i.write stdin_data
+        i.close
+        out = Thread.new { o.read }
+        err = Thread.new { e.read }
+        while n = t.gets do
+          x = t.read n.to_i
+          expected, actual, bt = *Marshal.load(x)
+          begin
+            assert_xmp_raw expected, actual, message
+          rescue Test::Unit::AssertionFailedError => x
+            r.close
+            x.set_backtrace bt
+            raise x
+          else
+            r.puts
+          end
+        end
+        assert_xmp_raw qo, out.value, message unless qo.empty?
+        assert_xmp_raw qe, err.value, message unless qe.empty?
+      end
+    end
   end
 
-  private
-
-  # :TODO: is it private?
+  # :TODO: tbw
   def assert_xmp_raw xmp, actual, message = nil
     expected = xmp2rexp xmp
 
     raise unless expected.match actual
   rescue
     # Regexp#match can raise. That should also be a failure.
-    msg = genmsg xmp, actual, message
     ix  = Test::Unit::Assertions::AssertionMessage.convert xmp
     ia  = Test::Unit::Assertions::AssertionMessage.convert actual
-    ex  = Test::Unit::AssertionFailedError.new(msg,
+    ex  = Test::Unit::AssertionFailedError.new(message,
                     expected: xmp,
                       actual: actual,
           inspected_expected: ix,
@@ -95,69 +96,4 @@ module XMP2Assert::Assertions
   else
     return self # or...?
   end
-
-  # We support pre-&. versions
-  def try obj, msg
-    return obj.send msg
-  rescue NoMethodError
-    return nil
-  end
-
-  def genmsg x, y, z = nil
-    diff = Test::Unit::Assertions::AssertionMessage.delayed_diff x, y
-    if try(x, :ascii_only?) && try(y, :ascii_only?) then
-      fmt  = "<?> expected but was\n<?>.?"
-      argv = [x, y, diff]
-    elsif try(x, :encoding) != try(y, :encoding) then
-      fmt  = "<?>(?) expected but was\n<?>(?).?"
-      argv = [x, x.encoding.name, y, y.encoding.name, diff]
-    else
-      fmt  = "<?> expected but was\n<?>.?"
-      argv = [x, y, diff]
-    end
-    return Test::Unit::Assertions::AssertionMessage.new z, fmt, argv
-  end
-
-  def erb
-    unless defined? @@erb
-      myself = Pathname.new __FILE__
-      path   = myself + '../template.erb'
-      src    = path.read mode: 'rb:binary:binary'
-      @@erb  = ERB.new src, nil, '%-'
-      @@erb.filename = path.realpath.to_path if defined? $DEBUG
-    end
-    return @@erb
-  end
-
-  def empty_binding
-    # This `eval 'binding'` does not return the current binding but creates one
-    # on top  of it.  To  make it  really empty, this  method has to  have zero
-    # arity, and zero local variables.
-    return eval 'binding'
-  end
-
-  def empty_binding_with hash
-    return empty_binding.tap do |b|
-      hash.each_pair do |k, v|
-        b.local_variable_set k, v
-      end
-    end
-  end
-
-  def ruby script, rubyopts: nil, **opts
-    Tempfile.create '' do |f|
-      b = empty_binding_with script: script
-      s = erb.result b
-      f.write s
-      argv = [RbConfig.ruby, rubyopts, f.path]
-      if defined? ENV['BUNDLE_BIN_PATH']
-        argv = [ENV['BUNDLE_BIN_PATH'], 'exec'] + argv
-      end
-      argv.flatten!
-      argv.compact!
-      f.flush
-      # STDERR.puts(f.path) ; sleep # for debug
-      return Open3.capture2e(*argv, binmode: true, **opts)
-    end
-  end
 end

data/lib/xmp2assert/classifier.rb

@@ -41,19 +41,20 @@ require_relative 'parser'
 # ```
 module XMP2Assert::Classifier
   # @param  (see XMP2Assert::Parser.new)
-  # @return [<Symbol>]  either empty, :=>, :>>, or both.
+  # @return [<Symbol>]  any combination of :=>, :>>, :!>, :~>, or empty.
   # @note               syntax error results in empty return value.
   def self.classify obj, file = nil, line = nil
     parser = XMP2Assert::Parser.new obj, file, line
   rescue SyntaxError
     return []
   else
-    return parser                                              \
-      .tokens                                                  \
-      .map(&:to_sym)                                           \
-      .sort                                                    \
-      .uniq                                                    \
-      .map {|i| case i when :'=>', :'>>' then i else nil end } \
+    mid = %i[=> >> !> ~>]
+    return parser                                      \
+      .tokens                                          \
+      .map(&:to_sym)                                   \
+      .sort                                            \
+      .uniq                                            \
+      .map {|i| case i when *mid then i else nil end } \
       .compact
   end
 end

data/lib/xmp2assert/converter.rb

@@ -23,7 +23,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-require 'ripper'
 require 'uuid'
 require_relative 'namespace'
 require_relative 'parser'
@@ -48,8 +47,7 @@ class XMP2Assert::Converter
   # ```
   #
   # @param  (see #initialize)
-  # @return [(Quasifile,String)] tuple  of  generated  file  and  its  expected
-  #                              output.
+  # @return (see #convert)
   def self.convert obj, file = nil, line = nil
     this = new obj, file, line
     return this.send :convert
@@ -62,13 +60,16 @@ class XMP2Assert::Converter
     @program = XMP2Assert::Parser.new obj, file, line
   end
 
+  # @return [(Quasifile,String,String,String)]
+  #   a  tuple  of  comment-converted  source, its  expected  stdout,  expected
+  #   stderr, and expected exception.
   def convert
     @tokens = @program.tokens
-    outputs = aggregate
-    merge_xmp
+    understand
+    stdout, stderr, exceptions = aggregate
     render
     ret = XMP2Assert::Quasifile.new @tokens.join, *@program.locations
-    return ret, outputs
+    return ret, stdout, stderr, exceptions
   end
 
   def gensym expr
@@ -81,19 +82,27 @@ class XMP2Assert::Converter
   Namespace = UUID.create_random
   private_constant :Namespace
 
-  def gen_tap xmp
-    n = gensym xmp
-    x = xmp.chomp.dump
-    return sprintf ".tap {|%s| assert_xmp(%s, %s) }", n, x, n
+  def gen_tap tok
+    xmp = tok.to_s.chomp.dump
+    case tok.to_sym
+    when :'~>' then
+      return sprintf " rescue (xmp2assert_assert(%s, $!) and raise)", xmp
+    when :'=>' then
+      nam = gensym xmp
+      return sprintf ".tap {|%s| xmp2assert_assert(%s, %s) }", nam, xmp, nam
+    end
   end
 
   def end_of_expr? tok
     case tok.to_sym
     when :sp          then return false
+    when :period      then return false
     when :comma       then return false
     when :semicolon   then return false
     when :comment     then return false
     when :'=>'        then return false
+    when :'!>'        then return false
+    when :'~>'        then return false
     when :>>          then return false
     when :nl          then return false
     when :ignored_nl  then return false
@@ -143,21 +152,83 @@ class XMP2Assert::Converter
     return true
   end
 
+  def tmp_reroute_heredoc line
+    return line.map do |tok|
+      case tok.to_sym when :heredoc_beg then
+        next XMP2Assert::Token.new :'""', '""', tok.yylloc
+      else
+        next tok
+      end
+    end
+  end
+
+  def revert_heredoc before, after
+    after.map! do |tok|
+      case tok.to_sym when :'""' then
+        next before.find {|i| i.yylloc == tok.yylloc }
+      else
+        next tok
+      end
+    end
+    before.replace after
+  end
+
+  def effective_first_token_of line
+    line.each do |tok|
+      return tok unless tok.to_sym == :sp
+    end
+    return nil
+  end
+
+  def effective_last_token_of line
+    line.reverse_each do |tok|
+      case tok.to_sym
+      when :sp         then next
+      when :comment    then next
+      when :'=>'       then next
+      when :'!>'       then next
+      when :'~>'       then next
+      when :>>         then next
+      when :nl         then next
+      when :ignored_nl then next
+      else return tok
+      end
+    end
+    return nil
+  end
+
+  def period_continued? tok
+    line = @program.lines[tok.__LINE__ ]
+    t = effective_first_token_of line
+    return true  if t.to_sym == :period
+    return false if tok.__LINE__ <= 1
+
+    line = @program.lines[tok.__LINE__ - 1]
+    return false unless t = effective_last_token_of(line)
+    return true  if t.to_sym == :period
+    return false
+  end
+
   def find_start stop
-    line = @program.same_line_as stop
+    line = @program.lines[stop.__LINE__]
     line.sort!
-    line.select! {|i| i.__COLUMN__ <= stop.__COLUMN__ }
+    line = line.select {|i| i.__COLUMN__ <= stop.__COLUMN__ }
     line = line.drop_while {|i| not beginning_of_expr? i }
-    until valid? line do
-      line.shift
+    line2 = tmp_reroute_heredoc line
+    until valid? line2 do
+      line2.shift
     end
+    revert_heredoc line, line2
     return line
   end
 
   def need_paren? list
     start = list.first.to_sym.to_s
 
-    if %r/(.+)_beg$/ =~ start then
+    if "embexpr_beg" == start then
+      return false # paren breaks expression
+
+    elsif %r/(.+)_beg$/ =~ start then
       t = $1
       list.inject 0 do |i, tok|
         tt = tok.to_sym.to_s
@@ -232,9 +303,18 @@ class XMP2Assert::Converter
   #      one: 1,
   #    } # => {:one=>1}
   #    ```
+  #
+  # 6. special case for periods... you can end a line with period, or
+  #    begin with it; that indicates the line continues.  We detect
+  #    that and handle as continuous lines.
+  #
+  #    A backslash-newline can also continue a line but we are dealing
+  #    with comments so that can never happen here.
   def rev_lookup_expr xmp
     needs_start, stop = find_stop xmp
     return nil, stop unless needs_start
+    return nil, stop if period_continued? stop
+
     list = find_start stop
 
     if list.empty? then
@@ -246,48 +326,71 @@ class XMP2Assert::Converter
     end
   end
 
-  def aggregate
-    return @tokens.each_with_object String.new do |tok, r|
-      next unless tok.to_sym == :>>
-      str = tok.to_s
-      r << str
-      str.replace "\n"
-    end
-  end
-
-  def merge_xmp
+  def understand
     xmp = nil
     @tokens.each do |tok|
-      case tok.to_sym
-      when :sp then next
-      when :'=>' then
-        str = tok.to_s
+      case sym = tok.to_sym
+      when :'=>', :>>, :'!>', :'~>' then
+        if xmp and xmp.to_sym == sym then
+          xmp.to_s.concat tok.to_s
+          tok.yylex  = :comment
+          tok.yylval = "#\n"
+        else
+          xmp = tok
+        end
+      when :comment then
         if xmp then
-          xmp << str
-          str.replace "\n"
-          tok.yylex = :nl
+          xmp.to_s.concat tok.to_s.sub(/^#/, '')
+          tok.yylval = "#\n"
         else
-          xmp = str
+          xmp = nil
         end
+      when :sp then
+        next # ignore spaces
       else
         xmp = nil
       end
     end
   end
 
+  def aggregate
+    buf = Hash.new "" # ok
+    @tokens.reverse_each do |tok|
+      case sym = tok.to_sym
+      when :>>, :'!>', :'~>' then
+        buf[sym] = tok.to_s << buf[sym]
+        tok.yylex  = :comment
+        tok.yylval = "#\n"
+      when :sp, :nl then
+        next
+      else
+        break
+      end
+    end
+    # aggregation of ~> stops here, others continue.
+    @tokens.reverse_each do |tok|
+      case sym = tok.to_sym when :>>, :'!>' then
+        buf[sym] = tok.to_s << buf[sym]
+        tok.yylex  = :comment
+        tok.yylval = "#\n"
+      end
+    end
+    return buf.values_at :>>, :'!>', :'~>'
+  end
+
   def render
     @tokens.each do |tok|
-      next unless tok.to_sym == :'=>'
-      xmp = tok.to_s
-      tap = gen_tap xmp
-      xmp.replace "\n"
-      x, y = rev_lookup_expr tok
-      if x and x != y then
-        x.to_s.sub! %r/^/, '('
-        y.to_s.sub! %r/$/, ')'
-      end
-      y.to_s.sub! %r/$/ do
-        tap # use block to prevent backslash substitution
+      case tok.to_sym when :'=>', :'~>' then
+        tap = gen_tap tok
+        tok.to_s.replace "\n"
+        x, y = rev_lookup_expr tok
+        if x and x != y then
+          x.to_s.sub! %r/^/, '('
+          y.to_s.sub! %r/$/, ')'
+        end
+        y.to_s.sub! %r/$/ do
+          tap # use block to prevent backslash substitution
+        end
       end
     end
   end

data/lib/xmp2assert/namespace.rb

@@ -28,7 +28,4 @@
 #
 # - {XMP2Assert::Assertions} The assertion framework.
 # - {XMP2Assert::Classifier} Check if the given file actually has the comment.
-# - {XMP2Assert::Converter}  Source code in-place editor using Ripper.
-# - {XMP2Assert::Quasifile}  IO/String abstraction layer
-# - {XMP2Assert::PrettierInspect} Helper module to ease inspection.
 module XMP2Assert; end

data/lib/xmp2assert/parser.rb

@@ -48,21 +48,11 @@ class XMP2Assert::Parser < Ripper
     return @qfile.__FILE__, @qfile.__LINE__
   end
 
-  # Find tokens that are in the same line as the argument.
+  # Split tokens into lines.
   #
-  # ```ruby
-  # [ 1, # => 1
-  #   2, # => 2
-  # ]    # => [1, 2]
-  # ```
-  #
-  # It will return `[(:sp ' ') (:int 2) (:'=>' "2")]` for `(:'=>' "2")`.
-  #
-  # @param tok [Token] a token to look at.
-  # @return    [Array] tokens of the same line as the argument.
-  def same_line_as tok
-    f, l = tok.__FILE__, tok.__LINE__
-    return @tokens.select {|i| i.__FILE__ == f }.select {|i| i.__LINE__ == l }
+  # @return [Array<Array<Token>>] tokens, split into lines.
+  def lines
+    return @lines ||= @tokens.group_by(&:__LINE__)
   end
 
   private
@@ -73,11 +63,8 @@ class XMP2Assert::Parser < Ripper
 
   def on_comment c
     case c
-    when /^# => / then
-      yylex = :'=>'
-      yylval = $'
-    when /^# [~>]> / then
-      yylex = :>>
+    when /^# ([~=!>]>) / then
+      yylex = $1.intern
       yylval = $'
     else
       yylex = :comment

data/lib/xmp2assert/renderer.rb

@@ -0,0 +1,77 @@
+#! /your/favourite/path/to/ruby
+# -*- mode: ruby; coding: utf-8; indent-tabs-mode: nil; ruby-indent-level 2 -*-
+# -*- frozen_string_literal: true -*-
+# -*- warn_indent: true -*-
+
+# Copyright (c) 2017 Urabe, Shyouhei
+#
+# Permission is hereby granted, free of  charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction,  including without limitation the rights
+# to use,  copy, modify,  merge, publish,  distribute, sublicense,  and/or sell
+# copies  of the  Software,  and to  permit  persons to  whom  the Software  is
+# furnished to do so, subject to the following conditions:
+#
+#         The above copyright notice and this permission notice shall be
+#         included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE  IS PROVIDED "AS IS",  WITHOUT WARRANTY OF ANY  KIND, EXPRESS OR
+# IMPLIED,  INCLUDING BUT  NOT LIMITED  TO THE  WARRANTIES OF  MERCHANTABILITY,
+# FITNESS FOR A  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO  EVENT SHALL THE
+# AUTHORS  OR COPYRIGHT  HOLDERS  BE LIABLE  FOR ANY  CLAIM,  DAMAGES OR  OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'erb'
+require 'pathname'
+require 'tempfile'
+require_relative 'namespace'
+require_relative 'quasifile'
+
+# Compiles a {XMP2Assert::Quasifile} into a separate ruby script.
+module XMP2Assert::Renderer
+
+  # I learned this handy "super-private" maneuver from @a_matsuda
+  # cf: https://github.com/rails/rails/pull/27363/files
+  using Module.new {
+    refine XMP2Assert::Renderer do
+      private
+
+      myself = Pathname.new __FILE__
+      path   = myself + '../template.erb'
+      src    = path.read mode: 'rb:binary:binary'
+      erb    = ERB.new src, nil, '%-'
+      eval <<-"end", binding, path.realpath.to_path, -1
+        def erb(script, exception)\n#{erb.src}\nend
+      end
+    end
+  }
+
+  public
+
+  # Compiles a {Quasifile} into a  separate ruby script.  Generated file should
+  # be passable to a separate ruby process.   This method yields that file if a
+  # block is given, and deletes it afterwards.  When no block is passed, leaves
+  # it undeleted; to clean it up is up to the caller then.
+  #
+  # @param qfile     [Quasifile] a file to convert to.
+  # @param exception [String]    :TBD:
+  # @return          [File]      rendered file, if no block is given.
+  # @yieldparam      [File]      rendered file, if block is given.
+  def render qfile, exception = nil
+    s = erb qfile, exception
+    if defined? yield
+      Tempfile.create '' do |f|
+        f.write s
+        f.flush
+        return yield f
+      end
+    else
+      f = Tempfile.create ''
+      f.write s
+      f.flush
+      return f
+    end
+  end
+end

data/lib/xmp2assert/spawn.rb

@@ -0,0 +1,81 @@
+#! /your/favourite/path/to/ruby
+# -*- mode: ruby; coding: utf-8; indent-tabs-mode: nil; ruby-indent-level 2 -*-
+# -*- frozen_string_literal: true -*-
+# -*- warn_indent: true -*-
+
+# Copyright (c) 2017 Urabe, Shyouhei
+#
+# Permission is hereby granted, free of  charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction,  including without limitation the rights
+# to use,  copy, modify,  merge, publish,  distribute, sublicense,  and/or sell
+# copies  of the  Software,  and to  permit  persons to  whom  the Software  is
+# furnished to do so, subject to the following conditions:
+#
+#         The above copyright notice and this permission notice shall be
+#         included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE  IS PROVIDED "AS IS",  WITHOUT WARRANTY OF ANY  KIND, EXPRESS OR
+# IMPLIED,  INCLUDING BUT  NOT LIMITED  TO THE  WARRANTIES OF  MERCHANTABILITY,
+# FITNESS FOR A  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO  EVENT SHALL THE
+# AUTHORS  OR COPYRIGHT  HOLDERS  BE LIABLE  FOR ANY  CLAIM,  DAMAGES OR  OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'rbconfig'
+require_relative 'namespace'
+
+# Helper class to spawn a ruby process, and communicate with it.
+class XMP2Assert::Spawn
+
+  # @param path        [#to_path]      a path to a ruby program.
+  # @param rubyopts    [Array<String>] extra opts to pass to ruby interpreter.
+  # @param opts        [Hash]          extra opts to pass to Process.spawn
+  # @yieldparam pid    [Integer]       child process' pid.
+  # @yieldparam stdin  [IO]            child process stdin.
+  # @yieldparam stdout [IO]            child process stdout.
+  # @yieldparam stderr [IO]            child process stderr.
+  # @yieldparam tx     [IO]            pipe to communicate.
+  # @yieldparam rx     [IO]            pipe to communicate.
+  def initialize path, rubyopts: nil, **opts
+    ours, theirs, spec = pipes %i'r w w r w'
+    opts.update Hash[spec]
+
+    argv = [RbConfig.ruby, rubyopts, path.to_path]
+    argv << theirs[3..4].map {|i| i.to_i.to_s }
+    argv.flatten!
+    argv.compact!
+
+    begin
+      pid = Process.spawn(*argv, opts)
+      theirs.each(&:close)
+      stdin, stdout, stdrrr, rx, tx = * ours
+      yield pid, stdin, stdout, stdrrr, rx, tx
+    ensure
+      ours.each(&:close)
+      Process.waitpid pid if pid
+    end
+  end
+
+  private
+
+  def pipes directions
+    ours = []
+    theirs = []
+    directions.each_with_index do |d, i|
+      r, w = IO.pipe
+      t = (d == :r) ? r : w
+      o = (d == :r) ? w : r
+      theirs[i] = t
+      ours[i]   = o
+      o.sync = true
+      o.binmode
+    end
+    iospec = theirs.map {|i| [i, i] }
+    iospec[0][0] = 0
+    iospec[1][0] = 1
+    iospec[2][0] = 2
+    return ours, theirs, iospec
+  end
+end

data/lib/xmp2assert/template.erb

@@ -26,10 +26,64 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+# Because we don't want to pollute $", we write everything needed in this file.
+
+saved_binding = TOPLEVEL_BINDING.dup
+rx = IO.for_fd ARGV.shift.to_i, 'rb'
+tx = IO.for_fd ARGV.shift.to_i, 'wb'
+
+using Module.new {
+  refine Kernel do
+
+    private
+
+    Kernel.class_variable_set('@@rx', rx)
+    Kernel.class_variable_set('@@tx', tx)
+
+    def assert_xmp_send *argv
+      rx  = Kernel.class_variable_get('@@rx')
+      tx  = Kernel.class_variable_get('@@tx')
+      str = Marshal.dump argv
+      tx.puts str.length
+      tx.write str
+      tx.flush
+      if rx.gets then
+        return true
+      else
+        Process.exit false
+      end
+    end
+  end
+}
+
+# Simulates test-unit.
+# @param xmp      [String] expected pattern of inspect.
+# @param expr     [Object] object to check.
+# @param message  [String] extra failure message.
+# @note  assertion is done in parent process, not in it.
+def xmp2assert_assert xmp, expr, c = caller(3)
+  c.reject! {|i| i.start_with? __FILE__ }
+  return assert_xmp_send xmp, expr.inspect, c
+end
+
+# Here we go.
+
 file = "<%= script.__FILE__ %>" #=
 line = <%= script.__LINE__ %> #=
 src  = ::DATA.read
-eval src, binding, file, line
+% if exception and not exception.empty?
+begin
+  eval src, saved_binding, file, line
+rescue Exception => e
+  b = e.backtrace
+  b.reject! {|i| i.start_with? __FILE__ }
+  e.set_backtrace b
+  expected = <%= exception.dump %> #=
+  xmp2assert_assert expected, e, e.backtrace
+end
+% else
+eval src, saved_binding, file, line
+% end
 
 # Below is a generated software, sourced from <%= script.__FILE__ %>.
 # Above copyright notice does not apply any further.  Consult the original.

data/lib/xmp2assert/version.rb

@@ -24,4 +24,4 @@
 # SOFTWARE.
 ;
 
-XMP2Assert::VERSION = 6
+XMP2Assert::VERSION = 8

data/xmp2assert.gemspec

@@ -49,7 +49,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/shyouhei/xmp2assert'
   spec.license       = 'MIT'
   spec.files         = `git ls-files -z`.split("\x0").reject { |f|
-    f.match(%r'^(test|spec|features)/')
+    f.match(%r'^(test|spec|features|samples)/')
   }
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r'^exe/') { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xmp2assert
 version: !ruby/object:Gem::Version
-  version: '6'
+  version: '8'
 platform: ruby
 authors:
 - Urabe, Shyouhei
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-09 00:00:00.000000000 Z
+date: 2017-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -220,6 +220,8 @@ files:
 - lib/xmp2assert/parser.rb
 - lib/xmp2assert/prettier_inspect.rb
 - lib/xmp2assert/quasifile.rb
+- lib/xmp2assert/renderer.rb
+- lib/xmp2assert/spawn.rb
 - lib/xmp2assert/template.erb
 - lib/xmp2assert/token.rb
 - lib/xmp2assert/version.rb
@@ -245,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: auto-generate assertions from `# =>` comments