ruby_jard 0.1.0 → 0.2.0

data/lib/ruby_jard/row.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Row
+    extend Forwardable
+
+    attr_accessor :row_template, :columns
+
+    def_delegators :@row_template, :line_limit
+
+    def initialize(row_template:, columns: [])
+      @row_template = row_template
+      @columns = columns
+    end
+  end
+end

data/lib/ruby_jard/screen.rb

@@ -6,56 +6,134 @@ module RubyJard
   # generated based on input layout specifiation, screen data, and top-left
   # corner cordination.
   class Screen
-    attr_reader :output
+    attr_accessor :output, :rows, :width, :height, :x, :y
 
-    def initialize(layout:, output:, session:, row:, col:)
-      @output = output
-      @session = session
-      @layout = layout
-      @row = row
-      @col = col
-      @color_decorator = Pastel.new
+    def initialize(screen_template:, session: nil, width:, height:, x:, y:)
+      @session = session || RubyJard.current_session
+      @screen_template = screen_template
+      @width = width
+      @height = height
+      @x = x
+      @y = y
     end
 
-    def draw(_row, _col, _size)
-      raise NotImplementedError, "#{self.class} must implement #draw method"
+    def draw(output)
+      calculate
+      drawer = RubyJard::ScreenDrawer.new(
+        output: output,
+        screen: self,
+        x: @x,
+        y: @y
+      )
+      drawer.draw
     end
 
-    def decorate_text
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::TextDecorator.new(@color_decorator)
+    def data_size
+      raise NotImplementedError, "#{self.class} must implement #data_size method"
     end
 
-    def decorate_path(path, lineno)
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::PathDecorator.new(path, lineno)
+    def data_window
+      raise NotImplementedError, "#{self.class} must implement #data_window method"
     end
 
-    def decorate_source(file, lineno, window)
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::SourceDecorator.new(file, lineno, window)
+    def calculate
+      @rows = []
+      row_template = @screen_template.row_template
+      @rows = data_window.map.with_index do |data_row, index|
+        create_row(row_template, data_row, index)
+      end
+      column_widths = calculate_column_widths(row_template, @rows)
+      fill_column_widths(@rows, column_widths)
     end
 
-    def decorate_loc(loc, highlighted)
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::LocDecorator.new(@color_decorator, loc, highlighted)
+    private
+
+    def calculate_column_widths(row_template, rows)
+      column_widths = {}
+      ideal_column_width = @width / row_template.columns.length
+      row_template.columns.each_with_index do |_column_template, column_index|
+        column_widths[column_index] ||= 0
+        rows.each do |row|
+          column = row.columns[column_index]
+          if column.content_length > ideal_column_width
+            column_widths[column_index] = nil
+            break
+          elsif column.content_length > column_widths[column_index]
+            column_widths[column_index] = column.content_length
+          end
+        end
+      end
+      column_widths
     end
 
-    private
+    def fill_column_widths(rows, column_widths)
+      fixed_count = column_widths.length
+      fixed_width = column_widths.values.inject(0) do |sum, col|
+        col.nil? ? sum : sum + col
+      end
+
+      rows.each do |row|
+        total_width = 0
+        row.columns.each_with_index do |column, column_index|
+          column.width =
+            if column_index == row.columns.length - 1
+              @width - total_width
+            elsif column_widths[column_index].nil?
+              (@width - fixed_width) / fixed_count
+            else
+              column_widths[column_index]
+            end
+          total_width += column.width
+        end
+      end
+    end
+
+    def create_row(row_template, data_row, index)
+      row = Row.new(row_template: row_template)
+      row.columns = row_template.columns.map do |column_template|
+        create_column(column_template, data_row, index)
+      end
+      row
+    end
+
+    def create_column(column_template, data_row, index)
+      column = Column.new(column_template: column_template)
+      column.spans = column_template.spans.map do |span_template|
+        create_span(span_template, data_row, index)
+      end.flatten
+      column.content_length =
+        column.spans.map(&:content_length).inject(&:+) +
+        column.margin_left +
+        column.margin_right
+      column
+    end
+
+    def create_span(span_template, data_row, index)
+      span = Span.new(span_template: span_template)
+      span_content_method = "span_#{span_template.name}".to_sym
+
+      if respond_to?(span_content_method)
+        content, styles = send(span_content_method, data_row, index)
+        if content.nil?
+          span.content = ''
+          span.content_length = 0
+        elsif content.is_a?(Array)
+          content.each do |sub_span|
+            sub_span.styles += Array(styles).flatten.compact
+          end
+          return content
+        else
+          content = ' ' * span_template.margin_left + content if span_template.margin_left
+          content += ' ' * span_template.margin_right if span_template.margin_right
+          span.content = content
+          span.styles = Array(styles).flatten.compact
+          span.content_length = span.content.length
+        end
+      else
+        raise NotImplementedError, "#{self.class} must implement #{span_content_method} method"
+      end
 
-    def default_frame_styles
-      {
-        style: {
-          fg: :white
-        },
-        border: {
-          bottom_left: false,
-          bottom_right: false,
-          bottom: false,
-          left: :line,
-          right: false
-        }
-      }
+      span
     end
   end
 end

data/lib/ruby_jard/screen_drawer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Draw a screen and its rows into the output interface.
+  class ScreenDrawer
+    attr_reader :output
+
+    ELLIPSIS = ' »'
+
+    def initialize(output:, screen:, x:, y:)
+      @output = output
+      @color_decorator = RubyJard::Decorators::ColorDecorator.new
+      @x = x
+      @y = y
+      @original_x = x
+      @original_y = y
+      @screen = screen
+    end
+
+    def draw
+      @original_x = @x
+      @screen.rows.each do |row|
+        draw_columns(row, row.columns)
+        @y += 1
+        @x = @original_x
+      end
+    end
+
+    private
+
+    def draw_columns(row, columns)
+      columns.each do |column|
+        width = 0
+        lines = 1
+        column_content_width = column.width - column.margin_left - column.margin_right
+        @x += column.margin_left
+        RubyJard::Console.move_to(@output, @x, @y)
+
+        column.spans.each do |span|
+          line_content = span.content
+
+          until line_content.nil? || line_content.empty?
+            if column_content_width - width <= 0
+              width = 0
+              lines += 1
+              @y += 1
+              RubyJard::Console.move_to(@output, @x, @y)
+            end
+            drawing_content = line_content[0..column_content_width - width - 1]
+            line_content = line_content[column_content_width - width..-1]
+            width += drawing_content.length
+
+            if !row.line_limit.nil? && lines >= row.line_limit && !line_content.nil? && !line_content.empty?
+              drawing_content[drawing_content.length - ELLIPSIS.length..-1] = ELLIPSIS
+              protected_print @color_decorator.decorate(drawing_content, *span.styles)
+              break
+            else
+              protected_print @color_decorator.decorate(drawing_content, *span.styles)
+            end
+          end
+        end
+        @x += column_content_width + column.margin_right
+      end
+    end
+
+    def protected_print(content)
+      # TODO: currently, only row overflow is detected. Definitely should handle column overflow
+      return if @y < @original_y || @y > @original_y + @screen.height - 1
+
+      @output.print content
+    end
+
+    def default_frame_styles
+      {
+        style: {
+          fg: :white
+        },
+        border: {
+          bottom_left: false,
+          bottom_right: false,
+          bottom: false,
+          left: :line,
+          right: false
+        }
+      }
+    end
+  end
+end

data/lib/ruby_jard/screen_manager.rb

@@ -1,108 +1,209 @@
 # frozen_string_literal: true
 
-require 'ruby_jard/decorators/text_decorator'
+require 'ruby_jard/console'
+
+require 'ruby_jard/decorators/color_decorator'
 require 'ruby_jard/decorators/path_decorator'
 require 'ruby_jard/decorators/loc_decorator'
 require 'ruby_jard/decorators/source_decorator'
+
 require 'ruby_jard/screen'
+require 'ruby_jard/box_drawer'
+require 'ruby_jard/screen_drawer'
 require 'ruby_jard/screens'
-require 'ruby_jard/screens/breakpoints_screen'
-require 'ruby_jard/screens/expressions_sreen'
 require 'ruby_jard/screens/source_screen'
 require 'ruby_jard/screens/backtrace_screen'
 require 'ruby_jard/screens/threads_screen'
 require 'ruby_jard/screens/variables_screen'
 require 'ruby_jard/screens/menu_screen'
-require 'ruby_jard/layout_template'
+
+require 'ruby_jard/templates/layout_template'
+require 'ruby_jard/templates/screen_template'
+require 'ruby_jard/templates/row_template'
+require 'ruby_jard/templates/column_template'
+require 'ruby_jard/templates/span_template'
+require 'ruby_jard/templates/space_template'
+
+require 'ruby_jard/layouts/wide_layout'
 require 'ruby_jard/layout'
+require 'ruby_jard/row'
+require 'ruby_jard/column'
+require 'ruby_jard/span'
 
 module RubyJard
   ##
   # This class acts as a coordinator, in which it combines the data and screen
   # layout template, triggers each screen to draw on the terminal.
   class ScreenManager
-    attr_reader :output
+    class << self
+      extend Forwardable
+
+      def_delegators :instance, :update, :draw_error, :started?, :updating?
 
-    def initialize(session:, output: STDOUT)
+      def instance
+        @instance ||= new
+      end
+    end
+
+    attr_reader :output, :output_storage
+
+    def initialize(output: STDOUT)
       @output = output
-      @session = session
       @screens = {}
+      @started = false
+      @updating = false
+      @output_storage = StringIO.new
     end
 
     def start
-      refresh
+      return if started?
+
+      RubyJard::Console.start_alternative_terminal(@output)
+      RubyJard::Console.hard_clear_screen(@output)
+
+      def $stdout.write(string)
+        if !RubyJard::ScreenManager.updating? && RubyJard::ScreenManager.started?
+          RubyJard::ScreenManager.instance.output_storage.write(string)
+        end
+        super
+      end
+
+      at_exit { stop }
+      @started = true
+    end
+
+    def started?
+      @started == true
+    end
+
+    def updating?
+      @updating == true
+    end
+
+    def stop
+      return unless started?
+
+      @started = false
+
+      RubyJard::Console.stop_alternative_terminal(@output)
+      RubyJard::Console.cooked!(@output)
+      RubyJard::Console.echo!(@output)
+      RubyJard::Console.show_cursor(@output)
+
+      unless @output_storage.string.empty?
+        @output.puts ''
+        @output.write @output_storage.string
+        @output.puts ''
+      end
+      @output_storage.close
     end
 
-    def refresh
+    def update
+      start unless started?
+      @updating = true
+
+      RubyJard::Console.hide_cursor(@output)
+      clear_screen
+      width, height = RubyJard::Console.screen_size(@output)
+      screen_layouts = calculate_layouts(width, height)
+      draw_screens(screen_layouts)
+      jump_to_prompt(screen_layouts)
+      draw_debug(width, height)
+    rescue StandardError => e
       clear_screen
-      width = TTY::Screen.width
-      height = TTY::Screen.height
-      template = pick_template(width, height)
-      layout = RubyJard::Layout.generate(template: template, width: width, height: height)
-      begin
-        draw(layout, 0, 0)
-      rescue StandardError => e
-        clear_screen
-        @output.puts e
-        @output.puts e.backtrace
+      draw_error(e, height)
+    ensure
+      # You don't want to mess up previous user TTY no matter happens
+      RubyJard::Console.cooked!(@output)
+      RubyJard::Console.echo!(@output)
+      RubyJard::Console.show_cursor(@output)
+      @updating = false
+    end
+
+    def draw_error(exception, height = 0)
+      @output.puts '--- Error ---'
+      @output.puts "Internal error from Jard. I'm sorry to mess up your debugging experience."
+      @output.puts 'It would be great if you can submit an issue in https://github.com/nguyenquangminh0711/ruby_jard/issues'
+      @output.puts ''
+      @output.puts exception
+      if height == 0
+        @output.puts exception.backtrace
+      else
+        @output.puts exception.backtrace.first(height - 5)
       end
+      @output.puts '-------------'
     end
 
+
     private
 
-    def clear_screen
-      @output.print TTY::Cursor.clear_screen
-      @output.print TTY::Cursor.move_to(0, 0)
+    def calculate_layouts(width, height)
+      layout = pick_layout(width, height)
+      RubyJard::Layout.calculate(
+        layout: layout,
+        width: width, height: height,
+        x: 0, y: 0
+      )
     end
 
-    def draw(layout, row, col)
-      @output.print TTY::Cursor.move_to(col, row)
+    def draw_box(screens)
+      RubyJard::BoxDrawer.new(
+        output: @output,
+        screens: screens
+      ).draw
+    end
 
-      if layout.screen.nil?
-        draw_children(layout, row, col)
-      else
-        screen = fetch_screen(layout.screen)
+    def draw_screens(screen_layouts)
+      screens = screen_layouts.map do |screen_template, width, height, x, y|
+        screen = fetch_screen(screen_template.screen)
         screen&.new(
-          output: @output,
-          session: @session,
-          layout: layout,
-          row: row,
-          col: col
-        )&.draw
+          screen_template: screen_template,
+          width: width, height: height,
+          x: x, y: y
+        )
+      end
+      draw_box(screens)
+      adjust_screen_contents(screens)
+      screens.each do |screen|
+        screen.draw(@output)
       end
     end
 
-    # rubocop:disable Metrics/AbcSize
-    def draw_children(layout, row, col)
-      children_row = row
-      children_col = col
-      drawing_width = 0
-      max_height = 0
-      layout.children.each do |child|
-        draw(child, children_row, children_col)
-
-        drawing_width += child.width
-        max_height = child.height if max_height < child.height
-        # Overflow. Break to next line
-        if drawing_width >= layout.width
-          children_row += max_height
-          children_col = col
-          drawing_width = 0
-          max_height = 0
-        else
-          children_col += child.width
+    def jump_to_prompt(screen_layouts)
+      prompt_y = screen_layouts.map { |_template, _width, screen_height, _x, y| y + screen_height }.max
+      RubyJard::Console.move_to(@output, 0, prompt_y)
+    end
+
+    def draw_debug(_width, height)
+      unless RubyJard.debug_info.empty?
+        @output.puts '--- Debug ---'
+        RubyJard.debug_info.first(height - 2).each do |line|
+          @output.puts line
         end
+        @output.puts '-------------'
       end
+      RubyJard.clear_debug
+    end
 
-      @output.print TTY::Cursor.move_to(0, children_row + 1)
+    def adjust_screen_contents(screens)
+      # After drawing the box, screen sizes should be updated to reflect content-only area
+      screens.each do |screen|
+        screen.width -= 2
+        screen.height -= 2
+        screen.x += 1
+        screen.y += 1
+      end
+    end
+
+    def clear_screen
+      RubyJard::Console.clear_screen(@output)
     end
-    # rubocop:enable Metrics/AbcSize
 
     def fetch_screen(name)
       RubyJard::Screens[name]
     end
 
-    def pick_template(width, height)
+    def pick_layout(width, height)
       RubyJard::DEFAULT_LAYOUT_TEMPLATES.each do |template|
         matched = true
         matched &&= (