ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/screens/menu_screen.rb

@@ -1,62 +1,90 @@
 # frozen_string_literal: true
 
 module RubyJard
-  module Screens
+  class Screens
+    ##
+    # Display key binding guidelines and shortcuts.
     class MenuScreen < RubyJard::Screen
-      def draw
-        @output.print TTY::Cursor.move_to(@col, @row)
-        frame = TTY::Box.frame(
-          **default_frame_styles.merge(
-            top: @row, left: @col, width: @layout.width, height: @layout.height,
-            border: {
-              left: false,
-              top: :line,
-              right: false,
-              bottom: false
-            },
-            style: {
-              fg: :white
-            }
-          )
-        )
-        @output.print frame
-
-        margin = 0
-        left_menu = generate_left_menu
-        left_menu.each do |item|
-          @output.print TTY::Cursor.move_to(@col + 1 + margin, @row + 1)
-          @output.print item.content
-          margin += item.length + 3
-        end
+      def initialize(*args)
+        super(*args)
+        @filter = RubyJard.config.filter
+        @filter_included = RubyJard.config.filter_included
+        @filter_excluded = RubyJard.config.filter_excluded
+        @selected = 0
+      end
 
-        margin = 0
-        right_menu = generate_right_menu
-        right_menu.reverse.each do |item|
-          @output.print TTY::Cursor.move_to(@col + @layout.width - margin - item.length - 1, @row + 1)
-          @output.print item.content
-          margin += item.length + 3
-        end
+      def build
+        left_spans = generate_left_spans
+        right_spans = generate_right_spans
+        @rows = [RubyJard::Row.new(
+          line_limit: 1,
+          columns: [
+            RubyJard::Column.new(
+              word_wrap: RubyJard::Column::WORD_WRAP_BREAK_WORD,
+              spans: [
+                left_spans,
+                align(left_spans, right_spans),
+                right_spans
+              ].flatten
+            )
+          ]
+        )]
       end
 
       private
 
-      def generate_left_menu
-        [
-          decorate_text.with_highlight(true).text('Debug console (F5)', :bright_yellow),
-          decorate_text.text('Program output (F6)', :white)
-        ]
+      def generate_left_spans
+        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
+          )
+          [
+            filter_mode_span,
+            filter_details_span
+          ]
+        end
       end
 
-      def generate_right_menu
+      def generate_right_spans
         [
-          decorate_text.text('Step (F7)', :white),
-          decorate_text.text('Next (F8)', :white),
-          decorate_text.text('Step out (Shift+F8)', :white),
-          decorate_text.text('Continue (F9)', :white)
-        ]
+          'Step (F7)',
+          'Step Out (Shift+F7)',
+          'Next (F8)',
+          'Continue (F9)'
+        ].map do |menu_item|
+          RubyJard::Span.new(
+            content: menu_item,
+            margin_left: 3,
+            styles: :text_primary
+          )
+        end
+      end
+
+      def align(left_spans, right_spans)
+        alignment =
+          @layout.width -
+          right_spans.map(&:content_length).sum -
+          left_spans.map(&:content_length).sum
+        RubyJard::Span.new(
+          content: ' ' * (alignment < 0 ? 0 : alignment),
+          styles: :background
+        )
       end
     end
   end
 end
 
-RubyJard::Screens.add_screen(:menu, RubyJard::Screens::MenuScreen)
+RubyJard::Screens.add_screen('menu', RubyJard::Screens::MenuScreen)

data/lib/ruby_jard/screens/source_screen.rb

@@ -1,133 +1,113 @@
 # frozen_string_literal: true
 
 module RubyJard
-  module Screens
+  class Screens
+    ##
+    # Display source code of current stopping line and surrounding lines
     class SourceScreen < RubyJard::Screen
-      def draw
-        @output.print TTY::Box.frame(
-          **default_frame_styles.merge(
-            top: @row, left: @col, width: @layout.width, height: @layout.height
-          )
-        )
-
-        @output.print TTY::Cursor.move_to(@col + 2, @row)
-        @output.print decorate_text
-          .with_highlight(true)
-          .text(' Source', :bright_yellow)
-          .text(' (', :bright_yellow)
-          .text(file_path, :bright_yellow)
-          .text(') ', :bright_yellow)
-          .content
-
-        decorate_codes.each_with_index do |decorated_loc, index|
-          @output.print TTY::Cursor.move_to(@col + 1, @row + 1 + index)
-          @output.print decorated_loc.content
+      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
-      end
-
-      private
 
-      def data_size
-        @layout.height - 1
+        @selected = 0
       end
 
-      def decorate_codes
-        return [] if RubyJard.current_session.frame.nil?
+      def title
+        return 'Source' if @frame_file.nil? || @frame_line.nil?
 
-        decorated_source = decorate_source(current_file, current_line, data_size)
-
-        lineno_padding = decorated_source.window_end.to_s.length
-
-        decorated_source.codes.map.with_index do |loc, index|
-          lineno = decorated_source.window_start + index
-          decorated_loc = decorate_loc(loc, current_line == lineno)
-
-          if current_line == lineno
-            decorate_text
-              .with_highlight(true)
-              .text('→ ')
-              .text(lineno.to_s.ljust(lineno_padding), :bright_yellow)
-              .text(' ')
-              .text(decorated_loc.loc)
-              .text(inline_variables(decorated_loc.tokens))
-          else
-            decorate_text
-              .with_highlight(false)
-              .text('  ')
-              .text(lineno.to_s.ljust(lineno_padding), :white)
-              .text(' ')
-              .text(decorated_loc.loc)
-          end
-        end
+        _, path_label = @path_decorator.decorate(@frame_file, @frame_line)
+        ['Source', path_label]
       end
 
-      def file_path
-        return '' if RubyJard.current_session.frame.nil?
-
-        decorated_path = decorate_path(current_file, current_line)
-        if decorated_path.gem?
-          "#{decorated_path.gem}: #{decorated_path.path}:#{decorated_path.lineno}"
-        else
-          "#{decorated_path.path}:#{decorated_path.lineno}"
+      def build
+        return 'Source' if @frame_file.nil? || @frame_line.nil?
+
+        # 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
       end
 
-      def current_binding
-        RubyJard.current_session.frame._binding
-      end
+      private
 
-      def current_frame_scope
-        RubyJard.current_session.backtrace[RubyJard.current_session.frame.pos][1]
+      def handle_anonymous_evaluation
+        @rows = [
+          RubyJard::Row.new(
+            line_limit: 3,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  RubyJard::Span.new(
+                    content: 'This section is anonymous!',
+                    styles: :normal_token
+                  )
+                ]
+              )
+            ]
+          ),
+          RubyJard::Row.new(
+            line_limit: 3,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  RubyJard::Span.new(
+                    content: 'Maybe it is dynamically evaluated, or called via ruby-e, without file information.',
+                    styles: :source_lineno
+                  )
+                ]
+              )
+            ]
+          )
+        ]
       end
 
-      def current_file
-        RubyJard.current_session.frame.file
+      def span_mark(lineno)
+        RubyJard::Span.new(
+          margin_right: 1,
+          content: @frame_line == lineno ? '⮕' : ' ',
+          styles: :text_selected
+        )
       end
 
-      def current_line
-        RubyJard.current_session.frame.line
+      def span_lineno(lineno)
+        padded_lineno = lineno.to_s.rjust(@source_decorator.window_end.to_s.length)
+        RubyJard::Span.new(
+          content: padded_lineno,
+          styles: @frame_line == lineno ? :text_selected : :text_dim
+        )
       end
 
-      def inline_variables(tokens)
-        variables = {}
-        local_variables = current_binding.local_variables
-        instance_variables = current_frame_scope.instance_variables
-
-        tokens.each_slice(2).each do |token, kind|
-          token = token.to_sym
-
-          if kind == :ident && local_variables.include?(token)
-            var = current_binding.local_variable_get(token)
-          elsif kind == :instance_variable && instance_variables.include?(token)
-            var = current_frame_scope.instance_variable_get(token)
-          else
-            next
-          end
-
-          next if variables.key?(token)
-
-          var_inspect = var.inspect
-          # TODO: dynamic fill the rest of the line instead
-          variables[token] = var_inspect if var_inspect.length < 30
-        end
-
-        return '' if variables.empty?
-
-        variables_text = decorate_text.with_highlight(false).text('   #→ ', :white)
-        variables.to_a.each_with_index do |(var_name, var_inspect), index|
-          variables_text
-            .with_highlight(false)
-            .text(var_name.to_s, :white)
-            .text('=', :white)
-            .text(var_inspect, :white)
-
-          variables_text.with_highlight(false).text(', ', :white) if index != variables.length - 1
-        end
+      def loc_spans(loc)
+        return [] if @frame_file.nil?
 
-        variables_text
+        spans, _tokens = @loc_decorator.decorate(loc, @frame_file)
+        spans
       end
     end
   end
 end
 
-RubyJard::Screens.add_screen(:source, RubyJard::Screens::SourceScreen)
+RubyJard::Screens.add_screen('source', RubyJard::Screens::SourceScreen)

data/lib/ruby_jard/screens/threads_screen.rb

@@ -1,68 +1,120 @@
 # frozen_string_literal: true
 
 module RubyJard
-  module Screens
+  class Screens
+    ##
+    # Display all current alive threads, excluding internal threads
     class ThreadsScreen < RubyJard::Screen
-      def draw
-        @output.print TTY::Box.frame(
-          **default_frame_styles.merge(
-            top: @row, left: @col, width: @layout.width, height: @layout.height
-          )
-        )
+      def initialize(*args)
+        super
+        @current_frame_location = @session.current_frame&.frame_location
+        @current_thread = @session.current_thread
+        @threads = @session.threads
 
-        decorated_threads = decorate_threads
+        @selected = @threads.index { |c| current_thread?(c) }
+        @path_decorator = RubyJard::Decorators::PathDecorator.new
+      end
 
-        @output.print TTY::Cursor.move_to(@col + 1, @row)
-        @output.print decorate_text
-          .with_highlight(true)
-          .text(" Threads (#{RubyJard.current_session.contexts.length}) ", :bright_yellow)
-          .content
+      def title
+        ['Threads', "#{@threads.length} threads"]
+      end
 
-        decorated_threads.each_with_index do |thread, index|
-          @output.print TTY::Cursor.move_to(@col + 1, @row + index + 1)
-          @output.print thread.content
+      def build
+        threads = sort_threads(@threads)
+        @rows = threads.map do |thread|
+          RubyJard::Row.new(
+            line_limit: 2,
+            columns: [
+              RubyJard::Column.new(
+                spans: [
+                  span_mark(thread),
+                  span_thread_label(thread)
+                ]
+              ),
+              RubyJard::Column.new(
+                spans: [
+                  span_thread_status(thread)
+                ]
+              ),
+              RubyJard::Column.new(
+                spans: [
+                  span_thread_name(thread),
+                  span_thread_location(thread)
+                ]
+              )
+            ]
+          )
         end
       end
 
       private
 
-      def data_size
-        @layout.height - 1
+      def span_mark(thread)
+        RubyJard::Span.new(
+          margin_right: 1,
+          content: thread.status == 'run' ? '▸' : '•',
+          styles: thread_status_style(thread)
+        )
       end
 
-      def decorate_threads
-        contexts = sort_contexts(RubyJard.current_session.contexts)
-        num_padding = contexts.length.to_s.length
-        contexts.first(data_size).map do |context|
-          decorate_text
-            .with_highlight(current_thread?(context))
-            .text(current_thread?(context) ? '→ ' : '  ', :bright_white)
-            .text(context_color(context, "T#{context.thread.object_id}"))
-            .with_highlight(false)
-            .text(" (#{context.thread.status}) ", :white)
-            .with_highlight(current_thread?(context))
-            .text(thread_name(context), :bright_white)
-        end
+      def span_thread_label(thread)
+        RubyJard::Span.new(
+          content: "Thread #{thread.label}",
+          styles: :text_highlighted
+        )
+      end
+
+      def span_thread_status(thread)
+        RubyJard::Span.new(
+          content: "(#{thread.status})",
+          styles: thread_status_style(thread)
+        )
       end
 
-      def sort_contexts(contexts)
-        # Sort: current context first
-        # Sort: not debug context first
-        # Sort: not suspended context first
+      def span_thread_name(thread)
+        RubyJard::Span.new(
+          margin_right: 1,
+          content: thread.name.nil? ? 'untitled' : thread.name,
+          styles: :text_primary
+        )
+      end
+
+      def span_thread_location(thread)
+        path_label, =
+          if current_thread?(thread)
+            @path_decorator.decorate(
+              @current_frame_location.path,
+              @current_frame_location.lineno
+            )
+          else
+            @path_decorator.decorate(
+              thread.backtrace_locations[1]&.path,
+              thread.backtrace_locations[1]&.lineno
+            )
+          end
+
+        RubyJard::Span.new(
+          content: path_label,
+          styles: :text_primary
+        )
+      end
+
+      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.ignored?),
-            bool_to_int(b.suspended?),
-            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.ignored?),
-            bool_to_int(a.suspended?),
-            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
@@ -71,46 +123,19 @@ module RubyJard
         bool == true ? -1 : 1
       end
 
-      def current_thread?(context)
-        context.thread == Thread.current
-      end
-
-      def context_color(context, text)
-        if current_thread?(context)
-          decorate_text
-            .with_highlight(true)
-            .text(text, :bright_yellow)
-        elsif context.suspended?
-          decorate_text
-            .with_highlight(false)
-            .text(text, :red)
-        elsif context.ignored?
-          decorate_text
-            .with_highlight(false)
-            .text(text, :white)
-        else
-          decorate_text
-            .with_highlight(false)
-            .text(text, :bright_white)
-        end
+      def current_thread?(thread)
+        thread == @current_thread
       end
 
-      def thread_name(context)
-        if context.thread.name.nil?
-          last_backtrace =
-            if context == RubyJard.current_session.current_context
-              context.backtrace[0][0]
-            else
-              context.thread.backtrace_locations[0]
-            end
-          location = decorate_path(last_backtrace.path, last_backtrace.lineno)
-          "#{location.path}:#{location.lineno}"
+      def thread_status_style(thread)
+        if thread.status == 'run'
+          :text_selected
         else
-          context.thread.name
+          :text_dim
         end
       end
     end
   end
 end
 
-RubyJard::Screens.add_screen(:threads, RubyJard::Screens::ThreadsScreen)
+RubyJard::Screens.add_screen('threads', RubyJard::Screens::ThreadsScreen)