tryouts 2.3.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 964b15141b2d2a8658bb5beee61ef9618ad478b8c29a4c91c5595dfb7ac92323
-  data.tar.gz: b33744a232df6dd0020deef5ea682217481ba6fc17d6d1336ccb9dc314080052
+  metadata.gz: 8c9881b556aa0492a4e0cba92343efa2c9761664a9507ac3d123fee8143301b8
+  data.tar.gz: 245f405149281445c9bb902695919f6fbd4c5ec461303f16c7078ed6ddcbe111
 SHA512:
-  metadata.gz: 4116e1c5918e226ec2232a55cd4dfdc8ff034948ceafa03ca3cdaecee6df4aa2f7d1dc5598eed66074f0c2e22c71492b7fab83c83b8869165897be69cabf4e9c
-  data.tar.gz: 826761b6d51762fb214380d05d438ab70b029bab4c7a138b59909ac096bcdc5bc79d7aed6c6f2509d728b6ea59f8ea03201fb42e6e77002fef1cd47a7635ec7d
+  metadata.gz: ced6968dc159ab82ffcc8902b9835977bfdac9fbf1f8290ce20c216a09fb07fe7731235ac464827094cdebb422048ae963cf396fcb604c37d8945d73d148a619
+  data.tar.gz: b57ed46b023c084209153176fcbb05c4ec710cf1da0a77e61db1ac14e50b87f4bd1c5d35c73e2b9a950d855415e4728d5f229138bb6d8d51edab1bb3df8961f3

data/README.md

@@ -1,4 +1,4 @@
-# Tryouts v2.3.0 (2024-04-04)
+# Tryouts v2.3.1 (2024-06-18)
 
 **Ruby tests that read like documentation.**
 

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:MAJOR: 2
+:MINOR: 3
+:PATCH: 1

data/exe/try

@@ -3,35 +3,49 @@
 require 'optparse'
 require_relative '../lib/tryouts'
 
-# Add local lib directories to the load path
-Dir.glob(File.join(Dir.pwd, '{lib,..,lib}')).each { |dir| $LOAD_PATH.unshift(dir) }
+# Adding local lib directories allows the test files
+# to require the ruby code they are testing without
+# needing even if the files use regular requires. It
+# skips the test files from having to muck with the
+# load path or use `require_relative` which is easy
+# to forget. This is a convenience feature.
+#
+# Here we're looking for directories relative to the
+# current working directory (i.e. where this script
+# is being run from.
+lib_glob = File.join(Dir.pwd, '{lib,../lib,.}')
+Tryouts.update_load_path(lib_glob)
 
 # Parse command-line arguments
-options = { quiet: false, noisy: false, fails: false }
 OptionParser.new do |opts|
-  opts.on('-V', '--version', 'Display the version') { puts "Tryouts: #{Tryouts::VERSION}"; exit }
-  opts.on('-q', '--quiet', 'Run in quiet mode') { options[:quiet] = true }
-  opts.on('-v', '--verbose', 'Run in verbose mode') { options[:noisy] = true }
-  opts.on('-f', '--fails', 'Show only failing tryouts') { options[:fails] = true }
+  opts.on('-V', '--version', 'Display the version') do
+    puts "Tryouts: #{Tryouts::VERSION}"
+    exit
+  end
+  opts.on('-q', '--quiet', 'Run in quiet mode') { Tryouts.quiet = true }
+  opts.on('-v', '--verbose', 'Run in verbose mode') { Tryouts.noisy = true }
+  opts.on('-f', '--fails', 'Show only failing tryouts') { Tryouts.fails = true }
   opts.on('-D', '--debug', 'Run in debug mode') { Tryouts.debug = true }
-  opts.on('-h', '--help', 'Display this help') { puts opts; exit }
+  opts.on('-h', '--help', 'Display this help') do
+    puts opts
+    exit
+  end
 end.parse!
 
-# Set Tryouts options
-Tryouts.quiet = options[:quiet]
-Tryouts.noisy = options[:noisy]
-Tryouts.fails = options[:fails]
+# Find tryouts path with a path glob unless thin
+# script was called with arguments in which case
+# we consume those as a list of paths.
+paths = if ARGV.empty?
+          Dir.glob(
+            ['./{try,tryouts/,.}/*_{try,tryouts}.rb'],
+            base: Dir.pwd
+          ).sort # deterministic order
 
-# Find tryouts path
-if ARGV.empty?
-  paths = Dir.glob(
-    ['./{try,tryouts/,.}/*_{try,tryouts}.rb'],
-    base: Dir.pwd,
-    sort: true  # deterministic order
-  )
-
-else
-  paths = ARGV
-end
+        else
+          ARGV
+        end
 
+# Running the tryouts returns the number of
+# test failures so here we pass that value
+# through as the exit code for the script.
 exit Tryouts.run_all(*paths)

data/lib/tryouts/console.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+class Tryouts
+  module Console
+    # ANSI escape sequence numbers for text attributes
+    unless defined? ATTRIBUTES
+      ATTRIBUTES = {
+        normal: 0,
+        bright: 1,
+        dim: 2,
+        underline: 4,
+        blink: 5,
+        reverse: 7,
+        hidden: 8,
+        default: 0
+      }.freeze
+    end
+
+    # ANSI escape sequence numbers for text colours
+    unless defined? COLOURS
+      COLOURS = {
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37,
+        default: 39,
+        random: 30 + rand(10).to_i
+      }.freeze
+    end
+
+    # ANSI escape sequence numbers for background colours
+    unless defined? BGCOLOURS
+      BGCOLOURS = {
+        black: 40,
+        red: 41,
+        green: 42,
+        yellow: 43,
+        blue: 44,
+        magenta: 45,
+        cyan: 46,
+        white: 47,
+        default: 49,
+        random: 40 + rand(10).to_i
+      }.freeze
+    end
+
+    module InstanceMethods
+      def bright
+        Console.bright(self)
+      end
+
+      def underline
+        Console.underline(self)
+      end
+
+      def reverse
+        Console.reverse(self)
+      end
+
+      def color(col)
+        Console.color(col, self)
+      end
+
+      def att(col)
+        Console.att(col, self)
+      end
+
+      def bgcolor(col)
+        Console.bgcolor(col, self)
+      end
+    end
+
+    def self.bright(str)
+      str = [style(ATTRIBUTES[:bright]), str, default_style].join
+      str.extend Console::InstanceMethods
+      str
+    end
+
+    def self.underline(str)
+      str = [style(ATTRIBUTES[:underline]), str, default_style].join
+      str.extend Console::InstanceMethods
+      str
+    end
+
+    def self.reverse(str)
+      str = [style(ATTRIBUTES[:reverse]), str, default_style].join
+      str.extend Console::InstanceMethods
+      str
+    end
+
+    def self.color(col, str)
+      str = [style(COLOURS[col]), str, default_style].join
+      str.extend Console::InstanceMethods
+      str
+    end
+
+    def self.att(name, str)
+      str = [style(ATTRIBUTES[name]), str, default_style].join
+      str.extend Console::InstanceMethods
+      str
+    end
+
+    def self.bgcolor(col, str)
+      str = [style(ATTRIBUTES[col]), str, default_style].join
+      str.extend Console::InstanceMethods
+      str
+    end
+
+    def self.style(*att)
+      # => \e[8;34;42m
+      "\e[%sm" % att.join(';')
+    end
+
+    def self.default_style
+      style(ATTRIBUTES[:default], ATTRIBUTES[:COLOURS], ATTRIBUTES[:BGCOLOURS])
+    end
+  end
+end

data/lib/tryouts/section.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+#
+class Tryouts
+  class Section < Array
+    attr_accessor :path, :first, :last
+
+    def initialize(path, start = 0)
+      @path = path
+      @first = start
+      @last = start
+    end
+
+    def range
+      @first..@last
+    end
+
+    def inspect
+      range.to_a.zip(self).collect do |line|
+        "%-4d %s\n" % line
+      end.join
+    end
+
+    def to_s
+      join($/)
+    end
+  end
+end

data/lib/tryouts/testbatch.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+#
+class Tryouts
+  class TestBatch < Array
+    class Container
+      def metaclass
+        class << self; end
+      end
+    end
+    attr_reader :path, :failed, :lines
+
+    def initialize(p, l)
+      @path = p
+      @lines = l
+      @container = Container.new.metaclass
+      @run = false
+    end
+
+    def run(before_test, &after_test)
+      return if empty?
+
+      setup
+      ret = self.select do |tc|
+        before_test.call(tc) unless before_test.nil?
+        ret = !tc.run
+        after_test.call(tc)
+        ret # select failed tests
+      end
+      @failed = ret.size
+      @run = true
+      clean
+      !failed?
+    end
+
+    def failed?
+      !@failed.nil? && @failed > 0
+    end
+
+    def setup
+      return if empty?
+
+      start = first.desc.nil? ? first.test.first : first.desc.first - 1
+      Tryouts.eval lines[0..start - 1].join, path, 0 if start > 0
+    end
+
+    def clean
+      return if empty?
+
+      last_line = last.exps.last + 1
+      return unless last_line < lines.size
+
+      Tryouts.eval lines[last_line..-1].join, path, last_line
+    end
+
+    def run?
+      @run
+    end
+  end
+end

data/lib/tryouts/testcase.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class Tryouts
+  class TestCase
+    attr_reader :desc, :test, :exps, :path, :outlines, :test_result
+
+    def initialize(d, t, e)
+      @desc, @test, @exps, @path = d, t, e
+      @outlines = []
+    end
+
+    def inspect
+      [@desc.inspect, @test.inspect, @exps.inspect].join
+    end
+
+    def to_s
+      [@desc.to_s, @test.to_s, @exps.to_s].join
+    end
+
+    def run
+      Tryouts.debug format('%s:%d', @test.path, @test.first)
+      Tryouts.debug inspect, $/
+      $stdout = StringIO.new
+      expectations = exps.collect do |exp, _idx|
+        exp =~ /\A\#?\s*=>\s*(.+)\Z/
+        ::Regexp.last_match(1) # this will be nil if the expectation is commented out
+      end
+
+      # Evaluate test block only if there are valid expectations
+      unless expectations.compact.empty?  # TODO: fast-fail if no expectations
+        test_value = Tryouts.eval @test.to_s, @test.path, @test.first
+        @has_run = true
+      end
+      $stdout = STDOUT # restore stdout
+
+
+      expectations.each_with_index do |exp, idx|
+        if exp.nil?
+          @outlines << '     [skipped]'
+          @test_result = 0
+        else
+          # Evaluate expectation
+
+          exp_value = Tryouts.eval(exp, @exps.path, @exps.first + idx)
+
+          test_passed = test_value.eql?(exp_value)
+          @test_result = test_passed ? 1 : -1
+          @outlines << test_value.inspect
+        end
+      end
+      Tryouts.debug # extra newline
+      failed?
+
+    rescue Exception => e
+      Tryouts.debug e.message, e.backtrace.join($/), $/
+      $stdout = STDOUT # restore stdout
+    end
+
+    def run?
+      @has_run.eql?(true)
+    end
+
+    def skipped?
+      @test_result == 0
+    end
+
+    def passed?
+      @test_result == 1
+    end
+    def failed?
+      @test_result == -1
+    end
+
+    def color
+      case @test_result
+      when 1
+        :green
+      when 0
+        :white
+      else
+        :red
+      end
+    end
+
+    def adjective
+      case @test_result
+      when 1
+        'PASSED'
+      when 0
+        'SKIPPED'
+      else
+        'FAILED'
+      end
+    end
+
+  end
+end

data/lib/tryouts/version.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 class Tryouts
   module VERSION
     def self.to_s
-      load_config
-      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
+      version_file
+      [@version_file[:MAJOR], @version_file[:MINOR], @version_file[:PATCH]].join('.')
     end
     alias_method :inspect, :to_s
-    def self.load_config
+    def self.version_file
       require 'yaml'
-      @version ||= YAML.load_file(File.join(TRYOUTS_LIB_HOME, '..', 'VERSION.yml'))
+      @version_file ||= YAML.load_file(File.join(TRYOUTS_LIB_HOME, '..', 'VERSION.yml'))
     end
   end
 end

data/lib/tryouts.rb

@@ -1,9 +1,13 @@
-require 'ostruct'
+# frozen_string_literal: true
 
-unless defined?(TRYOUTS_LIB_HOME)
-  TRYOUTS_LIB_HOME = File.expand_path File.dirname(__FILE__)
-end
+require 'stringio'
+
+TRYOUTS_LIB_HOME = __dir__ unless defined?(TRYOUTS_LIB_HOME)
 
+require_relative 'tryouts/console'
+require_relative 'tryouts/section'
+require_relative 'tryouts/testbatch'
+require_relative 'tryouts/testcase'
 require_relative 'tryouts/version'
 
 class Tryouts
@@ -14,9 +18,12 @@ class Tryouts
   @container = Class.new
   @cases = []
   @sysinfo = nil
-  class << self
-    attr_accessor :debug, :container, :quiet, :noisy, :fails
-    attr_reader :cases
+  @testcase_io = StringIO.new
+
+  module ClassMethods
+    attr_accessor :container, :quiet, :noisy, :fails
+    attr_writer :debug
+    attr_reader :cases, :testcase_io
 
     def sysinfo
       require 'sysinfo'
@@ -24,17 +31,26 @@ class Tryouts
       @sysinfo
     end
 
-    def debug?() @debug == true end
+    def debug?
+      @debug == true
+    end
+
+    def update_load_path(lib_glob)
+      Dir.glob(lib_glob).each { |dir| $LOAD_PATH.unshift(dir) }
+    end
 
     def run_all *paths
       batches = paths.collect do |path|
         parse path
       end
 
-      all, skipped_tests, failed_tests = 0, 0, 0
-      skipped_batches, failed_batches = 0, 0
+      all = 0
+      skipped_tests = 0
+      failed_tests = 0
+      skipped_batches = 0
+      failed_batches = 0
 
-      msg 'Ruby %s @ %-40s' % [RUBY_VERSION, Time.now], $/
+      msg format('Ruby %s @ %-60s', RUBY_VERSION, Time.now), $/
 
       if Tryouts.debug?
         Tryouts.debug "Found #{paths.size} files:"
@@ -43,415 +59,213 @@ class Tryouts
       end
 
       batches.each do |batch|
-
-        path = batch.path.gsub(/#{Dir.pwd}\/?/, '')
-
-        vmsg '%-60s %s' % [path, '']
-
-        before_handler = Proc.new do |t|
-          if Tryouts.noisy && !Tryouts.fails
-            vmsg Console.reverse(' %-58s ' % [t.desc.to_s])
-            vmsg t.test.inspect, t.exps.inspect
+        path = batch.path.gsub(%r{#{Dir.pwd}/?}, '')
+        divider = '-' * 70
+        path_pretty = format('>>>>>  %-20s  %s', path, '').ljust(70, '<')
+
+        msg $/
+        vmsg Console.reverse(divider)
+        vmsg Console.reverse(path_pretty)
+        vmsg Console.reverse(divider)
+        vmsg $/
+
+        before_handler = proc do |tc|
+          if Tryouts.noisy
+            tc_title = tc.desc.to_s
+            vmsg Console.underline(format('%-58s ', tc_title))
+            vmsg tc.test.inspect, tc.exps.inspect
           end
         end
 
-        batch.run(before_handler) do |t|
-          if t.failed?
-            failed_tests += 1
-            if Tryouts.noisy && Tryouts.fails
-              vmsg Console.color(:red, t.failed.join($/)), $/
-            else
-              msg ' %s (%s:%s)' % [Console.color(:red, "FAIL"), path, t.exps.first]
-            end
-          elsif (t.skipped? || !t.run?) && !Tryouts.fails
-            skipped_tests += 1
-            if Tryouts.noisy
-              vmsg Console.bright(t.skipped.join($/)), $/
-            else
-              msg ' SKIP (%s:%s)' % [path, t.exps.first]
-            end
-          elsif !Tryouts.fails
-            if Tryouts.noisy
-              vmsg Console.color(:green, t.passed.join($/)), $/
-            else
-              msg ' %s' % [Console.color(:green, 'PASS')]
-            end
-          end
+        batch.run(before_handler) do |tc|
           all += 1
+          failed_tests += 1 if tc.failed?
+          skipped_tests += 1 if tc.skipped?
+          codelines = tc.outlines.join($/)
+          first_exp_line = tc.exps.first
+          result_adjective = tc.failed? ? 'FAILED' : 'PASSED'
+
+          first_exp_line = tc.exps.first
+          location = format('%s:%d', tc.exps.path, first_exp_line)
+
+          expectation = Console.color(tc.color, codelines)
+          summary = Console.color(tc.color, "%s @ %s" % [tc.adjective, location])
+          vmsg '         %s' % expectation
+          if tc.failed?
+            msg Console.reverse(summary)
+          else
+            msg summary
+          end
+          vmsg
+
+          # Output buffered testcase_io to stdout
+          # and reset it for the next test case.
+          unless Tryouts.fails && !tc.failed?
+            $stdout.puts testcase_io.string unless Tryouts.quiet
+          end
+
+          # Reset the testcase IO buffer
+          testcase_io.truncate(0)
         end
       end
 
-      msg
-      if all > 0
-        suffix = 'tests passed'
-        suffix << " (and #{skipped_tests} skipped)" if skipped_tests > 0
-        msg cformat(all-failed_tests-skipped_tests, all-skipped_tests, suffix) if all-skipped_tests > 0
-      end
-      if batches.size > 1
-        if batches.size-skipped_batches > 0
-          suffix = "batches passed"
-          suffix << " (and #{skipped_batches} skipped)" if skipped_batches > 0
-          msg cformat(batches.size-skipped_batches-failed_batches, batches.size-skipped_batches, suffix)
+      # Create a line of separation before the result summary
+      msg $INPUT_RECORD_SEPARATOR  # newline
+
+      if all
+        suffix = "tests passed (#{skipped_tests} skipped)" if skipped_tests > 0
+        actual_test_size = all - skipped_tests
+        if actual_test_size > 0
+          msg cformat(all - failed_tests - skipped_tests, all - skipped_tests, suffix)
         end
       end
 
-      failed_tests # 0 means success
+      actual_batch_size = (batches.size - skipped_batches)
+      if batches.size > 1 && actual_batch_size > 0
+        suffix = 'batches passed'
+        suffix << " (#{skipped_batches} skipped)" if skipped_batches > 0
+        msg cformat(batches.size - skipped_batches - failed_batches, batches.size - skipped_batches, suffix)
+      end
+
+      # Print out the buffered result summary
+      $stdout.puts testcase_io.string
+
+      failed_tests  # returns the number of failed tests (0 if all passed)
     end
 
     def cformat(*args)
       Console.bright '%d of %d %s' % args
     end
 
-    def run path
+    def run(path)
       batch = parse path
       batch.run
       batch
     end
 
-    def parse path
-      #debug "Loading #{path}"
+    def parse(path)
+      # debug "Loading #{path}"
       lines = File.readlines path
       skip_ahead = 0
       batch = TestBatch.new path, lines
       lines.size.times do |idx|
         skip_ahead -= 1 and next if skip_ahead > 0
+
         line = lines[idx].chomp
-        #debug('%-4d %s' % [idx, line])
-        if expectation? line
-          offset = 0
-          exps = Section.new(path, idx+1)
-          exps << line.chomp
-          while (idx+offset < lines.size)
-            offset += 1
-            this_line = lines[idx+offset]
-            break if ignore?(this_line)
-            if expectation?(this_line)
-              exps << this_line.chomp
-              skip_ahead += 1
-            end
-            exps.last += 1
+        # debug('%-4d %s' % [idx, line])
+        next unless expectation? line
+
+        offset = 0
+        exps = Section.new(path, idx + 1)
+        exps << line.chomp
+        while idx + offset < lines.size
+          offset += 1
+          this_line = lines[idx + offset]
+          break if ignore?(this_line)
+
+          if expectation?(this_line)
+            exps << this_line.chomp
+            skip_ahead += 1
           end
+          exps.last += 1
+        end
 
-          offset = 0
-          buffer, desc = Section.new(path), Section.new(path)
-          test = Section.new(path, idx)  # test start the line before the exp.
-          blank_buffer = Section.new(path)
-          while (idx-offset >= 0)
-            offset += 1
-            this_line = lines[idx-offset].chomp
-            buffer.unshift this_line if ignore?(this_line)
-            if comment?(this_line)
-              buffer.unshift this_line
-            end
-            if test?(this_line)
-              test.unshift(*buffer) && buffer.clear
-              test.unshift this_line
-            end
-            if test_begin?(this_line)
-              while test_begin?(lines[idx-(offset+1)].chomp)
-                offset += 1
-                buffer.unshift lines[idx-offset].chomp
-              end
-            end
-            if test_begin?(this_line) || idx-offset == 0 || expectation?(this_line)
-              adjust = expectation?(this_line) ? 2 : 1
-              test.first = idx-offset+buffer.size+adjust
-              desc.unshift *buffer
-              desc.last = test.first-1
-              desc.first = desc.last-desc.size+1
-              # remove empty lines between the description
-              # and the previous expectation
-              while !desc.empty? && desc[0].empty?
-                desc.shift
-                desc.first += 1
-              end
-              break
+        offset = 0
+        buffer = Section.new(path)
+        desc = Section.new(path)
+        test = Section.new(path, idx) # test start the line before the exp.
+        while idx - offset >= 0
+          offset += 1
+          this_line = lines[idx - offset].chomp
+          buffer.unshift this_line if ignore?(this_line)
+          buffer.unshift this_line if comment?(this_line)
+          if test?(this_line)
+            test.unshift(*buffer) && buffer.clear
+            test.unshift this_line
+          end
+          if test_begin?(this_line)
+            while test_begin?(lines[idx - (offset + 1)].chomp)
+              offset += 1
+              buffer.unshift lines[idx - offset].chomp
             end
           end
-
-          batch << TestCase.new(desc, test, exps)
+          next unless test_begin?(this_line) || idx - offset == 0 || expectation?(this_line)
+
+          adjust = expectation?(this_line) ? 2 : 1
+          test.first = idx - offset + buffer.size + adjust
+          desc.unshift(*buffer)
+          desc.last = test.first - 1
+          desc.first = desc.last - desc.size + 1
+          # remove empty lines between the description
+          # and the previous expectation
+          while !desc.empty? && desc[0].empty?
+            desc.shift
+            desc.first += 1
+          end
+          break
         end
+
+        batch << TestCase.new(desc, test, exps)
       end
 
       batch
     end
-
-    def print str
+    def print(str)
       return if Tryouts.quiet
-      STDOUT.print str
-      STDOUT.flush
+
+      $stdout.print str
+      $stdout.flush
     end
 
-    def vmsg *msg
-      STDOUT.puts *msg if !Tryouts.quiet && Tryouts.noisy
+    def vmsg *msgs
+      msg(*msgs) if Tryouts.noisy
     end
 
-    def msg *msg
-      STDOUT.puts *msg unless Tryouts.quiet
+    def msg *msgs
+      testcase_io.puts(*msgs) unless Tryouts.quiet
     end
 
-    def err *msg
+    def err *msgs
       msg.each do |line|
-        STDERR.puts Console.color :red, line
+        $stderr.puts Console.color :red, line
       end
     end
 
-    def debug *msg
-      STDERR.puts *msg if @debug
+    def debug *msgs
+      $stderr.puts(*msgs) if debug?
     end
 
     def eval(str, path, line)
-      begin
-        Kernel.eval str, @container.send(:binding), path, line
-      rescue SyntaxError, LoadError => ex
-        Tryouts.err Console.color(:red, ex.message),
-                    Console.color(:red, ex.backtrace.first)
-        nil
-      end
+      Kernel.eval str, @container.send(:binding), path, line
+    rescue SyntaxError, LoadError => e
+      Tryouts.err Console.color(:red, e.message),
+                  Console.color(:red, e.backtrace.first)
+      nil
     end
 
     private
 
-    def expectation? str
+    def expectation?(str)
       !ignore?(str) && str.strip.match(/\A\#+\s*=>/)
     end
 
-    def comment? str
+    def comment?(str)
       !str.strip.match(/^\#+/).nil? && !expectation?(str)
     end
 
-    def test? str
+    def test?(str)
       !ignore?(str) && !expectation?(str) && !comment?(str)
     end
 
-    def ignore? str
+    def ignore?(str)
       str.to_s.strip.chomp.empty?
     end
 
-    def test_begin? str
-      ret = !str.strip.match(/\#+\s*TEST/i).nil? ||
-      !str.strip.match(/\A\#\#+[\s\w]+/i).nil?
-      ret
-    end
-
-
-  end
-
-  class TestBatch < Array
-    class Container
-      def metaclass
-        class << self; end
-      end
-    end
-    attr_reader :path
-    attr_reader :failed
-    attr_reader :lines
-    def initialize(p,l)
-      @path, @lines = p, l
-      @container = Container.new.metaclass
-      @run = false
-    end
-    def run(before_test, &after_test)
-      return if empty?
-      setup
-      ret = self.select { |tc|
-        before_test.call(tc) unless before_test.nil?
-        ret = !tc.run
-        after_test.call(tc)
-        ret # select failed tests
-      }
-      @failed = ret.size
-      @run = true
-      clean
-      !failed?
-    end
-    def failed?
-       !@failed.nil? && @failed > 0
-    end
-    def setup
-      return if empty?
-      start = first.desc.nil? ? first.test.first : first.desc.first-1
-      Tryouts.eval lines[0..start-1].join, path, 0 if start > 0
-    end
-    def clean
-      return if empty?
-      last_line = last.exps.last+1
-      if last_line < lines.size
-        Tryouts.eval lines[last_line..-1].join, path, last_line
-      end
-    end
-    def run?
-      @run
-    end
-  end
-  class TestCase
-    attr_reader :desc, :test, :exps, :failed, :passed, :skipped
-    def initialize(d,t,e)
-      @desc, @test, @exps, @path = d,t,e
-    end
-    def inspect
-      [@desc.inspect, @test.inspect, @exps.inspect].join
-    end
-    def to_s
-      [@desc.to_s, @test.to_s, @exps.to_s].join
-    end
-    def run
-      Tryouts.debug '%s:%d' % [@test.path, @test.first]
-      Tryouts.debug inspect, $/
-      expectations = exps.collect { |exp,idx|
-        exp =~ /\A\#?\s*=>\s*(.+)\Z/
-        $1  # this will be nil if the expectation is commented out
-      }
-
-      # Evaluate test block only if there are valid expectations
-      unless expectations.compact.empty?
-        test_value = Tryouts.eval @test.to_s, @test.path, @test.first
-        @has_run = true
-      end
-
-      @passed, @failed, @skipped = [], [], []
-      expectations.each_with_index { |exp,idx|
-        if exp.nil?
-          @skipped <<  '     [skipped]'
-        else
-          exp_value = Tryouts.eval(exp, @exps.path, @exps.first+idx)
-          if test_value == exp_value
-            @passed << '     ==  %s' % [test_value.inspect]
-          else
-            @failed << '     !=  %s' % [test_value.inspect]
-          end
-        end
-      }
-      Tryouts.debug
-      @failed.empty?
-    end
-    def skipped?
-      !@skipped.nil? && !@skipped.empty?
-    end
-    def run?
-      @has_run == true
-    end
-    def failed?
-      !@failed.nil? && !@failed.empty?
-    end
-    private
-    def create_proc str, path, line
-      eval("Proc.new {\n  #{str}\n}", binding, path, line)
-    end
-  end
-  class Section < Array
-    attr_accessor :path, :first, :last
-    def initialize path, start=0
-      @path = path
-      @first, @last = start, start
-    end
-    def range
-      @first..@last
-    end
-    def inspect
-      range.to_a.zip(self).collect do |line|
-        "%-4d %s\n" % line
-      end.join
-    end
-    def to_s
-      self.join($/)
-    end
-  end
-
-
-  module Console
-
-    # ANSI escape sequence numbers for text attributes
-    ATTRIBUTES = {
-      :normal     => 0,
-      :bright     => 1,
-      :dim        => 2,
-      :underline  => 4,
-      :blink      => 5,
-      :reverse    => 7,
-      :hidden     => 8,
-      :default    => 0,
-    }.freeze unless defined? ATTRIBUTES
-
-    # ANSI escape sequence numbers for text colours
-    COLOURS = {
-      :black   => 30,
-      :red     => 31,
-      :green   => 32,
-      :yellow  => 33,
-      :blue    => 34,
-      :magenta => 35,
-      :cyan    => 36,
-      :white   => 37,
-      :default => 39,
-      :random  => 30 + rand(10).to_i
-    }.freeze unless defined? COLOURS
-
-    # ANSI escape sequence numbers for background colours
-    BGCOLOURS = {
-      :black   => 40,
-      :red     => 41,
-      :green   => 42,
-      :yellow  => 43,
-      :blue    => 44,
-      :magenta => 45,
-      :cyan    => 46,
-      :white   => 47,
-      :default => 49,
-      :random  => 40 + rand(10).to_i
-    }.freeze unless defined? BGCOLOURS
-
-    module InstanceMethods
-      def bright
-        Console.bright(self)
-      end
-      def reverse
-        Console.reverse(self)
-      end
-      def color(col)
-        Console.color(col, self)
-      end
-      def att(col)
-        Console.att(col, self)
-      end
-      def bgcolor(col)
-        Console.bgcolor(col, self)
-      end
-    end
-
-    def self.bright(str)
-      str = [style(ATTRIBUTES[:bright]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
-    def self.reverse(str)
-      str = [style(ATTRIBUTES[:reverse]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
-    def self.color(col, str)
-      str = [style(COLOURS[col]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
-    def self.att(name, str)
-      str = [style(ATTRIBUTES[name]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
-    def self.bgcolor(col, str)
-      str = [style(ATTRIBUTES[col]), str, default_style].join
-      str.extend Console::InstanceMethods
-      str
-    end
-    private
-    def self.style(*att)
-      # => \e[8;34;42m
-      "\e[%sm" % att.join(';')
-    end
-    def self.default_style
-      style(ATTRIBUTES[:default], ATTRIBUTES[:COLOURS], ATTRIBUTES[:BGCOLOURS])
+    def test_begin?(str)
+      !str.strip.match(/\#+\s*TEST/i).nil? ||
+        !str.strip.match(/\A\#\#+[\s\w]+/i).nil?
     end
   end
 
+  extend ClassMethods
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tryouts
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.3.1
 platform: ruby
 authors:
 - Delano Mandelbaum
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies: []
 description: A simple test framework for Ruby code that uses introspection to allow
   defining checks in comments.
@@ -21,9 +21,14 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
+- VERSION.yml
 - exe/try
 - exe/tryouts
 - lib/tryouts.rb
+- lib/tryouts/console.rb
+- lib/tryouts/section.rb
+- lib/tryouts/testbatch.rb
+- lib/tryouts/testcase.rb
 - lib/tryouts/version.rb
 homepage: https://github.com/delano/tryouts
 licenses:
@@ -44,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.7
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Ruby tests that read like documentation.