test_bench-isolated 0 → 2.0.0.1

data/lib/test_bench_isolated/test_bench/session/controls/result.rb

@@ -0,0 +1,25 @@
+module TestBenchIsolated
+  module TestBench
+    class Session
+      module Controls
+        module Result
+          def self.example
+            pass
+          end
+  
+          def self.pass
+            true
+          end
+  
+          def self.failure
+            false
+          end
+  
+          def self.random
+            Random.boolean
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/session/controls/substitute/path.rb

@@ -0,0 +1,35 @@
+module TestBenchIsolated
+  module TestBench
+    class Session
+      module Controls
+        module Substitute
+          module Path
+            def self.example(segments=nil)
+              segments ||= Segment.examples
+  
+              segments = segments.dup
+  
+              path = TestBench::Session::Substitute::Path.new
+              path.segments = segments
+              path
+            end
+  
+            module Segment
+              def self.examples
+                [example, Context.other_example, Test.example]
+              end
+  
+              def self.example
+                Context.example
+              end
+  
+              Test = Title::Test
+  
+              Context = Title::Context
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/session/controls/time.rb

@@ -0,0 +1,9 @@
+module TestBenchIsolated
+  module TestBench
+    class Session
+      module Controls
+        Time = TestBench::Telemetry::Controls::Time
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module TestBenchIsolated
+  module TestBench
+    class Session
+      module Controls
+        module Title
+          module Context
+            def self.example
+              "Some Context"
+            end
+  
+            def self.other_example
+              "Some Other Context"
+            end
+  
+            def self.random
+              suffix = Random.string
+  
+              "#{example} #{suffix}"
+            end
+          end
+  
+          module Test
+            def self.example
+              "Some test"
+            end
+  
+            def self.other_example
+              "Some other test"
+            end
+  
+            def self.random
+              suffix = Random.string
+  
+              "#{example} #{suffix}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'test_bench_isolated/test_bench/telemetry/controls'
+require 'test_bench_isolated/test_bench/output/controls'
+
+require 'test_bench_isolated/test_bench/session/controls/random'
+require 'test_bench_isolated/test_bench/session/controls/time'
+require 'test_bench_isolated/test_bench/session/controls/process_id'
+require 'test_bench_isolated/test_bench/session/controls/result'
+require 'test_bench_isolated/test_bench/session/controls/exception'
+
+require 'test_bench_isolated/test_bench/session/controls/failure'
+require 'test_bench_isolated/test_bench/session/controls/title'
+require 'test_bench_isolated/test_bench/session/controls/exception'
+require 'test_bench_isolated/test_bench/session/controls/comment'
+require 'test_bench_isolated/test_bench/session/controls/detail'
+require 'test_bench_isolated/test_bench/session/controls/fixture'
+
+require 'test_bench_isolated/test_bench/session/controls/events/event_data'
+require 'test_bench_isolated/test_bench/session/controls/events/failed'
+require 'test_bench_isolated/test_bench/session/controls/events/context_started'
+require 'test_bench_isolated/test_bench/session/controls/events/context_finished'
+require 'test_bench_isolated/test_bench/session/controls/events/context_skipped'
+require 'test_bench_isolated/test_bench/session/controls/events/test_started'
+require 'test_bench_isolated/test_bench/session/controls/events/test_finished'
+require 'test_bench_isolated/test_bench/session/controls/events/test_skipped'
+require 'test_bench_isolated/test_bench/session/controls/events/commented'
+require 'test_bench_isolated/test_bench/session/controls/events/detailed'
+require 'test_bench_isolated/test_bench/session/controls/events/fixture_started'
+require 'test_bench_isolated/test_bench/session/controls/events/fixture_finished'
+require 'test_bench_isolated/test_bench/session/controls/events'
+
+require 'test_bench_isolated/test_bench/session/controls/substitute/path'
+
+require 'test_bench_isolated/test_bench/session/controls/event'
+
+require 'test_bench_isolated/test_bench/session/controls/output'
+require 'test_bench_isolated/test_bench/session/controls/output/detail'

data/lib/test_bench_isolated/test_bench/session/events.rb

@@ -0,0 +1,27 @@
+module TestBenchIsolated
+  module TestBench
+    class Session
+      module Events
+        def self.each_type(&block)
+          constants(false).each(&block)
+        end
+  
+        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)
+  
+        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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module TestBenchIsolated
+  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
+end

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

@@ -0,0 +1,167 @@
+module TestBenchIsolated
+  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
+  
+                  Kernel.require 'io/console'
+                  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
+end

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

@@ -0,0 +1,141 @@
+module TestBenchIsolated
+  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
+end

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

@@ -0,0 +1,29 @@
+module TestBenchIsolated
+  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
+end

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

@@ -0,0 +1,19 @@
+module TestBenchIsolated
+  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
+end

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

@@ -0,0 +1,19 @@
+module TestBenchIsolated
+  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
+end

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

@@ -0,0 +1,97 @@
+module TestBenchIsolated
+  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
+end