probatio 0.9.0 → 1.1.0

data/lib/probatio/assertions.rb

@@ -0,0 +1,324 @@
+
+#
+# probatio/assertions.rb
+
+class Probatio::Context
+
+  # Beware: ws.any? returns false when ws == [ false ]
+
+  def assert_nil(*as)
+
+    do_assert(as, 'nil') { |a| a == nil }
+  end
+
+  def assert_not_nil(*as)
+
+    do_assert(as, 'not nil') { |a| a != nil }
+  end
+
+  def assert_truthy(*as)
+
+    do_assert(as, 'truthy') { |a| !! a }
+  end
+  alias assert_trueish assert_truthy
+
+  def assert_falsey(*as)
+
+    do_assert(as, 'falsey') { |a| ! a }
+  end
+  alias assert_falsy assert_falsey
+  alias assert_falseish assert_falsey
+
+  def assert_true(*as)
+
+    do_assert(as, 'true') { |a| a == true }
+  end
+
+  def assert_false(*as)
+
+    do_assert(as, 'false') { |a| a == false }
+  end
+
+  def assert_any(*as)
+
+    do_assert(as, 'any') { |a| a.respond_to?(:size) && a.size > 0 }
+  end
+
+  def assert_empty(*as)
+
+    do_assert(as, 'empty') { |a| a.respond_to?(:size) && a.size == 0 }
+  end
+
+  def assert_equal(*as)
+
+    do_assert(as, 'equal') { |a| a == as[0] }
+  end
+
+  def assert_match(*as)
+
+    strings, others = as.partition { |a| a.is_a?(String) }
+    rex = others.find { |o| o.is_a?(Regexp) } || strings.pop
+
+    do_assert(strings, 'matched') { |s| s.match?(rex) }
+  end
+
+  def assert_start_with(*as)
+
+    fail ArgumentError.new(
+      "assert_start_with expects strings, not #{x.inspect}") \
+        if as.find { |a| ! a.is_a?(String) }
+
+    sta = as.inject { |s, a| s.length < a.length ? s : a }
+
+    do_assert(as.filter { |a| a != sta }, 'starting with') { |a|
+      a.start_with?(sta) }
+  end
+
+  def assert_end_with(*as)
+
+    fail ArgumentError.new(
+      "assert_end_with expects strings, not #{x.inspect}") \
+        if as.find { |a| ! a.is_a?(String) }
+
+    sta = as.inject { |s, a| s.length < a.length ? s : a }
+
+    do_assert(as.filter { |a| a != sta }, 'ending with') { |a|
+      a.end_with?(sta) }
+  end
+
+  def assert_include(*as)
+
+    ai =
+      as.index { |a| a.is_a?(Array) } ||
+      fail(ArgumentError.new("assert_include found no array"))
+
+    arr = as.delete_at(ai)
+
+    do_assert(as, 'included') { |e| arr.include?(e) }
+  end
+
+  def assert_size(*as)
+
+    ai =
+      as.index { |a| a.is_a?(Integer) && a >= 0 } ||
+      fail(ArgumentError.new("assert_size found no integer >= 0"))
+
+    sz = as.delete_at(ai)
+
+    as = as.collect { |a| a.respond_to?(:size) ? a.size : a.class }
+
+    do_assert(as, "size #{sz}") { |a| a == sz }
+  end
+  alias assert_count assert_size
+
+  def assert_hashy(*as)
+
+    do_assert(as[0].to_a, 'hashy equal') { |k, v| k == v }
+  end
+
+  def assert_instance_of(*as)
+
+    moc = as.find { |a| a.is_a?(Module) }
+    as.delete(moc)
+
+    do_assert(as, 'instance of') { |e| e.is_a?(moc) }
+  end
+  alias assert_is_a assert_instance_of
+
+  def assert_error(*as, &block)
+
+    block = block || as.find { |a| a.is_a?(Proc) }
+    as.delete(block)
+
+    fail ArgumentError.new("assert_error expects a block or a proc") \
+      unless block
+
+    err = nil;
+      begin; block.call; rescue => err; end
+
+    return "no error raised" unless err.is_a?(StandardError)
+
+    as.each do |a|
+
+      case a
+      when String
+        return "error message #{err.message} is not #{a.inspect}" \
+          unless err.message == a
+      when Regexp
+        return "error message #{err.message} did not match #{a.inspect}" \
+          unless err.message.match(a)
+      when Module
+        return "error is of class #{err.class} not #{a.name}" \
+          unless err.is_a?(a)
+      else
+        fail ArgumentError.new("assert_error cannot fathom #{a.inspect}")
+      end
+    end
+
+    true
+  end
+
+  def assert_not_error(*as, &block)
+
+    block = block || as.find { |a| a.is_a?(Proc) }
+
+    err = nil;
+      begin; block.call; rescue => err; end
+
+    return "no error expected but returned #{err.class} #{err.name}" if err
+
+    true
+  end
+  alias assert_no_error assert_not_error
+
+  # Checks whether its "_assert_something", if that's the case,
+  # just flags the assertion as :pending an moves on
+  #
+  def method_missing(name, *args, &block)
+
+    n = name.to_s
+
+    if n.start_with?('_assert') && self.respond_to?(n[1..-1])
+
+      Probatio.despatch(:assertion_pending, self, @__child)
+
+      :pending
+
+    else
+
+      super
+    end
+  end
+
+  # Jack of all trade assert
+  #
+  def assert(*as)
+
+    count = {
+      rexes: 0, hashes: 0, arrays: 0, strings: 0, scalars: 0, others: 0 }
+
+    as.each { |a|
+      k =
+        case a
+        when Regexp then :rexes
+        when Hash then :hashes
+        when Array then :arrays
+        when String then :strings
+        else :others; end
+      count[k] = count[k] + 1
+      count[:scalars] += 1 if %i[ rexes strings ].include?(k) }
+
+    if as.length == 1 && count[:hashes] == 1
+
+      assert_hashy(*as)
+
+    elsif as.length == 1
+
+      assert_truthy(*as)
+
+    elsif count[:rexes] == 1 && count[:strings] == as.length - 1
+
+      assert_match(*as)
+
+    #elsif count[:arrays] > 0
+    #  assert_include(*as)
+
+    else
+
+      assert_equal(*as)
+    end
+  end
+
+  protected
+
+  def do_assert(as, msg, &block)
+
+    do_assert_(as) do
+
+      rs, ws = as.partition(&block)
+      wi = ws.empty? ? -1 : as.index(ws.first)
+
+      wi == -1 ? true :
+      "not #{msg}: arg[#{wi}]: #{val_to_s(ws.first)}"
+    end
+  end
+
+  def do_assert_(as, &block)
+
+    Probatio.despatch(:assertion_enter, self, @__child)
+
+    case r =
+      begin; block.call; rescue => err; err; end
+
+    when StandardError, Hash, String
+
+      aerr = make_assertion_error(as, r)
+
+      Probatio.despatch(:test_fail, self, @__child, aerr)
+
+      raise aerr
+
+    when Exception
+
+      Probatio.despatch(:test_exception, self, @__child, r)
+
+      raise r
+
+    when :pending
+
+      :pending
+
+    else
+
+      true
+    end
+
+  ensure
+
+    #Probatio.despatch(:test_succeed, self, @__child)
+    Probatio.despatch(:assertion_leave, self, @__child)
+  end
+
+  def make_assertion_error(arguments, result)
+
+    Probatio::AssertionError
+      .new(
+        extract_assert_method(caller),
+        arguments,
+        result,
+        @__child,
+        *extract_file_and_line(caller))
+  end
+
+  def extract_file_and_line(backtrace)
+
+    #l = backtrace.find { |l|
+    #  ! l.index('lib/probatio/assertions.rb') &&
+    #  ! l.index('_helper.rb') }
+    l = backtrace.find { |l| l.index('_test.rb') }
+
+    m = l && l.match(/([^:]+):(\d+)/)
+    m && [ m[1], m[2].to_i ]
+  end
+
+  def extract_assert_method(backtrace)
+
+    backtrace.inject(nil) { |r, l|
+      r ||
+      begin
+        m = l.match(/[^a-zA-Z_](assert_[a-z0-9_]+)/)
+        m && m[1]
+      end }
+  end
+
+  MAX_VS_LENGTH = 42
+
+  def val_to_s(v)
+
+    vs = v.inspect
+    vs = vs[0, MAX_VS_LENGTH - 1] + '…' if vs.length > MAX_VS_LENGTH
+
+    ">#{vs}<"
+  end
+end
+

data/lib/probatio/debug.rb

@@ -0,0 +1,35 @@
+
+#
+# probatio/debug.rb
+
+module Probatio
+
+  module DebugMethods
+
+    def debug(*as, &block)
+
+      return unless $_PROBATIO_DEBUG.include?(as.shift)
+
+      $stderr.print $_PROBATIO_COLOURS.green
+      $stderr.puts(*as) if as.any?
+      $stderr.puts block.call if block
+      $stderr.print $_PROBATIO_COLOURS.reset
+    end
+
+    def dbg_s(*as, &block)
+
+      debug(:s, *as, &block)
+    end
+
+    def dbg_m(*as, &block)
+
+      debug(:m, *as, &block)
+    end
+  end
+
+  class << self
+
+    include DebugMethods
+  end
+end
+

data/lib/probatio/examples/a_plugin.rb

@@ -0,0 +1,14 @@
+
+#
+# examples of probatio plugins
+
+class MyProbatioPlugin
+
+  def on_test_succeed(ev)
+
+    puts "GREAT SUCCESS! " + ev.to_s
+  end
+end
+
+Probatio.plug(MyProbatioPlugin.new)
+

data/lib/probatio/examples/a_test.rb

@@ -0,0 +1,126 @@
+
+group 'core' do
+
+  setup do
+    # occurs once before tests and sub-groups in group 'core'
+  end
+  teadowm do
+    # occurs once after tests and sub-groups in group 'core'
+  end
+
+  group 'alpha' do
+
+    before do
+      # is run in the separate test context before _each_ test
+    end
+    after do
+      # is run in the separate test context after _each_ test
+    end
+
+    test 'one' do
+
+      MyLib.do_this_or_that()
+
+      assert_nil nil
+      assert_not_nil [], 1
+
+      assert_true true
+      assert_false 1 > 2
+
+      assert_truthy "yes", "no"
+      assert_trueish "yes", "no"
+      assert_falsy nil, false
+      assert_falsey nil, false
+      assert_falseish nil, false
+
+      assert_any %w[ an array ], 'a string'
+      assert_empty [], ''
+
+      assert_size [], 0
+      assert_size 'foo', 3
+      assert_size { a: 1 }, 1
+      assert_count %w[ a b c ], 3
+
+      assert_equal 'one', 'o' + 'ne'
+        # checks that all its arguments are equal
+
+      assert_match 'one', /^one$/
+        # checks that it receives a regex and one or more strings
+        # and that all those strings match the regex
+
+      assert_start_with 'one', 'one two or three'
+        # checks that the shortest string is the start of the remaining string
+        # arguments
+      assert_end_with 'three', 'one two or three'
+        # checks that the shortest string is the end of the remaining string
+        # arguments
+
+      assert_include 1, [ 1, 'two' ]
+        # checks that the first array argument includes all other arguments
+
+      assert_error(ArgumentError) { do_this_or_that() }
+        # checks that the given block raises an ArgumentError
+      assert_error(ArgumentError, /bad/) { do_this_or_that() }
+        # checks that the given block raises an ArgumentError and
+        # the error message matches the /bad/ regexp
+      assert_error lambda { do_this_or_that() }, ArgumentError
+        # checks that the given Proc raises an ArgumentError
+      assert_error lambda { do_this_or_that() }, ArgumentError, 'bad'
+        # checks that the given Proc raises an ArgumentError and
+        # the error message == "bad"
+
+      assert_hashy(
+        this_thing => 1,
+        that_thing => 'two')
+          # combines two assert_equals in one
+
+      assert_instance_of 1, Integer
+      assert_is_a Integer, 123
+        # checks that value or set of values are of a given of class
+
+      assert 1, 1
+        # behaves like assert_equal
+      assert 'one', /one/i
+        # behaves like assert_match
+      assert 11 => '10'.to_i + 1
+        # assert equality between key and value
+      assert 'one' => 'on' + 'e', 'two' => :two.to_s
+        # assert equality between keys and values
+    end
+  end
+
+  group 'bravo' do
+  end
+end
+
+group 'core' do
+  #
+  # it's OK to re-open a group to add sub-groups, tests,
+  # and setups, teardowns, befores, or afters
+  #
+  # it's OK to re-open a group in another file, as long
+  # as it's the same name at the same point in the name hierarchy
+
+  _test 'not yet' do
+    #
+    # prefix a test, a group, or other element with _
+    # marks it as _pending
+  end
+end
+
+group 'core', 'sub-core', 'sub-sub-core' do
+  #
+  # it's OK to specifiy a path of group names
+
+  test 'this' do
+  end
+end
+
+group 'core < sub-core < sub-sub-core' do
+  #
+  # this is also ok...
+
+  test 'that' do
+  end
+end
+

data/lib/probatio/mangle.rb

@@ -0,0 +1,42 @@
+
+#
+# probatio/mangle.rb
+
+module Probatio
+
+  class << self
+
+    def mangle(dirs, files, switches)
+
+      dry = switches['-y'] || switches['--dry']
+
+      (
+        dirs.collect { |d| Dir[File.join(d, '**', '*_spec.rb')] }.flatten +
+        files.select { |f| f.match?(/_spec\.rb$/) }
+      )
+        .each do |path|
+
+          puts c.dark_gray(". considering #{c.green(path)}")
+          p1 = path[0..-8] + 'test.rb'
+          puts c.dark_gray("  .. writing to #{c.light_green(p1)}")
+
+          next if dry
+
+          File.open(p1, 'wb') do |f|
+            f.write(
+              File.read(path)
+                .gsub(/^(\s*)describe(\s+)/) { "#{$1}group#{$2}" }
+                .gsub(/^(\s*)context(\s+)/) { "#{$1}group#{$2}" }
+                .gsub(/^(\s*)it(\s+)/) { "#{$1}test#{$2}" }
+                .gsub(/^(\s*)expect(\(|\s)/) { "#{$1}assert#{$2}" }
+                .gsub(/\)\.to (eq|match)\(/) { ', ' }
+                .gsub(/\n\s*, */) { ",\n" }
+            )
+          end
+
+          puts c.dark_gray("    .. wrote to #{c.light_green(p1)}")
+        end
+    end
+  end
+end
+

data/lib/probatio/more.rb

@@ -0,0 +1,151 @@
+
+#
+# probatio/more.rb
+
+
+module Probatio; class << self
+
+  def monow; @ts = Process.clock_gettime(Process::CLOCK_MONOTONIC); end
+  def monow_and_delta; ts0, ts1 = @ts, monow; [ ts1, ts1 - (ts0 || ts1) ]; end
+
+  def seconds_to_time_s(f)
+
+    i = f.to_i
+    d = i / (24 * 3600); i = i % (24 * 3600)
+    h = i / 3600; i = i % 3600
+    m = i / 60; i = i % 60
+    s = i
+
+    ms = ((
+      f < 1 ? '%0.6f' :
+      f < 60 ? '%0.3f' :
+      ''
+        ) % (f % 1.0))[2..-1] || ''
+    ms = ms.insert(3, '_') if ms.length > 3
+
+    [ d > 0 ? "#{d}d" : nil,
+      h > 0 ? "#{h}h" : nil,
+      m > 0 ? "#{m}m" : nil,
+      "#{s}s",
+      "#{ms}" ].compact.join('')
+  end
+  alias to_time_s seconds_to_time_s
+
+
+  def to_rexes_and_strs(a)
+
+    a && a.collect { |e| to_rex_or_str(e) }
+  end
+
+  def to_rex_or_str(s)
+
+    m = s.match(/^\/(.+)\/([imx]*)$/); return s unless m
+
+    pat = m[1]; opts = m[2]
+
+    ropts = opts.each_char.inject(0) { |r, c|
+      case c
+      when 'i' then r |= Regexp::IGNORECASE
+      #when 'm' then r |= Regexp::MULTILINE
+      when 'x' then r |= Regexp::EXTENDED
+      else r; end }
+
+    Regexp.new(pat, ropts)
+  end
+
+  def term_width
+
+    (IO.console.winsize[1] rescue nil) ||
+    (`tput cols`.strip.to_i rescue nil) ||
+    80
+  end
+end; end
+
+
+module Cerata; class << self
+
+  # TODO deal with double width characters...
+
+  def horizontal_a_to_s(a, indent='')
+
+    return '[]' if a.empty?
+
+    o = StringIO.new
+
+    o << indent << '[ '
+    a1 = a.dup; while e = a1.shift
+      o << e.inspect
+      o << ', ' if a1.any?
+    end
+    o << ' ]'
+
+    o.string
+  end
+
+  def horizontal_h_to_s(h, indent='')
+
+    return '{}' if h.empty?
+
+    o = StringIO.new
+
+    o << indent << '{ '
+    kvs = h.to_a; while kv = kvs.shift
+      o << "#{kv.first}: " << kv[1].inspect
+      o << ', ' if kvs.any?
+    end
+    o << ' }'
+
+    o.string
+  end
+
+  def vertical_h_to_s(h, indent='')
+
+    return '{}' if h.empty?
+
+    o = StringIO.new
+
+    o << indent << "{\n"
+    h.each { |k, v| o << indent << "#{k}: " << v.inspect << ",\n" }
+    o << indent << '}'
+
+    o.string
+  end
+
+  # A "table" here is an array of hashes
+  #
+  def table_to_s(a, indent='')
+
+    return '[]' if a.empty?
+
+    all_keys =
+      a.collect { |h| h.keys }.flatten.uniq.map(&:to_s)
+    key_widths =
+      all_keys.inject({}) { |h, k| h[k] = k.length; h }
+    val_widths =
+      a.inject({}) { |w, h|
+        h.each { |k, v| k = k.to_s; w[k] = [ w[k] || 0, v.inspect.length ].max }
+        w }
+
+    o = StringIO.new
+
+    o << indent << "[\n"
+
+    a.each do |h|
+      o << indent << '{ '
+      kvs = h.to_a; while kv = kvs.shift
+        k, v = kv[0].to_s, kv[1].inspect
+        kl, vl = key_widths[k], val_widths[k]
+        kf = "%#{kl}s"
+        vf = v.start_with?('"') ? "%#{vl}s" : "%-#{vl}s"
+        o << ("#{kf}: #{vf}" % [ k, v ])
+        o << ', ' if kvs.any?
+      end
+      o << " },\n"
+    end
+
+    o << indent << ']'
+
+    o.string
+  end
+end; end
+