ruby_jard 0.2.3 → 0.3.0

data/lib/ruby_jard/screen_renderer.rb

@@ -25,7 +25,7 @@ module RubyJard
     def calculate_content_lengths
       @screen.rows.each do |row|
         row.columns.each do |column|
-          column.content_length = column.spans.map(&:content_length).inject(&:+)
+          column.content_length = column.spans.map(&:content_length).inject(&:+) || 0
         end
       end
     end

data/lib/ruby_jard/screens/backtrace_screen.rb

@@ -5,18 +5,43 @@ module RubyJard
     ##
     # Backtrace screen implements the content to display current thread's backtrace to the user.
     class BacktraceScreen < RubyJard::Screen
+      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
+
+        @path_decorator = RubyJard::Decorators::PathDecorator.new
+      end
+
       def title
-        ['Backtrace', "#{frames_count} frames"]
+        if @hidden_frames_count <= 0
+          ['Backtrace', "#{@frames_count} frames"]
+        else
+          ['Backtrace', "#{@frames_count} frames - #{@hidden_frames_count} hidden"]
+        end
       end
 
       def build
-        @rows = @session.current_backtrace.map.with_index do |frame, frame_id|
+        @rows = @frames.map do |frame|
           RubyJard::Row.new(
             line_limit: 2,
             columns: [
               RubyJard::Column.new(
                 spans: [
-                  span_frame_id(frame_id)
+                  span_frame_pos(frame)
                 ]
               ),
               RubyJard::Column.new(
@@ -30,33 +55,38 @@ module RubyJard
             ]
           )
         end
-        @selected = current_frame
       end
 
       private
 
-      def span_frame_id(frame_id)
-        frame_id_label = frame_id.to_s.rjust(frames_count.to_s.length)
-        if current_frame?(frame_id)
+      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_id_label}",
-            styles: :frame_id_highlighted
+            content: "⮕ #{frame_pos_label}",
+            styles: :text_selected
           )
         else
           RubyJard::Span.new(
-            content: "  #{frame_id_label}",
-            styles: :frame_id
+            content: "  #{frame_pos_label}",
+            styles: :text_dim
           )
         end
       end
 
       def span_class_label(frame)
+        self_class = RubyJard::Reflection.call_class(frame.frame_self)
         class_label =
-          if frame.frame_class.nil? || frame.frame_self.class == frame.frame_class
-            if frame.frame_self.is_a?(Class)
+          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
-              frame.frame_self.class.name
+              self_class.name
             end
           elsif frame.frame_class.singleton_class?
             # No easy way to get the original class of a singleton class
@@ -77,7 +107,7 @@ module RubyJard
         RubyJard::Span.new(
           content: 'in',
           margin_right: 1,
-          styles: :frame_location
+          styles: :text_primary
         )
       end
 
@@ -96,39 +126,25 @@ module RubyJard
       end
 
       def span_path(frame)
-        decorated_path = decorate_path(frame.frame_location.absolute_path, frame.frame_location.lineno)
-
-        path_label =
-          if decorated_path.gem?
-            "in #{decorated_path.gem} (#{decorated_path.gem_version})"
-          else
-            "at #{decorated_path.path}:#{decorated_path.lineno}"
-          end
+        path_label, = @path_decorator.decorate(
+          frame.frame_location.path, frame.frame_location.lineno
+        )
         RubyJard::Span.new(
           content: path_label,
-          styles: :frame_location
+          styles: :text_primary
         )
       end
 
-      def current_frame?(frame_id)
-        frame_id == current_frame
-      end
+      def insert_current_frame
+        return if @current_frame.visible?
 
-      def current_frame
-        if @session.current_frame.nil?
-          0
+        index = @frames.find_index { |f| @current_frame.real_pos < f.real_pos }
+        if index.nil?
+          @frames << @current_frame
         else
-          @session.current_frame.pos.to_i
+          @frames.insert(index, @current_frame)
         end
       end
-
-      def frames_count
-        @session.current_backtrace.length
-      end
-
-      def decorate_path(path, lineno)
-        RubyJard::Decorators::PathDecorator.new(path, lineno)
-      end
     end
   end
 end

data/lib/ruby_jard/screens/menu_screen.rb

@@ -5,6 +5,14 @@ module RubyJard
     ##
     # Display key binding guidelines and shortcuts.
     class MenuScreen < RubyJard::Screen
+      def initialize(*args)
+        super(*args)
+        @filter = RubyJard.config.filter
+        @filter_included = RubyJard.config.filter_included
+        @filter_excluded = RubyJard.config.filter_excluded
+        @selected = 0
+      end
+
       def build
         left_spans = generate_left_spans
         right_spans = generate_right_spans
@@ -21,45 +29,37 @@ module RubyJard
             )
           ]
         )]
-        @selected = 0
       end
 
       private
 
       def generate_left_spans
-        [
-          RubyJard::Span.new(
-            content: ' REPL ',
-            styles: :title_highlighted
+        filter_mode_span = RubyJard::Span.new(
+          content: "Filter (F2): #{@filter.to_s.gsub(/_/, ' ').capitalize}",
+          styles: :text_special
+        )
+        filter_details =
+          @filter_included.map { |f| "+#{f}" } +
+          @filter_excluded.map { |f| "-#{f}" }
+        if filter_details.empty?
+          [filter_mode_span]
+        else
+          filter_exceprt = filter_details.first(3).join(' ')
+          filter_more = filter_details.length > 3 ? " (#{filter_details.length - 3} more...)" : nil
+          filter_details_span = RubyJard::Span.new(
+            content: "#{filter_exceprt}#{filter_more}",
+            styles: :text_primary,
+            margin_left: 1
           )
-        ]
-        # [
-        #   RubyJard::Span.new(
-        #     content: ' Mode (F2) ',
-        #     styles: :title_highlighted
-        #   ),
-        #   RubyJard::Span.new(
-        #     margin_left: 1,
-        #     content: 'All gems',
-        #     styles: :menu_mode
-        #   ),
-        #   RubyJard::Span.new(
-        #     margin_left: 1,
-        #     content: '|',
-        #     styles: :menu_tips
-        #   ),
-        #   RubyJard::Span.new(
-        #     margin_left: 1,
-        #     content: 'Application only',
-        #     styles: :menu_tips
-        #   )
-        # ]
+          [
+            filter_mode_span,
+            filter_details_span
+          ]
+        end
       end
 
       def generate_right_spans
         [
-          'Up (F6)',
-          'Down (Shift+F6)',
           'Step (F7)',
           'Step Out (Shift+F7)',
           'Next (F8)',
@@ -68,7 +68,7 @@ module RubyJard
           RubyJard::Span.new(
             content: menu_item,
             margin_left: 3,
-            styles: :menu_tips
+            styles: :text_primary
           )
         end
       end

data/lib/ruby_jard/screens/source_screen.rb

@@ -5,49 +5,50 @@ module RubyJard
     ##
     # Display source code of current stopping line and surrounding lines
     class SourceScreen < RubyJard::Screen
-      ANONYMOUS_SIGNATURES = [
-        '(eval)', '-e'
-      ].freeze
+      def initialize(*args)
+        super
+        @frame_file = @session.current_frame&.frame_file
+        @frame_line = @session.current_frame&.frame_line
+
+        if !@frame_file.nil? && !@frame_line.nil?
+          @path_decorator = RubyJard::Decorators::PathDecorator.new
+          @loc_decorator = RubyJard::Decorators::LocDecorator.new
+          @source_decorator = RubyJard::Decorators::SourceDecorator.new(@frame_file, @frame_line, @layout.height)
+        end
+
+        @selected = 0
+      end
 
       def title
-        return 'Source' if @session.current_frame.nil?
+        return 'Source' if @frame_file.nil? || @frame_line.nil?
 
-        decorated_path = path_decorator(@session.current_frame.frame_file, @session.current_frame.frame_line)
-        if decorated_path.gem?
-          ['Source', "#{decorated_path.gem} - #{decorated_path.path}:#{decorated_path.lineno}"]
-        else
-          ['Source', "#{decorated_path.path}:#{decorated_path.lineno}"]
-        end
+        _, path_label = @path_decorator.decorate(@frame_file, @frame_line)
+        ['Source', path_label]
       end
 
       def build
-        return if @session.current_frame.nil?
+        return 'Source' if @frame_file.nil? || @frame_line.nil?
 
-        if ANONYMOUS_SIGNATURES.include? @session.current_frame.frame_file
-          # (eval) is hard-coded in Ruby source code for in-code evaluation
-          handle_anonymous_evaluation
-        else
-          # 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
+        # TODO: screen now supports window.
+        codes = @source_decorator.codes
+        @rows = codes.map.with_index do |loc, index|
+          lineno = @source_decorator.window_start + index
+          RubyJard::Row.new(
+            line_limit: 3,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  span_mark(lineno),
+                  span_lineno(lineno)
+                ]
+              ),
+              RubyJard::Column.new(
+                word_wrap: RubyJard::Column::WORD_WRAP_BREAK_WORD,
+                spans: loc_spans(loc)
+              )
+            ]
+          )
         end
-        @selected = 0
       end
 
       private
@@ -83,44 +84,27 @@ module RubyJard
         ]
       end
 
-      def span_mark(index)
-        lineno = source_lineno(index)
+      def span_mark(lineno)
         RubyJard::Span.new(
           margin_right: 1,
-          content: @session.current_frame.frame_line == lineno ? '➠' : ' ',
-          styles: :source_line_mark
+          content: @frame_line == lineno ? '⮕' : ' ',
+          styles: :text_selected
         )
       end
 
-      def span_lineno(index)
-        lineno = source_lineno(index).to_s.rjust(source_decorator.window_end.to_s.length)
+      def span_lineno(lineno)
+        padded_lineno = lineno.to_s.rjust(@source_decorator.window_end.to_s.length)
         RubyJard::Span.new(
-          content: lineno,
-          styles: @session.current_frame.frame_line == lineno ? :source_line_mark : :source_lineno
+          content: padded_lineno,
+          styles: @frame_line == lineno ? :text_selected : :text_dim
         )
       end
 
       def loc_spans(loc)
-        spans, _tokens = loc_decorator.decorate(loc, @session.current_frame.frame_file)
-        spans
-      end
-
-      def path_decorator(path, lineno)
-        @path_decorator ||= RubyJard::Decorators::PathDecorator.new(path, lineno)
-      end
+        return [] if @frame_file.nil?
 
-      def source_decorator
-        @source_decorator ||= RubyJard::Decorators::SourceDecorator.new(
-          @session.current_frame.frame_file, @session.current_frame.frame_line, @layout.height
-        )
-      end
-
-      def loc_decorator
-        @loc_decorator ||= RubyJard::Decorators::LocDecorator.new
-      end
-
-      def source_lineno(index)
-        source_decorator.window_start + index
+        spans, _tokens = @loc_decorator.decorate(loc, @frame_file)
+        spans
       end
     end
   end

data/lib/ruby_jard/screens/threads_screen.rb

@@ -5,122 +5,116 @@ module RubyJard
     ##
     # Display all current alive threads, excluding internal threads
     class ThreadsScreen < RubyJard::Screen
+      def initialize(*args)
+        super
+        @current_frame_location = @session.current_frame&.frame_location
+        @current_thread = @session.current_thread
+        @threads = @session.threads
+
+        @selected = @threads.index { |c| current_thread?(c) }
+        @path_decorator = RubyJard::Decorators::PathDecorator.new
+      end
+
       def title
-        ['Threads', "#{@session.threads.length} threads"]
+        ['Threads', "#{@threads.length} threads"]
       end
 
       def build
-        contexts = @session.threads.select { |c| c.thread.alive? }
-        contexts = sort_contexts(contexts)
-        @rows = contexts.map do |context|
+        threads = sort_threads(@threads)
+        @rows = threads.map do |thread|
           RubyJard::Row.new(
             line_limit: 2,
             columns: [
               RubyJard::Column.new(
                 spans: [
-                  span_mark(context),
-                  span_thread_id(context)
+                  span_mark(thread),
+                  span_thread_label(thread)
                 ]
               ),
               RubyJard::Column.new(
                 spans: [
-                  span_thread_status(context)
+                  span_thread_status(thread)
                 ]
               ),
               RubyJard::Column.new(
                 spans: [
-                  span_thread_name(context),
-                  span_thread_location(context)
+                  span_thread_name(thread),
+                  span_thread_location(thread)
                 ]
               )
             ]
           )
         end
-        @selected = contexts.index { |c| current_thread?(c) }
       end
 
       private
 
-      def span_mark(context)
-        style = thread_status_style(context.thread)
+      def span_mark(thread)
         RubyJard::Span.new(
           margin_right: 1,
-          content: style == :thread_status_run ? '►' : '•',
-          styles: style
+          content: thread.status == 'run' ? '▸' : '•',
+          styles: thread_status_style(thread)
         )
       end
 
-      def span_thread_id(context)
+      def span_thread_label(thread)
         RubyJard::Span.new(
-          content: "Thread #{context.thread.object_id}",
-          styles: :thread_id
+          content: "Thread #{thread.label}",
+          styles: :text_highlighted
         )
       end
 
-      def span_thread_status(context)
+      def span_thread_status(thread)
         RubyJard::Span.new(
-          content: "(#{context.thread.status})",
-          styles: thread_status_style(context.thread)
+          content: "(#{thread.status})",
+          styles: thread_status_style(thread)
         )
       end
 
-      def span_thread_name(context)
+      def span_thread_name(thread)
         RubyJard::Span.new(
           margin_right: 1,
-          content: context.thread.name.nil? ? 'untitled' : context.thread.name,
-          styles: :thread_name
+          content: thread.name.nil? ? 'untitled' : thread.name,
+          styles: :text_primary
         )
       end
 
-      def span_thread_location(context)
-        return unknown_thread_location if
-          context.thread.backtrace_locations.nil? ||
-          @session.current_frame.frame_location.nil?
-
-        last_backtrace =
-          if current_thread?(context)
-            @session.current_frame.frame_location
+      def span_thread_location(thread)
+        path_label, =
+          if current_thread?(thread)
+            @path_decorator.decorate(
+              @current_frame_location.path,
+              @current_frame_location.lineno
+            )
           else
-            context.thread.backtrace_locations[1]
+            @path_decorator.decorate(
+              thread.backtrace_locations[1]&.path,
+              thread.backtrace_locations[1]&.lineno
+            )
           end
 
-        return unknown_thread_location if last_backtrace.nil?
-
-        decorated_path = decorate_path(last_backtrace.path, last_backtrace.lineno)
-        if decorated_path.gem?
-          RubyJard::Span.new(
-            content: "in #{decorated_path.gem} (#{decorated_path.gem_version})",
-            styles: :thread_location
-          )
-        else
-          RubyJard::Span.new(
-            content: "at #{decorated_path.path}:#{decorated_path.lineno}",
-            styles: :thread_location
-          )
-        end
-      end
-
-      def unknown_thread_location
         RubyJard::Span.new(
-          content: 'at ???',
-          styles: :thread_location
+          content: path_label,
+          styles: :text_primary
         )
       end
 
-      def sort_contexts(contexts)
-        # Sort: current context first
-        # Sort: not debug context first
-        # Sort: not suspended context first
+      def sort_threads(threads)
+        # Sort: current thread first
+        # Sort: not debug thread first
+        # Sort: not suspended thread first
         # Sort: sort by thread num
-        contexts.sort do |a, b|
+        threads.sort do |a, b|
           [
             bool_to_int(current_thread?(a)),
-            bool_to_int(b.thread.name.nil?),
-            a.thread.object_id
+            bool_to_int(b.name.nil?),
+            a.name,
+            a.backtrace_locations[0].to_s
           ] <=> [
             bool_to_int(current_thread?(b)),
-            bool_to_int(a.thread.name.nil?),
-            b.thread.object_id
+            bool_to_int(a.name.nil?),
+            b.name,
+            b.backtrace_locations[0].to_s
           ]
         end
       end
@@ -129,22 +123,15 @@ module RubyJard
         bool == true ? -1 : 1
       end
 
-      def current_thread?(context)
-        context.thread == Thread.current
-      end
-
-      def decorate_path(path, lineno)
-        RubyJard::Decorators::PathDecorator.new(path, lineno)
+      def current_thread?(thread)
+        thread == @current_thread
       end
 
       def thread_status_style(thread)
-        case thread.status
-        when 'run'
-          :thread_status_run
-        when 'sleep'
-          :thread_status_sleep
+        if thread.status == 'run'
+          :text_selected
         else
-          :thread_status_other
+          :text_dim
         end
       end
     end