test_bench-session 2.1.3.2 → 3.0.0.0.pre.2

data/lib/test_bench/session/controls/events/fixture_finished.rb

@@ -1,53 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Events
-        module FixtureFinished
-          extend EventData
-
-          def self.example(name: nil, result: nil, process_id: nil, time: nil)
-            name ||= self.name
-            result = self.result if result.nil?
-            process_id ||= self.process_id
-            time ||= self.time
-
-            Session::Events::FixtureFinished.build(name, result, process_id:, time:)
-          end
-
-          def self.random
-            Random.example
-          end
-
-          def self.name
-            Fixture::Name.example
-          end
-
-          def self.result
-            Result.example
-          end
-
-          def self.process_id
-            ProcessID.example
-          end
-
-          def self.time
-            Time.example
-          end
-
-          module Random
-            extend EventData
-
-            def self.example(name: nil, result: nil, process_id: nil, time: nil)
-              name ||= Fixture::Name.random
-              result = Result.random if result.nil?
-              process_id ||= ProcessID.random
-              time ||= Time.random
-
-              FixtureFinished.example(name:, result:, process_id:, time:)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/session/controls/events/fixture_started.rb

@@ -1,47 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Events
-        module FixtureStarted
-          extend EventData
-
-          def self.example(name: nil, process_id: nil, time: nil)
-            name ||= self.name
-            process_id ||= self.process_id
-            time ||= self.time
-
-            Session::Events::FixtureStarted.build(name, process_id:, time:)
-          end
-
-          def self.random
-            Random.example
-          end
-
-          def self.name
-            Fixture::Name.example
-          end
-
-          def self.process_id
-            ProcessID.example
-          end
-
-          def self.time
-            Time.example
-          end
-
-          module Random
-            extend EventData
-
-            def self.example(name: nil, process_id: nil, time: nil)
-              name ||= Fixture::Name.random
-              process_id ||= ProcessID.random
-              time ||= Time.random
-
-              FixtureStarted.example(name:, process_id:, time:)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/session/controls/events/test_skipped.rb

@@ -1,47 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Events
-        module TestSkipped
-          extend EventData
-
-          def self.example(title: nil, process_id: nil, time: nil)
-            title ||= self.title
-            process_id ||= self.process_id
-            time ||= self.time
-
-            Session::Events::TestSkipped.build(title, process_id:, time:)
-          end
-
-          def self.random
-            Random.example
-          end
-
-          def self.title
-            Title::Test.example
-          end
-
-          def self.process_id
-            ProcessID.example
-          end
-
-          def self.time
-            Time.example
-          end
-
-          module Random
-            extend EventData
-
-            def self.example(title: nil, process_id: nil, time: nil)
-              process_id ||= ProcessID.random
-              time ||= Time.random
-              title ||= Title::Test.random
-
-              TestSkipped.example(title:, process_id:, time:)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Failure
-        module Message
-          def self.example
-            "Some failure message"
-          end
-
-          def self.random
-            suffix = Random.string
-
-            "#{example} #{suffix}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Fixture
-        module Name
-          def self.example
-            "SomeNamespace::SomeFixture"
-          end
-
-          def self.random
-            suffix = Random.string
-
-            "#{example}_#{suffix}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/session/controls/output/detail.rb

@@ -1,29 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Output
-        module Detail
-          def self.example
-            Session::Output::Detail.on
-          end
-
-          def self.other_example
-            Session::Output::Detail.off
-          end
-
-          def self.random
-            details = [
-              Session::Output::Detail.on,
-              Session::Output::Detail.off,
-              Session::Output::Detail.failure
-            ]
-
-            index = Random.integer % details.count
-
-            details[index]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      module Output
-        Device = TestBench::Output::Controls::Device
-        Data = TestBench::Output::Controls::Data
-        Styling = TestBench::Output::Controls::Styling
-        Style = TestBench::Output::Controls::Style
-        Text = TestBench::Output::Controls::Text
-
-        def self.example(details: nil, styling: nil, mode: nil)
-          styling ||= false
-
-          output = Session::Output.new
-
-          if details == true
-            output.detail_policy = Session::Output::Detail.on
-          elsif details == false
-            output.detail_policy = Session::Output::Detail.off
-          else
-            output.detail_policy = Session::Output::Detail.failure
-          end
-
-          if styling
-            output.writer.styling!
-          end
-
-          if not mode.nil?
-            output.mode = mode
-          end
-
-          output
-        end
-
-        module Styling
-          def self.example
-            Output.example(styling:)
-          end
-
-          def self.styling
-            true
-          end
-        end
-
-        module Pending
-          def self.example
-            output = Styling.example
-            output.pending_writer.buffer.limit = nil
-            output
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-module TestBench
-  class Session
-    module Controls
-      ProcessID = TestBench::Telemetry::Controls::ProcessID
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-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

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

@@ -1,27 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

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

@@ -1,139 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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