ruby_jard 0.1.0

data/lib/ruby_jard/screens.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Screen registry. The screens call add_screen right after they are declared.
+  module Screens
+    class << self
+      def screen_registry
+        @screen_registry ||= {}
+      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
+
+        screen_registry[name] = screen_class
+      end
+
+      def [](name)
+        screen_registry[name]
+      end
+      alias get []
+    end
+  end
+end

data/lib/ruby_jard/screens/backtrace_screen.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    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
+
+          # 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
+      end
+
+      private
+
+      def data_size
+        @layout.height - 1
+      end
+
+      def frame_styles
+        default_frame_styles.merge(
+          top: @row, left: @col, width: @layout.width, height: @layout.height
+        )
+      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
+
+        backtrace[window_start..window_end]
+          .map
+          .with_index do |frame, frame_index|
+            decorate_frame(frame, window_start + frame_index, window_start, window_end)
+          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 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)
+      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)
+      end
+
+      def decorate_object_label(object, klass)
+        if klass.nil? || object.class == klass
+          if object.is_a?(Class)
+            object.name
+          else
+            object.class.name
+          end
+        elsif klass.singleton_class?
+          # No easy way to get the original class of a singleton class
+          object.name
+        else
+          klass.name
+        end
+      end
+
+      def decorate_method_label(location)
+        if location.label != location.base_label
+          "#{location.base_label} (#{location.label.split(' ').first})"
+        else
+          location.base_label
+        end
+      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 frame_pos
+        if @session.frame.nil?
+          0
+        else
+          @session.frame.pos.to_i
+        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)

data/lib/ruby_jard/screens/breakpoints_screen.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    class BreakpointsScreen < 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(' Breakpoints ', :bright_yellow)
+          .content
+      end
+    end
+  end
+end
+
+RubyJard::Screens.add_screen(:breakpoints, RubyJard::Screens::BreakpointsScreen)

data/lib/ruby_jard/screens/empty_screen.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    class EmptyScreen < RubyJard::Screen
+      def draw
+        # Do nothing
+      end
+    end
+  end
+end
+
+RubyJard::Screens.add_screen(:empty, RubyJard::Screens::EmptyScreen)

data/lib/ruby_jard/screens/expressions_sreen.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    class ExpressionsScreen < 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(' Expressions ', :bright_yellow)
+          .content
+      end
+    end
+  end
+end
+
+RubyJard::Screens.add_screen(:expressions, RubyJard::Screens::ExpressionsScreen)

data/lib/ruby_jard/screens/menu_screen.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    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
+
+        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
+      end
+
+      private
+
+      def generate_left_menu
+        [
+          decorate_text.with_highlight(true).text('Debug console (F5)', :bright_yellow),
+          decorate_text.text('Program output (F6)', :white)
+        ]
+      end
+
+      def generate_right_menu
+        [
+          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)
+        ]
+      end
+    end
+  end
+end
+
+RubyJard::Screens.add_screen(:menu, RubyJard::Screens::MenuScreen)

data/lib/ruby_jard/screens/source_screen.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    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
+        end
+      end
+
+      private
+
+      def data_size
+        @layout.height - 1
+      end
+
+      def decorate_codes
+        return [] if RubyJard.current_session.frame.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
+      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}"
+        end
+      end
+
+      def current_binding
+        RubyJard.current_session.frame._binding
+      end
+
+      def current_frame_scope
+        RubyJard.current_session.backtrace[RubyJard.current_session.frame.pos][1]
+      end
+
+      def current_file
+        RubyJard.current_session.frame.file
+      end
+
+      def current_line
+        RubyJard.current_session.frame.line
+      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
+
+        variables_text
+      end
+    end
+  end
+end
+
+RubyJard::Screens.add_screen(:source, RubyJard::Screens::SourceScreen)

data/lib/ruby_jard/screens/threads_screen.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Screens
+    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
+          )
+        )
+
+        decorated_threads = decorate_threads
+
+        @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
+
+        decorated_threads.each_with_index do |thread, index|
+          @output.print TTY::Cursor.move_to(@col + 1, @row + index + 1)
+          @output.print thread.content
+        end
+      end
+
+      private
+
+      def data_size
+        @layout.height - 1
+      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
+      end
+
+      def sort_contexts(contexts)
+        # Sort: current context first
+        # Sort: not debug context first
+        # Sort: not suspended context first
+        # Sort: sort by thread num
+        contexts.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(current_thread?(b)),
+            bool_to_int(a.ignored?),
+            bool_to_int(a.suspended?),
+            bool_to_int(a.thread.name.nil?),
+            b.thread.object_id
+          ]
+        end
+      end
+
+      def bool_to_int(bool)
+        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
+      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}"
+        else
+          context.thread.name
+        end
+      end
+    end
+  end
+end
+
+RubyJard::Screens.add_screen(:threads, RubyJard::Screens::ThreadsScreen)