tet 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97ce2949a018ea80d5012fc9dd00268098dd0ece
-  data.tar.gz: fefa2a09bfc0adf45730b15be19785812e75d535
+  metadata.gz: 71c11439cad3f5c481d5242bc65ade2c8780804f
+  data.tar.gz: 6a410a5f775aa07096ed3b56e06cf85baddbdb33
 SHA512:
-  metadata.gz: c60b11a370e690471156621bce8884a3daaaa13bab34e0bb80cb0a9c8e52fb11b24d9f2231f42ff80d0aa65804e25000069095324bbfb3f0f2d125d5dfc0dc6c
-  data.tar.gz: '0719db9dedda2b62d2a413dd3b3342a28c87cff1855fb41b300e165aef30d2998156e67c3b153f1b7ef765f1cf1831e920b570efa613fb056e41d323aba95ab5'
+  metadata.gz: 4bcdfe86d7625c0a0a259a75f61b76165f0bb5dcb20400edaa950207553eaa451af2a219f5b7075c56caabdd46abf0fc573d006e2a3682b70fad43d41027bc2f
+  data.tar.gz: b24180e3e816c9e165d857547072f73e5f4d2a0cbe6d9f5a010e4017a9bf1a95392374228110d45b05241442e3793ebe12bbb9a7a3e8625dd9020c076f17e624

data/lib/tests.rb

@@ -37,7 +37,7 @@ group '#err' do
   err('errors pass')     { raise IntendedError }
   err('non-errors fail') { true }
 
-  err('correct errors pass',   expect: IntendedError)      { raise IntendedError }
+  err('correct errors pass',  expect: IntendedError)      { raise IntendedError }
   err('incorrect errors err', expect: IntendedErrorChild) { raise IntendedError }
 end
 

data/lib/tet.rb

@@ -5,7 +5,7 @@
 # terms of the three-clause BSD license. See LICENSE.txt
 # (located in root directory of this project) for details.
 
-# Label a block of tests
+# Label a block of tests.
 def group label, &block
   Tet.run(
     label: label,
@@ -13,7 +13,7 @@ def group label, &block
   )
 end
 
-# Assert that a block will return a truthy value
+# Assert that a block will return a truthy value.
 def assert label = '', &block
   Tet.run(
     label:   label,
@@ -24,7 +24,7 @@ def assert label = '', &block
   )
 end
 
-# Assert that a block will err
+# Assert that a block will err.
 def err label = '', expect: StandardError, &block
   Tet.run(
     label:   label,
@@ -32,9 +32,9 @@ def err label = '', expect: StandardError, &block
     no_nest: true,
     truthy:  -> { Tet.failed },
     falsy:   -> { Tet.failed },
-    error:   ->(caught) {
+    error:   ->(caught) do
                (expect >= caught.class) ? Tet.passed : Tet.erred(caught, expect)
-             }
+             end
   )
 end
 
@@ -42,41 +42,41 @@ end
 
 # A namespace for all of the helper methods and classes.
 module Tet
-  # Print all the reports after all the tests have run
+  # Print all the reports after all the tests have run.
   at_exit do
-    unless Stats.empty?
-      puts
-      puts_report 'Failures',   Messages.failure_report
-      puts_report 'Exceptions', Messages.error_report
-      puts_report 'Statistics', Stats.report
-    end
+    puts
+    puts_report 'Failures',   failure_report
+    puts_report 'Exceptions', error_report
+    puts_report 'Statistics', statistics_report
   end
 
 
 
-  # An exception class to distinguish errors from incorrectly written tests
+  # An exception class to distinguish errors from incorrectly written tests.
   class TestError < StandardError; end
 
-  # Object oriented way to do string formatting
+
+
+  # Object oriented ways to do string formatting.
   module StringFormatting
     refine String do
       def indent
         gsub(/^/, '    ')
       end
 
-      def to_label
+      def to_label_string
         self
       end
     end
 
     refine Module do
-      def to_label
+      def to_label_string
         name
       end
     end
 
     refine Object do
-      def to_label
+      def to_label_string
         inspect
       end
     end
@@ -86,26 +86,27 @@ module Tet
 
 
 
-  # Helpers for building test methods
+  # Helpers for building test methods.
   class << self
-    # Call when an assertion has passed
+    # Call when an assertion has passed.
     def passed
-      Stats.passed
+      print_now ?.
+      Data.add_note(:pass)
     end
 
-    # Call when an assertion has failed
+    # Call when an assertion has failed.
     def failed
-      Stats.failed
-      Messages.failed
+      print_now ?!
+      Data.add_note(:fail)
     end
 
-    # Call when an assertion has erred
+    # Call when an assertion has erred.
     def erred caught, expected = nil
-      Stats.erred
-      Messages.erred(caught, expected)
+      print_now ??
+      Data.add_note(:error, caught: caught, expected: expected)
     end
 
-    # Run a block as a test
+    # Run a block as a test.
     def run label:,
             truthy:  -> { },
             falsy:   -> { },
@@ -113,7 +114,7 @@ module Tet
             no_nest: false,
             test:
 
-      Messages.with_label(label) do
+      Data.with_label(label) do
         nesting_guard(no_nest) do
           begin
             test.call ? truthy.call : falsy.call
@@ -128,9 +129,15 @@ module Tet
       nil
     end
 
-    private
+  private
 
-    # Print out a report to stdout
+    # Print out a string immediately. Calling #print alone may have a delay.
+    def print_now string
+      print string
+      $stdout.flush
+    end
+
+    # Print out a report to stdout.
     def puts_report header, content
       unless content.empty?
         puts
@@ -139,6 +146,60 @@ module Tet
       end
     end
 
+    # Render a string with details about all of the test run.
+    def statistics_report
+      pass_count  = Data.count_type(:pass)
+      fail_count  = Data.count_type(:fail)
+      error_count = Data.count_type(:error)
+
+      output = []
+      output << "Errors: #{error_count}" unless error_count.zero?
+      output << "Failed: #{fail_count}"  unless fail_count.zero?
+      output << "Passed: #{pass_count}"  unless pass_count.zero?
+
+      output.join(?\n)
+    end
+
+    # Render a string with details about all of the failures encountered.
+    def failure_report
+      errors = Data.select_type(:error)
+
+      Data.select_type(:fail, :error)
+          .map do |node|
+            node.label
+                .tap do |label|
+                  if node.type == :error
+                    error_note  = "EXCEPTION_#{1 + errors.index(node)}"
+                    expected    = node.data[:expected]
+                    error_note << " (expected: #{expected}" if expected
+
+                    label << error_note
+                  end
+                end
+                .map(&:to_label_string)
+                .join('  ::  ')
+          end
+          .join(?\n)
+    end
+
+    # Render a string with details about all of the errors encountered.
+    def error_report
+      Data.select_type(:error)
+          .map.with_index do |node, index|
+            error    = node.data[:caught]
+            message  = error.to_s
+            message << " (#{error.class})" if message != error.class.to_s
+            summary  = "#{index + 1}. #{message}"
+
+            error.backtrace
+                 .reject { |line| line.start_with?(__FILE__) }
+                 .map    { |line| line.indent }
+                 .unshift(summary)
+                 .join(?\n)
+          end
+          .join("\n\n")
+    end
+
     # Check and set a flag to prevent test blocks from nesting
     def nesting_guard guard_state
       raise TestError, 'assertions can not be nested' if @nesting_banned
@@ -150,136 +211,93 @@ module Tet
   end
 
 
+  # Because tests are represented as series of nested groups containing
+  # assertions, the test data is stored in a tree.
+  module Tree
+    module Basics
+      include Enumerable
 
-  # Tracks and reports statistics about the tests that have run
-  module Stats
-    Counts = { passed: 0,  failed: 0,  erred: 0  }
-    Marks  = { passed: ?., failed: ?!, erred: ?? }
-
-    class << self
-      # Call when an assertion has passed
-      def passed
-        log :passed
-      end
-
-      # Call when an assertion has failed
-      def failed
-        log :failed
-      end
-
-      # Call when an assertion has erred
-      def erred
-        log :erred
+      # Create and append a new node to this node, returning the new node.
+      def append_node type, data
+        Node.new(type: type, data: data, parent: self)
+            .tap { |node| @children << node }
       end
 
-      # Returns true if no statistics have been logged
-      def empty?
-        Counts.values.inject(&:+).zero?
+      # Recursively iterate over each node in the test data tree in the order
+      # that they were added.
+      def each &block
+        @children.each do |node|
+          block.call(node)
+          node.each(&block)
+        end
       end
+    end
 
-      # Returns a string with statistics about the tests that have been run
-      def report
-        errors = Counts[:erred]
-        fails  = Counts[:failed]
-        passes = Counts[:passed]
-
-        output = []
-        output << "Errors: #{errors}" unless errors.zero?
-        output << "Failed: #{fails}"
-        output << "Passed: #{passes}"
+    # The root of the tree with methods to terminate Node methods which search
+    # up the tree, as well as methods for enumerating over the test data, adding
+    # labels and adding nodes.
+    class Root
+      include Basics
 
-        output.join(?\n)
+      def initialize
+        @children     = []
+        @current_node = self
       end
 
-      private
-
-      # Log an event and print a mark to show progress is being made on tests
-      def log type
-        Counts[type] += 1
-
-        print Marks[type]
-        $stdout.flush
+      # Terminate Node#label.
+      def label
+        []
       end
-    end
-  end
-
-
-  # Tracks and reports messages for each test
-  module Messages
-    Labels  = []
-    Results = []
-    Errors  = []
 
-    class << self
-      # Add a label to all subsequent messages
+      # Run a block where any notes added will be inside a new label node.
       def with_label label
-        Labels.push(label)
+        previous      = @current_node
+        @current_node = add_note(:label, label)
         yield
       ensure
-        Labels.pop
-      end
-
-      # Call when an assertion has failed
-      def failed
-        add_result!
+        @current_node = previous
+        self
       end
 
-      # Call when an assertion has passed
-      def erred caught, expected = nil
-        number = Stats::Counts[:erred]
-        label  = "EXCEPTION_#{number}"
-        label << " (expected: #{expected})" if expected
-
-        with_label(label) { add_result! }
-
-        Errors.push(error_message(caught, number))
+      # Add a node to note some data within the node that is currently active.
+      def add_note type, data = nil
+        @current_node.append_node(type, data)
       end
 
-      # Returns a string with details about all failed tests
-      def failure_report
-        Results.join(?\n)
+      # Get an array of all nodes of some type in the order they were added.
+      def select_type *types
+        select { |node| types.include?(node.type) }
       end
 
-      # Returns a string with details about all errors
-      def error_report
-        Errors.join("\n\n")
+      # Count the number of nodes of a given type.
+      def count_type type
+        select_type(type).size
       end
+    end
 
-      private
+    # A node to store data about that some point in the test tree
+    class Node
+      include Basics
+      attr_reader :data, :type
 
-      # Add a message for a new result using the current labels
-      def add_result!
-        Results.push(
-          Labels.map { |raw| raw.to_label }
-                .reject(&:empty?)
-                .join('  ::  ')
-        )
+      def initialize parent:, type:, data: nil
+        @type     = type
+        @data     = data
+        @parent   = parent
+        @children = []
       end
 
-      def format_label label
-        case label
-        when Module
-          label.name
-        when String
-          label.to_s
+      # Generate the array of labels that identify this point in the tree.
+      def label
+        if @type == :label
+          @parent.label + [@data]
         else
-          label.inspect
+          @parent.label
         end
       end
-
-      # Format an error into a message string
-      def error_message error, number
-        error_message  = error.to_s
-        error_class    = error.class.to_s
-        error_message << " (#{error.class})" if error_message != error_class
-
-        summary  = "#{number}. #{error_message}"
-        details  = error.backtrace
-                        .reject { |line| line.start_with?(__FILE__) }
-                        .map    { |line| line.indent }
-
-        details.unshift(summary).join(?\n)
-      end
     end
   end
+
+  # The instance of the Tree data structure that stores all of the test results.
+  Data = Tree::Root.new
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tet
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Colin Fulton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-08 00:00:00.000000000 Z
+date: 2017-03-10 00:00:00.000000000 Z
 dependencies: []
 description: A very minimal test framework designed for simple projects. A couple
   of features, relatively nice looking output, and nothing else. Does the world need