test_bench-output 2.0.0.0

data/lib/test_bench/output/output.rb

@@ -0,0 +1,335 @@
+module TestBench
+  class Output
+    include Session::Handler
+
+    def pending_writer
+      @pending_writer ||= Writer::Substitute.build
+    end
+    attr_writer :pending_writer
+
+    def passing_writer
+      @passing_writer ||= Writer::Substitute.build
+    end
+    attr_writer :passing_writer
+
+    def failing_writer
+      @failing_writer ||= Writer::Substitute.build
+    end
+    attr_writer :failing_writer
+
+    def failures
+      @failures ||= []
+    end
+    attr_writer :failures
+
+    def mode
+      @mode ||= Mode.initial
+    end
+    attr_writer :mode
+
+    def failures
+      @failures ||= []
+    end
+    attr_writer :failures
+
+    def branch_count
+      @branch_count ||= 0
+    end
+    attr_writer :branch_count
+
+    def detail_policy
+      @detail_policy ||= Detail.default
+    end
+    alias :detail :detail_policy
+    attr_writer :detail_policy
+
+    def self.build(device: nil, styling: nil, detail: nil)
+      instance = new
+
+      Writer.configure(instance, device:, styling:, attr_name: :pending_writer)
+
+      if not detail.nil?
+        instance.detail_policy = detail
+      end
+
+      instance
+    end
+
+    def self.register(telemetry, **arguments)
+      instance = build(**arguments)
+
+      telemetry.register(instance)
+      instance
+    end
+
+    def receive(event)
+      case event
+      when ContextStarted, TestStarted
+        branch
+      end
+
+      if initial?
+        handle(event)
+
+      else
+        self.mode = Mode.failing
+        handle(event)
+
+        self.mode = Mode.passing
+        handle(event)
+
+        self.mode = Mode.pending
+        handle(event)
+      end
+
+      case event
+      when ContextFinished, TestFinished
+        merge(event.result)
+      end
+    end
+
+    handle Detailed do |text, quote, heading|
+      if not detail?
+        return
+      end
+
+      comment(text, quote, heading)
+    end
+
+    handle Commented do |text, quote, heading|
+      comment(text, quote, heading)
+    end
+
+    handle ContextStarted do |title|
+      if not title.nil?
+        writer.
+          indent.
+          style(:green).
+          puts(title)
+
+        writer.indent!
+
+        if branch_count == 1
+          failures.clear
+        end
+      end
+    end
+
+    handle ContextFinished do |title|
+      if not title.nil?
+        writer.deindent!
+
+        if branch_count == 1
+          writer.puts
+
+          if failing? && failures.any?
+            writer.
+              style(:bold, :red).
+              puts("Failure#{'s' if not failures.one?}:")
+
+            failures.each do |failure_message|
+              writer.
+                print('- ').
+                style(:red).
+                puts(failure_message)
+            end
+
+            writer.puts
+          end
+        end
+      end
+    end
+
+    handle TestStarted do |title|
+      if title.nil?
+        if passing?
+          return
+        else
+          title = 'Test'
+        end
+      end
+
+      writer.indent
+
+      if passing?
+        writer.style(:green)
+      elsif failing?
+        if not writer.styling?
+          title = "#{title} (failed)"
+        end
+
+        writer.style(:bold, :red)
+      elsif pending?
+        writer.style(:faint)
+      end
+
+      writer.puts(title)
+
+      writer.indent!
+    end
+
+    handle TestFinished do |title, result|
+      if passing? && title.nil?
+        return
+      end
+
+      writer.deindent!
+    end
+
+    handle Failed do |message|
+      if failing?
+        failures << message
+      end
+
+      writer
+        .indent
+        .style(:red)
+        .puts(message)
+    end
+
+    def comment(text, quote, heading)
+      if not heading.nil?
+        writer.style(:bold, :underline).puts(heading)
+      end
+
+      if text.empty?
+        writer.
+          indent.
+          style(:faint, :italic).
+          puts('(empty)')
+        return
+      end
+
+      if not quote
+        writer.puts(text)
+      else
+        text.each_line do |line|
+          line.chomp!
+
+          writer.
+            indent.
+            style(:faint).
+            print('> ').
+            style(:reset_intensity).
+            puts(line)
+        end
+      end
+    end
+
+    def current_writer
+      if initial? || pending?
+        pending_writer
+      elsif passing?
+        passing_writer
+      elsif failing?
+        failing_writer
+      end
+    end
+    alias :writer :current_writer
+
+    def branch
+      if branch_count.zero?
+        self.mode = Mode.pending
+
+        pending_writer.sync = false
+
+        parent_writer = pending_writer
+      else
+        parent_writer = passing_writer
+      end
+
+      self.branch_count += 1
+
+      self.passing_writer, self.failing_writer = parent_writer.branch
+    end
+
+    def merge(result)
+      self.branch_count -= 1
+
+      if not branched?
+        pending_writer.sync = true
+
+        self.mode = Mode.initial
+      end
+
+      if result
+        writer = passing_writer
+      else
+        writer = failing_writer
+      end
+
+      writer.flush
+
+      self.passing_writer = writer.device
+      self.failing_writer = writer.alternate_device
+    end
+
+    def branched?
+      branch_count > 0
+    end
+
+    def initial?
+      mode == Mode.initial
+    end
+
+    def pending?
+      mode == Mode.pending
+    end
+
+    def passing?
+      mode == Mode.passing
+    end
+
+    def failing?
+      mode == Mode.failing
+    end
+
+    def detail?
+      Detail.detail?(detail_policy, mode)
+    end
+
+    module Mode
+      def self.initial = :initial
+      def self.pending = :pending
+      def self.passing = :passing
+      def self.failing = :failing
+    end
+
+    module Detail
+      Error = Class.new(RuntimeError)
+
+      def self.detail?(policy, mode)
+        case policy
+        when on
+          true
+        when off
+          false
+        when failure
+          if mode == Mode.failing || mode == Mode.initial
+            true
+          else
+            false
+          end
+        else
+          raise Error, "Unknown detail policy #{policy.inspect}"
+        end
+      end
+
+      def self.on = :on
+      def self.off = :off
+      def self.failure = :failure
+
+      def self.default
+        policy = ENV.fetch('TEST_BENCH_DETAIL') do
+          return default!
+        end
+
+        policy.to_sym
+      end
+
+      def self.default!
+        :failure
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+module TestBench
+  class Output
+    class Writer
+      class Buffer
+        class Console
+          def device
+            @device ||= Device::Null.build
+          end
+          attr_writer :device
+
+          def geometry
+            @geometry ||= Geometry.get
+          end
+          attr_writer :geometry
+
+          def cursor_saved
+            @cursor_saved ||= false
+          end
+          alias :cursor_saved? :cursor_saved
+          attr_writer :cursor_saved
+
+          def self.build(device=nil)
+            device ||= Defaults.device
+
+            instance = new
+
+            if device.tty?
+              instance.device = device
+            end
+
+            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 set_geometry(width, height, row, column)
+            geometry = Geometry.new(width, height, row, column)
+            self.geometry = geometry
+          end
+
+          def receive(text)
+            if not cursor_saved?
+              device.write("\e[s")
+              self.cursor_saved = true
+            end
+
+            write_ahead_text = geometry.next(text)
+
+            if not write_ahead_text.empty?
+              device.write(write_ahead_text)
+            elsif geometry.bottom_row?
+              buffering_message = "Output is buffering"
+
+              device.write("\e[2m#{buffering_message}\e[22m")
+              geometry.next!(buffering_message)
+            end
+
+            device.flush
+
+            write_ahead_text.length
+          end
+
+          def flush(...)
+            if cursor_saved?
+              device.write("\e[u")
+              self.cursor_saved = false
+            end
+          end
+
+          def capacity
+            geometry.capacity
+          end
+
+          def next_position(text)
+            geometry.next_position(text)
+          end
+
+          Geometry = Struct.new(:width, :height, :row, :column) do
+            def self.get
+              instance = new
+
+              STDIN.raw do |stdin|
+                instance.height, instance.width = stdin.winsize
+
+                instance.row, instance.column = stdin.cursor
+              end
+
+              instance
+            end
+
+            def bottom_row?
+              row + 1 == height && column == 0
+            end
+
+            def next(text)
+              write_ahead_text = text.slice!(0, capacity)
+
+              next!(write_ahead_text)
+
+              write_ahead_text
+            end
+
+            def next!(text)
+              escape_sequence_pattern = %r{\A\e\[[[:digit:]]+(?:;[[:digit:]]+)*[[:alpha:]]$}
+              if escape_sequence_pattern.match?(text)
+                return
+              end
+
+              row, column, _scroll_rows = next_position(text)
+
+              self.row = row
+              self.column = column
+            end
+
+            def capacity
+              capacity = 0
+
+              rows_remaining = height - row - 1
+
+              if rows_remaining > 0
+                capacity += (rows_remaining - 1) * width
+
+                final_row = width - column
+                capacity += final_row
+              end
+
+              capacity
+            end
+
+            def next_position(text)
+              text_length = text.length
+
+              newline = text.end_with?("\n")
+              if newline
+                text_length -= 1
+              end
+
+              row = self.row
+              column = self.column
+
+              text_rows, text_columns = text_length.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 newline
+                reached_next_line = column == 0 && row > self.row
+
+                newline_needed = !reached_next_line
+                if newline_needed
+                  row += 1
+                  column = 0
+                end
+              end
+
+              if row >= height
+                row_limit = height - 1
+
+                scroll_rows = row - row_limit
+                row = row_limit
+              else
+                scroll_rows = 0
+              end
+
+              return row, column, scroll_rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module TestBench
+  class Output
+    class Writer
+      class Buffer
+        attr_accessor :limit
+
+        def contents
+          @contents ||= String.new
+        end
+        attr_writer :contents
+
+        def receive(data)
+          bytes = data.bytesize
+
+          if not limit.nil?
+            final_size = contents.bytesize + data.bytesize
+
+            if final_size > limit
+              bytes = limit - contents.bytesize
+            end
+          end
+
+          data = data[0...bytes]
+
+          contents << data
+
+          bytes
+        end
+
+        def limit?
+          !limit.nil?
+        end
+
+        def flush(device=nil, alternate_device=nil)
+          if not device.nil?
+            device.write(contents)
+          end
+
+          if not alternate_device.nil?
+            alternate_device.write(contents)
+          end
+
+          contents.clear
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module TestBench
+  class Output
+    class Writer
+      module Defaults
+        def self.device
+          STDOUT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module TestBench
+  class Output
+    class Writer
+      module Style
+        Error = Class.new(RuntimeError)
+
+        def self.control_code(style)
+          control_codes.fetch(style) do
+            raise Error, "Invalid style #{style.inspect}"
+          end
+        end
+
+        def self.control_codes
+          @sgr_codes ||= {
+            :reset => '0',
+
+            :bold => '1',
+            :faint => '2',
+            :italic => '3',
+            :underline => '4',
+
+            :reset_intensity => '22',
+            :reset_italic => '23',
+            :reset_underline => '24',
+
+            :black => '30',
+            :red => '31',
+            :green => '32',
+            :yellow => '33',
+            :blue => '34',
+            :magenta => '35',
+            :cyan => '36',
+            :white => '37',
+            :reset_fg => '39',
+
+            :black_bg => '40',
+            :red_bg => '41',
+            :green_bg => '42',
+            :yellow_bg => '43',
+            :blue_bg => '44',
+            :magenta_bg => '45',
+            :cyan_bg => '46',
+            :white_bg => '47',
+            :reset_bg => '49'
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module TestBench
+  class Output
+    class Writer
+      module Substitute
+        def self.build
+          Writer.build
+        end
+
+        class Writer < Writer
+          def written_data
+            device.written_data
+          end
+          alias :written_text :written_data
+
+          def self.build
+            instance = new
+            instance.buffer.limit = 0
+            instance
+          end
+
+          def styling!
+            self.styling_policy = Styling.on
+          end
+        end
+      end
+    end
+  end
+end