test_bench-session 2.0.0.0 → 2.1.0.0

data/lib/test_bench/session/controls/title.rb

@@ -2,24 +2,36 @@ module TestBench
   class Session
     module Controls
       module Title
-        module Test
-          def self.example(suffix=nil)
-            suffix = " #{suffix}" if not suffix.nil?
+        module Context
+          def self.example
+            "Some Context"
+          end
+
+          def self.other_example
+            "Some Other Context"
+          end
+
+          def self.random
+            suffix = Random.string
 
-            "Some test#{suffix}"
+            "#{example} #{suffix}"
           end
-          def self.other_example = "Some other test"
-          def self.random = example(Random.string)
         end
 
-        module Context
-          def self.example(suffix=nil)
-            suffix = " #{suffix}" if not suffix.nil?
+        module Test
+          def self.example
+            "Some test"
+          end
+
+          def self.other_example
+            "Some other test"
+          end
+
+          def self.random
+            suffix = Random.string
 
-            "Some Context#{suffix}"
+            "#{example} #{suffix}"
           end
-          def self.other_example = "Some Other Context"
-          def self.random = example(Random.string)
         end
       end
     end

data/lib/test_bench/session/controls.rb

@@ -1,4 +1,5 @@
 require 'test_bench/telemetry/controls'
+require 'test_bench/output/controls'
 
 require 'test_bench/session/controls/random'
 require 'test_bench/session/controls/time'
@@ -8,29 +9,28 @@ require 'test_bench/session/controls/exception'
 
 require 'test_bench/session/controls/failure'
 require 'test_bench/session/controls/title'
+require 'test_bench/session/controls/exception'
 require 'test_bench/session/controls/comment'
 require 'test_bench/session/controls/detail'
 require 'test_bench/session/controls/fixture'
-require 'test_bench/session/controls/file'
 
+require 'test_bench/session/controls/events/event_data'
 require 'test_bench/session/controls/events/failed'
-require 'test_bench/session/controls/events/test_started'
-require 'test_bench/session/controls/events/test_finished'
-require 'test_bench/session/controls/events/test_skipped'
 require 'test_bench/session/controls/events/context_started'
 require 'test_bench/session/controls/events/context_finished'
 require 'test_bench/session/controls/events/context_skipped'
+require 'test_bench/session/controls/events/test_started'
+require 'test_bench/session/controls/events/test_finished'
+require 'test_bench/session/controls/events/test_skipped'
 require 'test_bench/session/controls/events/commented'
 require 'test_bench/session/controls/events/detailed'
 require 'test_bench/session/controls/events/fixture_started'
 require 'test_bench/session/controls/events/fixture_finished'
-require 'test_bench/session/controls/events/file_started'
-require 'test_bench/session/controls/events/file_finished'
-require 'test_bench/session/controls/events/started'
-require 'test_bench/session/controls/events/aborted'
-require 'test_bench/session/controls/events/finished'
 require 'test_bench/session/controls/events'
 
-require 'test_bench/session/controls/capture_sink/path'
-require 'test_bench/session/controls/capture_sink/event'
-require 'test_bench/session/controls/capture_sink/record'
+require 'test_bench/session/controls/substitute/path'
+
+require 'test_bench/session/controls/event'
+
+require 'test_bench/session/controls/output'
+require 'test_bench/session/controls/output/detail'

data/lib/test_bench/session/events.rb

@@ -5,28 +5,21 @@ module TestBench
         constants(false).each(&block)
       end
 
-      Failed = TestBench::Telemetry::Event.define(:message, :path, :line_number)
-
-      TestStarted = TestBench::Telemetry::Event.define(:title)
-      TestFinished = TestBench::Telemetry::Event.define(:title, :result)
-      TestSkipped = TestBench::Telemetry::Event.define(:title)
+      Failed = TestBench::Telemetry::Event.define(:message)
 
       ContextStarted = TestBench::Telemetry::Event.define(:title)
       ContextFinished = TestBench::Telemetry::Event.define(:title, :result)
       ContextSkipped = TestBench::Telemetry::Event.define(:title)
 
-      Commented = TestBench::Telemetry::Event.define(:text)
-      Detailed = TestBench::Telemetry::Event.define(:text)
+      TestStarted = TestBench::Telemetry::Event.define(:title)
+      TestFinished = TestBench::Telemetry::Event.define(:title, :result)
+      TestSkipped = TestBench::Telemetry::Event.define(:title)
+
+      Commented = TestBench::Telemetry::Event.define(:text, :quote, :heading)
+      Detailed = TestBench::Telemetry::Event.define(:text, :quote, :heading)
 
       FixtureStarted = TestBench::Telemetry::Event.define(:name)
       FixtureFinished = TestBench::Telemetry::Event.define(:name, :result)
-
-      FileStarted = TestBench::Telemetry::Event.define(:path)
-      FileFinished = TestBench::Telemetry::Event.define(:path, :result)
-
-      Started = TestBench::Telemetry::Event.define(:process_count)
-      Aborted = TestBench::Telemetry::Event.define(:abort_process_id)
-      Finished = TestBench::Telemetry::Event.define(:result, :process_count)
     end
   end
 end

data/lib/test_bench/session/output/get.rb

@@ -0,0 +1,27 @@
+module TestBench
+  class Session
+    class Output
+      module Get
+        def self.call(substitute_session, styling: nil)
+          styling = true if styling.nil?
+
+          session_sink = substitute_session.sink
+
+          output = Output.new
+
+          if styling
+            output.writer.styling!
+          end
+
+          session_sink.records.each do |record|
+            event_data = record.event_data
+
+            output.receive(event_data)
+          end
+
+          output.writer.written_text
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/output/writer/buffer/interactive/viewport.rb

@@ -0,0 +1,164 @@
+module TestBench
+  class Session
+    class Output
+      class Writer
+        module Buffer
+          class Interactive
+            Viewport = Struct.new(:width, :height, :row, :column, :scroll_rows, :rows_scrolled) do
+              def self.build(width, height, row, column, scroll_rows=nil)
+                scroll_rows ||= 0
+
+                rows_scrolled = 0
+
+                new(width, height, row, column, scroll_rows, rows_scrolled)
+              end
+
+              def self.null
+                build(0, 0, 0, 0)
+              end
+
+              def self.get
+                width, height, row, column = nil
+
+                STDIN.raw do |stdin|
+                  height, width = stdin.winsize
+
+                  row, column = stdin.cursor
+                end
+
+                scroll_rows = row
+
+                build(width, height, row, column, scroll_rows)
+              end
+
+              def write(text)
+                bytes_written = 0
+
+                escape_sequence_pattern = self.class.escape_sequence_pattern
+
+                until text.empty?
+                  write_text, escape_sequence, text = text.partition(escape_sequence_pattern)
+
+                  bytes_written += write!(write_text)
+                  bytes_written += escape_sequence.bytesize
+                end
+
+                bytes_written
+              end
+
+              def write!(text)
+                newline = text.end_with?("\n")
+
+                if newline
+                  text = text[0...-1]
+                end
+
+                bytes_written = write_text(text)
+
+                if newline
+                  bytes_written += write_newline
+                end
+
+                bytes_written
+              end
+
+              def write_text(text)
+                if text.start_with?("\e")
+                  return text.bytesize
+                end
+
+                written_text = text[0...capacity]
+
+                bytes_written = written_text.bytesize
+
+                row = self.row
+                column = self.column
+
+                text_rows, text_columns = bytes_written.divmod(width)
+
+                row += text_rows
+
+                columns_remaining = width - column
+                if columns_remaining > text_columns
+                  column += text_columns
+                else
+                  row += 1
+                  column = text_columns - columns_remaining
+                end
+
+                if row >= height
+                  final_row = height - 1
+
+                  scroll_rows = row - final_row
+                  self.rows_scrolled += scroll_rows
+
+                  row = final_row
+                end
+
+                self.row = row
+                self.column = column
+
+                bytes_written
+              end
+
+              def write_newline
+                if bottom_row?
+                  if scroll_rows_remaining.zero?
+                    return 0
+                  end
+
+                  self.rows_scrolled += 1
+                else
+                  self.row += 1
+                end
+
+                self.column = 0
+
+                1
+              end
+
+              def capacity?
+                if scroll_rows_remaining > 0
+                  true
+                else
+                  not bottom_row?
+                end
+              end
+
+              def capacity
+                capacity = 0
+
+                rows_remaining = height + scroll_rows_remaining - row - 1
+
+                if rows_remaining > 0
+                  capacity += (rows_remaining - 1) * width
+
+                  final_row = width - column
+                  capacity += final_row
+                end
+
+                capacity
+              end
+
+              def scroll_rows_remaining
+                scroll_rows - rows_scrolled
+              end
+
+              def bottom_row?
+                row == height - 1
+              end
+
+              def self.escape_sequence_pattern
+                initiator = %r{\e\[}
+                terminator = %r{[[:alpha:]]}
+                sequence = %r{[[:digit:]]+(?:;[[:digit:]]+)*}
+
+                %r{#{initiator}#{sequence}?#{terminator}}
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/output/writer/buffer/interactive.rb

@@ -0,0 +1,139 @@
+module TestBench
+  class Session
+    class Output
+      class Writer
+        module Buffer
+          class Interactive
+            attr_accessor :viewport
+
+            attr_accessor :raw_stderr
+
+            attr_accessor :stderr_pipe
+
+            def stderr_buffer
+              @stderr_buffer ||= String.new
+            end
+
+            def device
+              @device ||= TestBench::Output::Device::Substitute.build
+            end
+            attr_writer :device
+
+            attr_accessor :buffering
+            def buffering? = !!buffering
+
+            def self.build(device=nil)
+              device ||= Defaults.device
+
+              instance = new
+              instance.device = device
+              instance
+            end
+
+            def self.configure(receiver, device: nil, attr_name: nil)
+              attr_name ||= :buffer
+
+              instance = build(device)
+              receiver.public_send(:"#{attr_name}=", instance)
+            end
+
+            def receive(text)
+              if not cursor_saved?
+                save_cursor
+              end
+
+              bytes_written = viewport.write(text)
+
+              write_text = text.byteslice(0, bytes_written)
+              device.write(write_text)
+
+              if not viewport.capacity?
+                if not buffering?
+                  buffering_message = "Output is buffering"
+
+                  device.write("\e[0G\e[2m#{buffering_message}\e[22m")
+
+                  self.buffering = true
+                end
+              end
+
+              update_stderr_buffer
+
+              bytes_written
+            end
+
+            def flush(*_devices)
+              if cursor_saved?
+                update_stderr_buffer
+                restore_cursor
+              end
+            end
+
+            def save_cursor
+              self.viewport = Viewport.get
+
+              self.raw_stderr = STDERR.dup
+
+              reader, writer = IO.pipe
+
+              new_stderr = writer
+              STDERR.reopen(new_stderr)
+
+              stderr_buffer.clear
+
+              self.stderr_pipe = reader
+
+              device.write("\e[s")
+            end
+
+            def restore_cursor
+              stderr_pipe.close
+
+              device.write("\e[u")
+
+              rows_scrolled = viewport.rows_scrolled
+
+              if not rows_scrolled.zero?
+                upward_movements = rows_scrolled
+                device.write("\e[#{upward_movements}F")
+              end
+
+              stderr_buffer.each_line do |line|
+                raw_stderr.write("\e[0K")
+                raw_stderr.write(line)
+              end
+
+              STDERR.reopen(raw_stderr)
+              self.raw_stderr = nil
+
+              self.viewport = nil
+            end
+
+            def update_stderr_buffer
+              loop do
+                stderr_text = stderr_pipe.read_nonblock(4096, exception: false)
+
+                if stderr_text == :wait_readable
+                  break
+                end
+
+                viewport.write(stderr_text)
+
+                if not buffering?
+                  raw_stderr.write(stderr_text)
+                end
+
+                self.stderr_buffer << stderr_text
+              end
+            end
+
+            def viewport?
+              !viewport.nil?
+            end
+            alias :cursor_saved? :viewport?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/output/writer/buffer.rb

@@ -0,0 +1,27 @@
+module TestBench
+  class Session
+    class Output
+      class Writer
+        module Buffer
+          def self.configure(receiver, device: nil, experimental_output: nil, attr_name: nil)
+            device ||= Defaults.device
+            experimental_output ||= Defaults.experimental_output
+            attr_name ||= :buffer
+
+            if experimental_output
+              interactive = device.tty?
+            else
+              interactive = false
+            end
+
+            if interactive
+              Buffer::Interactive.configure(receiver, device:, attr_name:)
+            else
+              TestBench::Output::Writer::Buffer.configure(receiver, attr_name:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/output/writer/defaults.rb

@@ -0,0 +1,17 @@
+module TestBench
+  class Session
+    class Output
+      class Writer
+        module Defaults
+          def self.device
+            TestBench::Output::Writer::Defaults.device
+          end
+
+          def self.experimental_output
+            ENV.fetch('TEST_BENCH_EXPERIMENTAL_OUTPUT', 'off') == 'on'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/output/writer/substitute.rb

@@ -0,0 +1,17 @@
+module TestBench
+  class Session
+    class Output
+      class Writer
+        module Substitute
+          def self.build
+            Writer.build
+          end
+
+          class Writer < Writer
+            include TestBench::Output::Writer::Substitute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/session/output/writer.rb

@@ -0,0 +1,95 @@
+module TestBench
+  class Session
+    class Output
+      class Writer < TestBench::Output::Writer
+        attr_accessor :peer
+
+        def alternate_device
+          @alternate_device ||= TestBench::Output::Device::Substitute.build
+        end
+        attr_writer :alternate_device
+
+        def indentation_depth
+          @indentation_depth ||= 0
+        end
+        attr_writer :indentation_depth
+
+        def configure
+          device = self.device
+
+          self.alternate_device = TestBench::Output::Device::Null.build
+
+          Buffer.configure(self, device:)
+        end
+
+        def self.follow(previous_writer)
+          device = previous_writer
+
+          alternate_device = previous_writer.peer
+          alternate_device ||= TestBench::Output::Device::Null.build
+
+          previous_digest = previous_writer.digest
+          digest = previous_digest.clone
+
+          writer = new
+          writer.sync = false
+          writer.device = device
+          writer.alternate_device = alternate_device
+          writer.styling_policy = previous_writer.styling_policy
+          writer.digest = digest
+          writer.sequence = previous_writer.sequence
+          writer.column_sequence = previous_writer.column_sequence
+          writer.indentation_depth = previous_writer.indentation_depth
+          writer.digest = previous_writer.digest.clone
+          writer
+        end
+
+        def branch
+          alternate = self.class.follow(self)
+          primary = self.class.follow(self)
+
+          primary.peer = alternate
+
+          return primary, alternate
+        end
+
+        def indent
+          indentation = '  ' * indentation_depth
+
+          print(indentation)
+        end
+
+        def flush
+          buffer.flush(device, alternate_device)
+        end
+
+        def write!(data)
+          device.write(data)
+          alternate_device.write(data)
+        end
+
+        def increase_indentation
+          self.indentation_depth += 1
+        end
+        alias :indent! :increase_indentation
+
+        def decrease_indentation
+          self.indentation_depth -= 1
+        end
+        alias :deindent! :decrease_indentation
+
+        def follows?(other_writer)
+          if sequence < other_writer.sequence
+            false
+          elsif device == other_writer
+            true
+          elsif device == other_writer.peer
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end