ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/screen_renderer.rb

@@ -0,0 +1,152 @@
+# 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
+      # Move this logic into a class called SreenRenderer
+      calculate_content_lengths
+      column_widths = calculate_column_widths
+      adjust_column_widths(column_widths)
+      calculate_window
+
+      @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(&:+) || 0
+        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 = count_dynamic_columns(column_widths)
+      fixed_width = sum_fixed_width(column_widths)
+
+      @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
+          column.content_width = column.width
+          column.content_width -= 1 if column_index < row.columns.length - 1
+
+          total_width += column.width
+        end
+      end
+    end
+
+    def count_dynamic_columns(column_widths)
+      column_widths.values.select(&:nil?).length
+    end
+
+    def sum_fixed_width(column_widths)
+      column_widths.values.inject(0) do |sum, col|
+        col.nil? ? sum : sum + col
+      end
+    end
+
+    def render_rows
+      @screen.rows.each do |row|
+      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(row).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(row).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
+
+    def row_content(row)
+      unless row.rendered?
+        RubyJard::RowRenderer.new(
+          row: row,
+          width: @screen.layout.width,
+          height: @screen.layout.height,
+          color_scheme: @color_scheme
+        ).render
+      end
+
+      row.content
+    end
+  end
+end

data/lib/ruby_jard/screens.rb

@@ -1,26 +1,45 @@
 # frozen_string_literal: true
 
+require 'ruby_jard/screen'
+
 module RubyJard
   ##
   # Screen registry. The screens call add_screen right after they are declared.
-  module Screens
+  class Screens
     class << self
-      def screen_registry
-        @screen_registry ||= {}
+      extend Forwardable
+      def_delegators :instance, :add_screen, :[], :get, :names
+
+      def instance
+        @instance ||= new
       end
+    end
 
-      def add_screen(name, screen_class)
-        unless screen_class < RubyJard::Screen
-          raise RubyJard::Error, "#{screen_class} must implement, and inherit from #{RubyJard::Screen}"
-        end
+    def initialize
+      @screen_registry = {}
+    end
 
-        screen_registry[name] = screen_class
+    def add_screen(name, screen_class)
+      unless screen_class < RubyJard::Screen
+        raise RubyJard::Error, "#{screen_class} must implement, and inherit from #{RubyJard::Screen}"
       end
 
-      def [](name)
-        screen_registry[name]
-      end
-      alias get []
+      @screen_registry[name.to_s] = screen_class
+    end
+
+    def [](name)
+      @screen_registry[name.to_s]
+    end
+    alias_method :get, :[]
+
+    def names
+      @screen_registry.keys.sort.dup
     end
   end
 end
+
+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'

data/lib/ruby_jard/screens/backtrace_screen.rb

@@ -1,150 +1,152 @@
 # frozen_string_literal: true
 
 module RubyJard
-  module Screens
+  class Screens
+    ##
+    # Backtrace screen implements the content to display current thread's backtrace to the user.
     class BacktraceScreen < RubyJard::Screen
-      def draw
-        @output.print TTY::Box.frame(**frame_styles)
-
-        @output.print TTY::Cursor.move_to(@col + 2, @row)
-        @output.print decorate_text
-          .with_highlight(true)
-          .text(" Backtrace (#{frames_count}) ", :bright_yellow)
-          .content
-
-        decorate_frames.each_with_index do |frame_texts, index|
-          left, right = frame_texts
-          @output.print TTY::Cursor.move_to(@col + 1, @row + index + 1)
-          @output.print left.content
-
-          next unless @col + left.length < @col + @layout.width - right.length - 1
+      def initialize(*args)
+        super(*args)
+        @current_frame = @session.current_frame
+        @frames =
+          @session
+          .current_backtrace
+          .select(&:visible?)
+          .sort { |a, b| a.virtual_pos.to_i <=> b.virtual_pos.to_i }
+        insert_current_frame
+        @selected =
+          if @current_frame.nil?
+            0
+          else
+            @frames.find_index { |f| f.real_pos == @current_frame.real_pos }
+          end
+        @frames_count = @frames.length
+        @hidden_frames_count = @session.current_backtrace.length - @frames.length
 
-          # TODO: handle reducable components in case of smaller screen
-          @output.print TTY::Cursor.move_to(@col + @layout.width - right.length, @row + index + 1)
-          @output.print right.content
-        end
+        @path_decorator = RubyJard::Decorators::PathDecorator.new
       end
 
-      private
-
-      def data_size
-        @layout.height - 1
+      def title
+        if @hidden_frames_count <= 0
+          ['Backtrace', "#{@frames_count} frames"]
+        else
+          ['Backtrace', "#{@frames_count} frames - #{@hidden_frames_count} hidden"]
+        end
       end
 
-      def frame_styles
-        default_frame_styles.merge(
-          top: @row, left: @col, width: @layout.width, height: @layout.height
-        )
+      def build
+        @rows = @frames.map do |frame|
+          RubyJard::Row.new(
+            line_limit: 2,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  span_frame_pos(frame)
+                ]
+              ),
+              RubyJard::Column.new(
+                spans: [
+                  span_class_label(frame),
+                  span_label_preposition,
+                  span_method_label(frame),
+                  span_path(frame)
+                ]
+              )
+            ]
+          )
+        end
       end
 
-      def decorate_frames
-        return [] if data_size.zero?
-
-        window_start = frame_pos / data_size * data_size
-        window_end = [frames_count, window_start + data_size - 1].min
+      private
 
-        backtrace[window_start..window_end]
-          .map
-          .with_index do |frame, frame_index|
-            decorate_frame(frame, window_start + frame_index, window_start, window_end)
+      def span_frame_pos(frame)
+        frame_pos_label =
+          if frame.hidden?
+            '*'.rjust(@frames_count.to_s.length)
+          else
+            frame.virtual_pos.to_s.rjust(@frames_count.to_s.length)
           end
+        if frame.real_pos == @current_frame.real_pos
+          RubyJard::Span.new(
+            content: "⮕ #{frame_pos_label}",
+            styles: :text_selected
+          )
+        else
+          RubyJard::Span.new(
+            content: "  #{frame_pos_label}",
+            styles: :text_dim
+          )
+        end
       end
 
-      def decorate_frame(line, frame_id, window_start, window_end)
-        location = line[0]
-        object = line[1]
-        klass = line[2]
-
-        left =
-          decorate_frame_id(frame_id, window_start, window_end) +
-          ' ' +
-          decorate_location_label(frame_id, location, object, klass)
-        right = decorate_location_path(frame_id, location)
-
-        [left, right]
-      end
-
-      def reset
-        @color = Pastel.new
-      end
+      def span_class_label(frame)
+        self_class = RubyJard::Reflection.call_class(frame.frame_self)
+        class_label =
+          if frame.frame_class.nil? || self_class == frame.frame_class
+            if ::RubyJard::Reflection.call_is_a?(frame.frame_self, Class)
+              frame.frame_self.name
+            else
+              self_class.name
+            end
+          elsif frame.frame_class.singleton_class?
+            # No easy way to get the original class of a singleton class
+            frame.frame_self.respond_to?(:name) ? frame.frame_self.name : frame.frame_self.to_s
+          else
+            frame.frame_class.name
+          end
 
-      def decorate_frame_id(frame_id, _window_start, window_end)
-        decorate_text
-          .with_highlight(frame_pos == frame_id)
-          .text(frame_pos == frame_id ? '→ ' : '  ', :white)
-          .text(frame_id.to_s.ljust(window_end.to_s.length), frame_pos == frame_id ? :bright_yellow : :white)
+        c_frame = frame.c_frame? ? '[c] ' : ''
+        RubyJard::Span.new(
+          content: "#{c_frame}#{class_label}",
+          margin_right: 1,
+          styles: :constant
+        )
       end
 
-      def decorate_location_label(frame_id, location, object, klass)
-        decorate_text
-          .with_highlight(frame_pos == frame_id)
-          .text(backtrace[frame_id].last.nil? ? '[c] ' : '', :green)
-          .text(decorate_object_label(object, klass), :green)
-          .text(' in ', :white)
-          .text(decorate_method_label(location), :green)
+      def span_label_preposition
+        RubyJard::Span.new(
+          content: 'in',
+          margin_right: 1,
+          styles: :text_primary
+        )
       end
 
-      def decorate_object_label(object, klass)
-        if klass.nil? || object.class == klass
-          if object.is_a?(Class)
-            object.name
+      def span_method_label(frame)
+        method_label =
+          if frame.frame_location.label != frame.frame_location.base_label
+            "#{frame.frame_location.base_label} (#{frame.frame_location.label.split(' ').first})"
           else
-            object.class.name
+            frame.frame_location.base_label
           end
-        elsif klass.singleton_class?
-          # No easy way to get the original class of a singleton class
-          object.name
-        else
-          klass.name
-        end
+        RubyJard::Span.new(
+          content: method_label,
+          margin_right: 1,
+          styles: :method
+        )
       end
 
-      def decorate_method_label(location)
-        if location.label != location.base_label
-          "#{location.base_label} (#{location.label.split(' ').first})"
-        else
-          location.base_label
-        end
+      def span_path(frame)
+        path_label, = @path_decorator.decorate(
+          frame.frame_location.path, frame.frame_location.lineno
+        )
+        RubyJard::Span.new(
+          content: path_label,
+          styles: :text_primary
+        )
       end
 
-      def decorate_location_path(frame_id, location)
-        decorated_path = decorate_path(location.absolute_path, location.lineno)
-
-        if decorated_path.gem?
-          decorate_text
-            .with_highlight(frame_pos == frame_id)
-            .text('in ', :bright_white)
-            .text(decorated_path.gem, :bright_white)
-            .text(' (', :bright_white)
-            .text(decorated_path.gem_version, :bright_white)
-            .text(')', :bright_white)
-        else
-          decorate_text
-            .with_highlight(frame_pos == frame_id)
-            .text('at ', :bright_white)
-            .text(decorated_path.path, :bright_white)
-            .text(':', :bright_white)
-            .text(decorated_path.lineno, :bright_white)
-        end
-      end
+      def insert_current_frame
+        return if @current_frame.visible?
 
-      def frame_pos
-        if @session.frame.nil?
-          0
+        index = @frames.find_index { |f| @current_frame.real_pos < f.real_pos }
+        if index.nil?
+          @frames << @current_frame
         else
-          @session.frame.pos.to_i
+          @frames.insert(index, @current_frame)
         end
       end
-
-      def frames_count
-        @session.backtrace.length
-      end
-
-      def backtrace
-        @session.backtrace
-      end
     end
   end
 end
 
-RubyJard::Screens.add_screen(:backtrace, RubyJard::Screens::BacktraceScreen)
+RubyJard::Screens.add_screen('backtrace', RubyJard::Screens::BacktraceScreen)