ruby_jard 0.2.0 → 0.2.1

data/lib/ruby_jard/screen_renderer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Adjust the layout between screens, render row's bitmap by calling RowRenderer,
+  # calculate screen window to ready for putting on the screen.
+  class ScreenRenderer
+    def initialize(screen:, color_scheme:)
+      @screen = screen
+      @color_scheme = color_scheme
+    end
+
+    def render
+      return unless @screen.need_to_render?
+
+      # Move this logic into a class called SreenRenderer
+      calculate_content_lengths
+      column_widths = calculate_column_widths
+      adjust_column_widths(column_widths)
+      render_rows
+      calculate_window
+      @screen.mark_rendered!
+
+      @screen
+    end
+
+    private
+
+    def calculate_content_lengths
+      @screen.rows.each do |row|
+        row.columns.each do |column|
+          column.content_length = column.spans.map(&:content_length).inject(&:+)
+        end
+      end
+    end
+
+    def calculate_column_widths
+      column_widths = {}
+      total_columns = count_columns
+
+      return column_widths if total_columns == 0
+
+      ideal_column_width = @screen.layout.width / total_columns
+      total_columns.times do |column_index|
+        column_widths[column_index] ||= 0
+        @screen.rows.each do |row|
+          column = row.columns[column_index]
+          if column.content_length > ideal_column_width - 1
+            column_widths[column_index] = nil
+            break
+          elsif column.content_length + 1 > column_widths[column_index]
+            column_widths[column_index] = column.content_length + 1
+          end
+        end
+      end
+      column_widths
+    end
+
+    def adjust_column_widths(column_widths)
+      dynamic_count = column_widths.values.select(&:nil?).length
+      fixed_width = column_widths.values.inject(0) do |sum, col|
+        col.nil? ? sum : sum + col
+      end
+
+      @screen.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
+              @screen.layout.width - total_width
+            elsif column_widths[column_index].nil?
+              (@screen.layout.width - fixed_width) / dynamic_count
+            else
+              column_widths[column_index]
+            end
+          total_width += column.width
+        end
+      end
+    end
+
+    def render_rows
+      @screen.rows.each do |row|
+        RubyJard::RowRenderer.new(
+          row: row,
+          width: @screen.layout.width,
+          height: @screen.layout.height,
+          color_scheme: @color_scheme
+        ).render
+      end
+    end
+
+    def calculate_window
+      @screen.window = []
+
+      if @screen.cursor.nil?
+        find_seleted_window
+      else
+        find_cursor_window
+      end
+    end
+
+    def find_seleted_window
+      @screen.rows.each_with_index do |row, row_index|
+        row.content.each_with_index do |line, line_index|
+          if @screen.window.length < @screen.layout.height
+            @screen.window << line
+          elsif row_index < @screen.selected
+            @screen.window = [line]
+          elsif row_index == @screen.selected
+            if line_index != 0
+              @screen.window.shift
+              @screen.window << line
+            else
+              @screen.window = [line]
+            end
+          else
+            return
+          end
+        end
+      end
+    end
+
+    def find_cursor_window
+      cursor_line = -1
+      @screen.rows.each do |row|
+        row.content.each do |line|
+          cursor_line += 1
+          @screen.window << line if cursor_line >= @screen.cursor
+          return if @screen.window.length >= @screen.layout.height
+        end
+      end
+    end
+
+    def count_columns
+      @screen.rows.map { |row| row.columns.count }.max.to_i
+    end
+  end
+end

data/lib/ruby_jard/screens/backtrace_screen.rb

@@ -6,48 +6,51 @@ module RubyJard
     # Backtrace screen implements the content to display current thread's backtrace to the user.
     class BacktraceScreen < RubyJard::Screen
       def title
-        "Backtrace (#{frames_count})"
-      end
-
-      def data_size
-        [@height, frames_count].min
-      end
-
-      def data_window
-        return [] if data_size.zero?
-
-        @data_window ||= backtrace[data_window_start..data_window_end]
-      end
-
-      def data_window_start
-        return 0 if data_size.zero?
-
-        current_frame / data_size * data_size
-      end
-
-      def data_window_end
-        [frames_count, data_window_start + data_size - 1].min
+        ['Backtrace', "#{frames_count} frames"]
+      end
+
+      def build
+        @rows = @session.backtrace.map.with_index do |frame, frame_id|
+          RubyJard::Row.new(
+            line_limit: 2,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  span_frame_id(frame_id)
+                ]
+              ),
+              RubyJard::Column.new(
+                spans: [
+                  span_class_label(frame),
+                  span_label_preposition,
+                  span_method_label(frame),
+                  span_path(frame)
+                ]
+              )
+            ]
+          )
+        end
+        @selected = current_frame
       end
 
-      def span_mark(_frame, index)
-        [
-          current_frame?(index) ? '→' : ' ',
-          [:bright_yellow, current_frame?(index) ? :bold : nil]
-        ]
-      end
+      private
 
-      def span_frame_id(_frame, index)
-        frame_id = index + data_window_start
-        [
-          frame_id.to_s,
-          [
-            current_frame?(index) ? :bright_yellow : :white,
-            current_frame?(index) ? :bold : nil
-          ]
-        ]
+      def span_frame_id(frame_id)
+        frame_id_label = frame_id.to_s.rjust(frames_count.to_s.length)
+        if current_frame?(frame_id)
+          RubyJard::Span.new(
+            content: frame_id_label,
+            styles: :frame_id_highlighted
+          )
+        else
+          RubyJard::Span.new(
+            content: frame_id_label,
+            styles: :frame_id
+          )
+        end
       end
 
-      def span_klass_label(frame, index)
+      def span_class_label(frame)
         object = frame[1]
         klass = frame[2]
         klass_label =
@@ -63,18 +66,23 @@ module RubyJard
           else
             klass.name
           end
-        c_frame = frame_at(index).last.nil? ? '[c] ' : ''
-        [
-          "#{c_frame}#{klass_label}",
-          [:green, current_frame?(index) ? :bold : nil]
-        ]
+        c_frame = frame.last.nil? ? '[c] ' : ''
+        RubyJard::Span.new(
+          content: "#{c_frame}#{klass_label}",
+          margin_right: 1,
+          styles: :constant
+        )
       end
 
-      def span_label_preposition(_frame, index)
-        ['in', current_frame?(index) ? [:bright_white] : [:white]]
+      def span_label_preposition
+        RubyJard::Span.new(
+          content: 'in',
+          margin_right: 1,
+          styles: :frame_location
+        )
       end
 
-      def span_method_label(frame, index)
+      def span_method_label(frame)
         location = frame[0]
         method_label =
           if location.label != location.base_label
@@ -82,33 +90,31 @@ module RubyJard
           else
             location.base_label
           end
-        [method_label, [:green, current_frame?(index) ? :bold : nil]]
-      end
-
-      def span_path_preposition(frame, index)
-        location = frame[0]
-        decorated_path = decorate_path(location.absolute_path, location.lineno)
-        preposition = decorated_path.gem? ? 'in' : 'at'
-        [preposition, current_frame?(index) ? [:bright_white] : [:white]]
+        RubyJard::Span.new(
+          content: method_label,
+          margin_right: 1,
+          styles: :method
+        )
       end
 
-      def span_path(frame, index)
+      def span_path(frame)
         location = frame[0]
         decorated_path = decorate_path(location.absolute_path, location.lineno)
 
         path_label =
           if decorated_path.gem?
-            "#{decorated_path.gem} (#{decorated_path.gem_version})"
+            "in #{decorated_path.gem} (#{decorated_path.gem_version})"
           else
-            "#{decorated_path.path}:#{decorated_path.lineno}"
+            "at #{decorated_path.path}:#{decorated_path.lineno}"
           end
-        [path_label, current_frame?(index) ? [:bold, :bright_white] : [:white]]
+        RubyJard::Span.new(
+          content: path_label,
+          styles: :frame_location
+        )
       end
 
-      private
-
-      def current_frame?(index)
-        index + data_window_start == current_frame
+      def current_frame?(frame_id)
+        frame_id == current_frame
       end
 
       def current_frame
@@ -119,18 +125,10 @@ module RubyJard
         end
       end
 
-      def frame_at(index)
-        backtrace[index + data_window_start]
-      end
-
       def frames_count
         @session.backtrace.length
       end
 
-      def backtrace
-        @session.backtrace
-      end
-
       def decorate_path(path, lineno)
         RubyJard::Decorators::PathDecorator.new(path, lineno)
       end

data/lib/ruby_jard/screens/menu_screen.rb

@@ -3,49 +3,54 @@
 module RubyJard
   module Screens
     class MenuScreen < RubyJard::Screen
-      def draw(output)
-        RubyJard::Console.move_to(output, @x, @y)
-
-        margin = 0
-        left_menu = generate_left_menu
-        left_menu.each do |text, length|
-          RubyJard::Console.move_to(output, @x + 1 + margin, @y)
-          output.print text
-          margin += length + 3
-        end
-
-        margin = 0
-        right_menu = generate_right_menu
-        right_menu.reverse.each do |text, length|
-          RubyJard::Console.move_to(output, @x + @width - margin - length - 1, @y)
-          output.print text
-          margin += length + 3
-        end
+      def build
+        span_title = RubyJard::Span.new(
+          content: ' REPL Console ',
+          styles: :title_highlighted
+        )
+        menu_spans = generate_menu_spans
+
+        alignment =
+          @layout.width -
+          span_title.content_length -
+          menu_spans.map(&:content_length).sum
+        span_align = RubyJard::Span.new(
+          content: ' ' * (alignment < 0 ? 0 : alignment),
+          styles: :background
+        )
+        @rows = [RubyJard::Row.new(
+          line_limit: 1,
+          ellipsis: false,
+          columns: [
+            RubyJard::Column.new(
+              spans: [
+                span_title,
+                span_align,
+                menu_spans
+              ].flatten
+            )
+          ]
+        )]
+        @selected = 0
       end
 
       private
 
-      def generate_left_menu
-        [
-          # Fill in later
-        ]
-      end
-
-      def generate_right_menu
+      def generate_menu_spans
         [
-          decorate_text('Step (F7)', :white),
-          decorate_text('Step Out (Shift+F7)', :white),
-          decorate_text('Next (F8)', :white),
-          decorate_text('Continue (F9)', :white)
-        ]
-      end
-
-      def decorate_text(str, *styles)
-        [color_decorator.decorate(str, *styles), str.length]
-      end
-
-      def color_decorator
-        @color_decorator ||= RubyJard::Decorators::ColorDecorator.new
+          'Up (F6)',
+          'Down (Shift+F6)',
+          'Step (F7)',
+          'Step Out (Shift+F7)',
+          'Next (F8)',
+          'Continue (F9)'
+        ].map do |menu_item|
+          RubyJard::Span.new(
+            content: menu_item,
+            margin_left: 3,
+            styles: :control_buttons
+          )
+        end
       end
     end
   end

data/lib/ruby_jard/screens/source_screen.rb

@@ -8,41 +8,57 @@ module RubyJard
 
         decorated_path = path_decorator(current_file, current_line)
         if decorated_path.gem?
-          "Source (#{decorated_path.gem} - #{decorated_path.path}:#{decorated_path.lineno})"
+          ['Source', "#{decorated_path.gem} - #{decorated_path.path}:#{decorated_path.lineno}"]
         else
-          "Source (#{decorated_path.path}:#{decorated_path.lineno})"
+          ['Source', "#{decorated_path.path}:#{decorated_path.lineno}"]
         end
       end
 
-      def data_size
-        @height
-      end
-
-      def data_window
-        return [] if RubyJard.current_session.frame.nil?
-
-        @data_window ||= source_decorator.codes
+      def build
+        return if RubyJard.current_session.frame.nil?
+
+        # TODO: screen now supports window.
+        codes = source_decorator.codes
+        @rows = codes.map.with_index do |loc, index|
+          RubyJard::Row.new(
+            line_limit: 3,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  span_mark(index),
+                  span_lineno(index)
+                ]
+              ),
+              RubyJard::Column.new(
+                word_wrap: RubyJard::Column::WORD_WRAP_BREAK_WORD,
+                spans: loc_spans(loc)
+              )
+            ]
+          )
+        end
+        @selected = 0
       end
 
-      def span_mark(_loc, index)
+      def span_mark(index)
         lineno = source_lineno(index)
-        [
-          current_line == lineno ? '→' : ' ',
-          [:bright_yellow, current_line == lineno ? :bold : nil]
-        ]
+        RubyJard::Span.new(
+          margin_right: 1,
+          content: current_line == lineno ? '➠' : ' ',
+          styles: :source_line_mark
+        )
       end
 
-      def span_lineno(_loc, index)
-        lineno = source_lineno(index)
-        [
-          lineno.to_s,
-          current_line == lineno ? [:bold, :bright_yellow] : [:dim, :white]
-        ]
+      def span_lineno(index)
+        lineno = source_lineno(index).to_s.rjust(source_decorator.window_end.to_s.length)
+        RubyJard::Span.new(
+          content: lineno,
+          styles: current_line == lineno ? :source_line_mark : :source_lineno
+        )
       end
 
-      def span_code(loc, index)
-        lineno = source_lineno(index)
-        [loc_decorator(loc).spans, current_line == lineno ? [:brighter] : [:dim]]
+      def loc_spans(loc)
+        spans, _tokens = loc_decorator.decorate(loc, current_file)
+        spans
       end
 
       private
@@ -68,11 +84,11 @@ module RubyJard
       end
 
       def source_decorator
-        @source_decorator ||= RubyJard::Decorators::SourceDecorator.new(current_file, current_line, data_size)
+        @source_decorator ||= RubyJard::Decorators::SourceDecorator.new(current_file, current_line, @layout.height)
       end
 
-      def loc_decorator(loc)
-        RubyJard::Decorators::LocDecorator.new(current_file, loc)
+      def loc_decorator
+        @loc_decorator ||= RubyJard::Decorators::LocDecorator.new
       end
 
       def source_lineno(index)