ruby_jard 0.2.0 → 0.2.1

data/lib/ruby_jard/repl_processor.rb

@@ -120,7 +120,7 @@ module RubyJard
       # Do nothing
     end
 
-    def handle_key_binding_command(options)
+    def handle_key_binding_command(options = {})
       method_name = "handle_#{options[:action]}_command"
       if respond_to?(method_name, true)
         send(method_name)
@@ -129,5 +129,9 @@ module RubyJard
               "Fail to handle key binding `#{options[:action]}`"
       end
     end
+
+    def handle_list_command(_options = {})
+      process_commands
+    end
   end
 end

data/lib/ruby_jard/repl_proxy.rb

@@ -7,6 +7,7 @@ require 'ruby_jard/commands/next_command'
 require 'ruby_jard/commands/step_command'
 require 'ruby_jard/commands/step_out_command'
 require 'ruby_jard/commands/frame_command'
+require 'ruby_jard/commands/list_command'
 
 module RubyJard
   ##
@@ -80,7 +81,7 @@ module RubyJard
     end
 
     def read_key
-      STDIN.getch(min: 0, time: KEYPRESS_POLLING)
+      RubyJard::Console.getch(STDIN, KEYPRESS_POLLING)
     end
 
     def repl(current_binding)

data/lib/ruby_jard/row.rb

@@ -4,13 +4,13 @@ module RubyJard
   class Row
     extend Forwardable
 
-    attr_accessor :row_template, :columns
+    attr_accessor :columns, :line_limit, :content
 
-    def_delegators :@row_template, :line_limit
-
-    def initialize(row_template:, columns: [])
-      @row_template = row_template
+    def initialize(line_limit: 1, columns: [], ellipsis: true)
+      @content = []
       @columns = columns
+      @ellipsis = ellipsis
+      @line_limit = line_limit
     end
   end
 end

data/lib/ruby_jard/row_renderer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Generate bitmap lines from a row's data
+  class RowRenderer
+    ELLIPSIS = ' »'
+
+    def initialize(row:, width:, height:, color_scheme:)
+      @row = row
+      @width = width
+      @height = height
+      @color_decorator = RubyJard::Decorators::ColorDecorator.new(color_scheme)
+    end
+
+    def render
+      @x = 0
+      @y = 0
+      @content_map = []
+
+      original_x = 0
+      @row.columns.each_with_index do |column, index|
+        @y = 0
+        @x = original_x
+        content_width = column.width
+        content_width -= 1 if index < @row.columns.length - 1
+        render_column(column, original_x, content_width)
+
+        original_x += column.width
+      end
+
+      generate_bitmap
+    end
+
+    def render_column(column, original_x, content_width)
+      width = 0
+      lines = 1
+
+      column.spans.each do |span|
+        line_content = span.content
+
+        until line_content.nil? || line_content.empty?
+          if column.word_wrap == RubyJard::Column::WORD_WRAP_NORMAL
+            if content_width - width < line_content.length && width != 0
+              width = 0
+              lines += 1
+              @y += 1
+              @x = original_x
+            end
+          elsif column.word_wrap == RubyJard::Column::WORD_WRAP_BREAK_WORD
+            if content_width - width <= 0
+              width = 0
+              lines += 1
+              @y += 1
+              @x = original_x
+            end
+          elsif content_width - width <= 0
+            return
+          end
+          drawing_content = line_content[0..content_width - width - 1]
+          line_content = line_content[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
+            draw_content(drawing_content, span.styles)
+            return
+          else
+            draw_content(drawing_content, span.styles)
+          end
+        end
+      end
+    end
+
+    def draw_content(drawing_content, styles)
+      return if @y < 0 || @y >= @height
+
+      @content_map[@y] ||= []
+      @content_map[@y][@x] = [styles, drawing_content]
+      @x += drawing_content.length
+    end
+
+    def generate_bitmap
+      @row.content = []
+      @content_map.each do |line|
+        line_content = ''
+        pending_content = ''
+
+        cell_index = 0
+        while cell_index < @width
+          cell = line[cell_index]
+          if cell.nil? || cell[1].empty?
+            pending_content += ' '
+            cell_index += 1
+          else
+            line_content += @color_decorator.decorate(:background, pending_content)
+            line_content += @color_decorator.decorate(cell[0], cell[1])
+            pending_content = ''
+            cell_index += cell[1].length
+          end
+        end
+
+        line_content += @color_decorator.decorate(:background, pending_content) unless pending_content.empty?
+        @row.content << line_content
+      end
+    end
+  end
+end

data/lib/ruby_jard/screen.rb

@@ -6,134 +6,39 @@ module RubyJard
   # generated based on input layout specifiation, screen data, and top-left
   # corner cordination.
   class Screen
-    attr_accessor :output, :rows, :width, :height, :x, :y
+    attr_accessor :layout, :rows, :color_scheme, :window, :cursor, :selected
 
-    def initialize(screen_template:, session: nil, width:, height:, x:, y:)
+    def initialize(session: nil, layout:, color_scheme:)
       @session = session || RubyJard.current_session
-      @screen_template = screen_template
-      @width = width
-      @height = height
-      @x = x
-      @y = y
-    end
-
-    def draw(output)
-      calculate
-      drawer = RubyJard::ScreenDrawer.new(
-        output: output,
-        screen: self,
-        x: @x,
-        y: @y
-      )
-      drawer.draw
-    end
-
-    def data_size
-      raise NotImplementedError, "#{self.class} must implement #data_size method"
-    end
-
-    def data_window
-      raise NotImplementedError, "#{self.class} must implement #data_window method"
-    end
-
-    def calculate
+      @layout = layout
+      @color_scheme = color_scheme
+      @window = []
+      @cursor = nil
+      @selected = 0
       @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)
+      @need_to_render = true
     end
 
-    private
+    def move_down; end
 
-    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
+    def move_up; end
 
-    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
+    def page_up; 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 page_down; 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 click(relative_x, relative_y); 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
+    def build
+      raise NotImplementedError, "#{self.class} should implement this method."
     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 need_to_render?
+      @need_to_render == true
+    end
 
-      span
+    def mark_rendered!
+      @need_to_render = false
     end
   end
 end

data/lib/ruby_jard/screen_drawer.rb

@@ -1,89 +1,22 @@
 # 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:)
+    def initialize(output:, screen:, color_scheme:)
       @output = output
-      @color_decorator = RubyJard::Decorators::ColorDecorator.new
-      @x = x
-      @y = y
-      @original_x = x
-      @original_y = y
       @screen = screen
+      @color_decorator = RubyJard::Decorators::ColorDecorator.new(color_scheme)
     end
 
     def draw
-      @original_x = @x
-      @screen.rows.each do |row|
-        draw_columns(row, row.columns)
-        @y += 1
-        @x = @original_x
+      @screen.window.each_with_index do |line, index|
+        RubyJard::Console.move_to(@output, @screen.layout.x, @screen.layout.y + index)
+        @output.print line
       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
+      (@screen.window.length..@screen.layout.height - 1).each do |index|
+        RubyJard::Console.move_to(@output, @screen.layout.x, @screen.layout.y + index)
+        @output.print @color_decorator.decorate(:background, ' ' * @screen.layout.width)
       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

@@ -6,11 +6,24 @@ 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/decorators/inspection_decorator'
 
 require 'ruby_jard/screen'
+require 'ruby_jard/screens'
+
+require 'ruby_jard/color_scheme'
+require 'ruby_jard/color_schemes'
+require 'ruby_jard/color_schemes/deep_space_color_scheme'
+require 'ruby_jard/color_schemes/256_color_scheme'
+
+require 'ruby_jard/row'
+require 'ruby_jard/column'
+require 'ruby_jard/span'
+require 'ruby_jard/row_renderer'
+require 'ruby_jard/screen_renderer'
 require 'ruby_jard/box_drawer'
 require 'ruby_jard/screen_drawer'
-require 'ruby_jard/screens'
+
 require 'ruby_jard/screens/source_screen'
 require 'ruby_jard/screens/backtrace_screen'
 require 'ruby_jard/screens/threads_screen'
@@ -19,16 +32,11 @@ require 'ruby_jard/screens/menu_screen'
 
 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/layouts/narrow_layout'
 require 'ruby_jard/layout'
-require 'ruby_jard/row'
-require 'ruby_jard/column'
-require 'ruby_jard/span'
+require 'ruby_jard/layout_calculator'
 
 module RubyJard
   ##
@@ -59,7 +67,7 @@ module RubyJard
       return if started?
 
       RubyJard::Console.start_alternative_terminal(@output)
-      RubyJard::Console.hard_clear_screen(@output)
+      RubyJard::Console.clear_screen(@output)
 
       def $stdout.write(string)
         if !RubyJard::ScreenManager.updating? && RubyJard::ScreenManager.started?
@@ -86,9 +94,9 @@ module RubyJard
       @started = false
 
       RubyJard::Console.stop_alternative_terminal(@output)
-      RubyJard::Console.cooked!(@output)
-      RubyJard::Console.echo!(@output)
-      RubyJard::Console.show_cursor(@output)
+      RubyJard::Console.cooked!
+      RubyJard::Console.enable_echo!
+      RubyJard::Console.enable_cursor!
 
       unless @output_storage.string.empty?
         @output.puts ''
@@ -102,25 +110,35 @@ module RubyJard
       start unless started?
       @updating = true
 
-      RubyJard::Console.hide_cursor(@output)
-      clear_screen
+      RubyJard::Console.disable_cursor!
       width, height = RubyJard::Console.screen_size(@output)
-      screen_layouts = calculate_layouts(width, height)
-      draw_screens(screen_layouts)
-      jump_to_prompt(screen_layouts)
+
+      @layouts = calculate_layouts(width, height)
+      @screens = build_screens(@layouts)
+      draw_box(@screens)
+      draw_screens(@screens)
+
+      RubyJard::Console.move_to(@output, 0, total_screen_height(@layouts) + 1)
+      RubyJard::Console.clear_screen_to_end(@output)
+
       draw_debug(width, height)
     rescue StandardError => e
-      clear_screen
+      RubyJard::Console.clear_screen(@output)
       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)
+      RubyJard::Console.cooked!
+      RubyJard::Console.enable_echo!
+      RubyJard::Console.enable_cursor!
       @updating = false
     end
 
+    def scroll; end
+
+    def click; end
+
     def draw_error(exception, height = 0)
+      @output.print RubyJard::Decorators::ColorDecorator::CSI_RESET
       @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'
@@ -129,52 +147,62 @@ module RubyJard
       if height == 0
         @output.puts exception.backtrace
       else
-        @output.puts exception.backtrace.first(height - 5)
+        @output.puts exception.backtrace.first(10)
       end
       @output.puts '-------------'
     end
 
-
     private
 
     def calculate_layouts(width, height)
       layout = pick_layout(width, height)
-      RubyJard::Layout.calculate(
-        layout: layout,
+      RubyJard::LayoutCalculator.calculate(
+        layout_template: layout,
         width: width, height: height,
         x: 0, y: 0
       )
     end
 
+    def build_screens(layouts)
+      layouts.map do |layout|
+        screen_class = fetch_screen(layout.template.screen)
+        screen = screen_class.new(
+          layout: layout,
+          color_scheme: pick_color_scheme
+        )
+        screen.build
+        render_screen(screen)
+        screen
+      end
+    end
+
     def draw_box(screens)
       RubyJard::BoxDrawer.new(
         output: @output,
-        screens: screens
+        screens: screens,
+        color_scheme: pick_color_scheme
       ).draw
     end
 
-    def draw_screens(screen_layouts)
-      screens = screen_layouts.map do |screen_template, width, height, x, y|
-        screen = fetch_screen(screen_template.screen)
-        screen&.new(
-          screen_template: screen_template,
-          width: width, height: height,
-          x: x, y: y
-        )
-      end
-      draw_box(screens)
-      adjust_screen_contents(screens)
+    def draw_screens(screens)
       screens.each do |screen|
-        screen.draw(@output)
+        RubyJard::ScreenDrawer.new(
+          output: @output,
+          screen: screen,
+          color_scheme: pick_color_scheme
+        ).draw
       end
     end
 
-    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)
+    def render_screen(screen)
+      RubyJard::ScreenRenderer.new(
+        screen: screen,
+        color_scheme: pick_color_scheme
+      ).render
     end
 
     def draw_debug(_width, height)
+      @output.print RubyJard::Decorators::ColorDecorator::CSI_RESET
       unless RubyJard.debug_info.empty?
         @output.puts '--- Debug ---'
         RubyJard.debug_info.first(height - 2).each do |line|
@@ -185,24 +213,14 @@ module RubyJard
       RubyJard.clear_debug
     end
 
-    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
-
     def fetch_screen(name)
       RubyJard::Screens[name]
     end
 
+    def total_screen_height(layouts)
+      layouts.map { |layout| layout.y + layout.height }.max
+    end
+
     def pick_layout(width, height)
       RubyJard::DEFAULT_LAYOUT_TEMPLATES.each do |template|
         matched = true
@@ -218,5 +236,10 @@ module RubyJard
       end
       RubyJard::DEFAULT_LAYOUT_TEMPLATES.first
     end
+
+    def pick_color_scheme
+      # TODO: Fallback to a default color scheme if not found
+      RubyJard::ColorSchemes[RubyJard::DEFAULT_COLOR_SCHEME].new
+    end
   end
 end