ruby_jard 0.1.0 → 0.2.0

data/lib/ruby_jard/screens/threads_screen.rb

@@ -3,48 +3,65 @@
 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
-          )
-        )
+      def title
+        "Threads (#{RubyJard.current_session.contexts.length})"
+      end
 
-        decorated_threads = decorate_threads
+      def data_size
+        [@height, RubyJard.current_session.contexts.length].min
+      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 data_window
+        return @data_window if defined?(@data_window)
 
-        decorated_threads.each_with_index do |thread, index|
-          @output.print TTY::Cursor.move_to(@col + 1, @row + index + 1)
-          @output.print thread.content
-        end
+        contexts = RubyJard.current_session.contexts.filter { |c| c.thread.alive? }
+        @data_window ||= sort_contexts(contexts).first(data_size)
       end
 
-      private
+      def span_mark(context, _index)
+        [
+          current_thread?(context) ? '→' : ' ',
+          [:bright_yellow, current_thread?(context) ? :bold : nil]
+        ]
+      end
 
-      def data_size
-        @layout.height - 1
+      def span_thread_id(context, _index)
+        [
+          context.thread.object_id.to_s,
+          [:green, current_thread?(context) ? :bold : nil]
+        ]
+      end
+
+      def span_thread_status(context, _index)
+        status_color =
+          if context.suspended?
+            :red
+          elsif context.ignored?
+            :white
+          elsif context.thread.status == 'run'
+            :green
+          else
+            :white
+          end
+        [
+          "(#{context.thread.status})",
+          [status_color, current_thread?(context) ? :bold : nil]
+        ]
       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)
+      def span_thread_name(context, _index)
+        if context.thread.name.nil?
+          last_backtrace = context.thread.backtrace_locations[1]
+          location = decorate_path(last_backtrace.path, last_backtrace.lineno)
+          ["#{location.path}:#{location.lineno}", current_thread?(context) ? [:bright_white, :bold] : :white]
+        else
+          name = context.thread.name.to_s
+          [name, current_thread?(context) ? [:bright_white, :bold] : :white]
         end
       end
 
+      private
+
       def sort_contexts(contexts)
         # Sort: current context first
         # Sort: not debug context first
@@ -75,39 +92,8 @@ module RubyJard
         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
+      def decorate_path(path, lineno)
+        RubyJard::Decorators::PathDecorator.new(path, lineno)
       end
     end
   end

data/lib/ruby_jard/screens/variables_screen.rb

@@ -18,13 +18,11 @@ module RubyJard
         [].class => :arr,
         {}.class => :hash,
         //.class => :reg,
+        (0..0).class => :rng,
         Class => :cls # Sorry, I lied, Class will never change
       }.freeze
-      TYPE_SYMBOL_PADDING = TYPE_SYMBOLS.map { |_, s| s.to_s.length }.max + 1
       DEFAULT_TYPE_SYMBOL = :var
 
-      INSPECTION_ELLIPSIS = ' [...]'
-
       KINDS = [
         KIND_LOC = :loc,
         KIND_INS = :ins,
@@ -38,36 +36,85 @@ module RubyJard
       }.freeze
 
       KIND_COLORS = {
-        KIND_LOC => :yellow,
-        KIND_INS => :blue,
+        KIND_LOC => :bright_blue,
+        KIND_INS => :bright_blue,
         KIND_CON => :green
       }.freeze
 
-      def draw
-        @output.print TTY::Box.frame(
-          **default_frame_styles.merge(
-            top: @row, left: @col, width: @layout.width, height: @layout.height
-          )
-        )
+      INLINE_TOKEN_KIND_MAPS = {
+        KIND_LOC => :ident,
+        KIND_INS => :instance_variable,
+        KIND_CON => :constant
+      }.freeze
+      INLINE_TOKEN_KINDS = INLINE_TOKEN_KIND_MAPS.values
+
+      def title
+        'Variables'
+      end
 
-        @output.print TTY::Cursor.move_to(@col + 1, @row)
-        @output.print decorate_text
-          .with_highlight(true)
-          .text('Variables ', :bright_yellow)
-          .content
+      def data_size
+        @height
+      end
+
+      def data_window
+        return [] if current_frame.nil?
+        return @data_window if defined?(@data_window)
 
-        decorated_variables.first(data_size).each_with_index do |variable, index|
-          @output.print TTY::Cursor.move_to(@col + 1, @row + index + 1)
-          @output.print variable.content
+        variables = fetch_local_variables + fetch_instance_variables + fetch_constants
+        # Each row is an array of [kind, name, value]
+        @data_window = sort_variables(variables).first(data_size)
+      end
+
+      def span_inline(data_row, _index)
+        if inline?(data_row[0], data_row[1])
+          ['•', [:bright_yellow, :bold]]
+        else
+          [' ']
         end
       end
 
-      private
+      def span_type(data_row, _index)
+        type_name = TYPE_SYMBOLS[data_row[2].class] || DEFAULT_TYPE_SYMBOL
+        [type_name.to_s, :white]
+      end
 
-      def data_size
-        @layout.height - 1
+      def span_name(data_row, _index)
+        [
+          data_row[1].to_s,
+          [
+            KIND_COLORS[data_row[0]] || :bright_white,
+            inline?(data_row[0], data_row[1]) ? :bold : nil
+          ]
+        ]
       end
 
+      def span_indicator(_data_row, _index)
+        ['=', [:bright_white]]
+      end
+
+      def span_size(data_row, _index)
+        value = data_row[2]
+        if value.is_a?(Array) && !value.empty?
+          ["(size:#{value.length})", :white]
+        elsif value.is_a?(String) && value.length > 20
+          ["(size:#{value.length})", :white]
+        elsif value.is_a?(Hash) && !value.empty?
+          ["(size:#{value.length})", :white]
+        end
+      end
+
+      def span_inspection(data_row, _index)
+        # Hard limit: screen area
+        inspection = data_row[2].inspect[0..@height * @width]
+        # TODO: This is just a workable. Should write a decorator to inspect objects accurately
+        ["\n", "\r", "\r\n"].each do |esc|
+          inspection.gsub!(esc, esc.inspect)
+        end
+        [inspection, :dim, :white]
+      end
+
+      private
+
       def current_binding
         RubyJard.current_session.frame._binding
       end
@@ -84,16 +131,6 @@ module RubyJard
         RubyJard.current_session.backtrace[RubyJard.current_session.frame.pos][2]
       end
 
-      def decorated_variables
-        return [] if current_frame.nil?
-
-        variables = fetch_local_variables + fetch_instance_variables + fetch_constants
-
-        sort_variables(variables).map do |kind, name, value|
-          decorated_variable(kind, name, value)
-        end.flatten
-      end
-
       def fetch_local_variables
         variables = current_binding.local_variables
         # Exclude Pry's sticky locals
@@ -138,73 +175,6 @@ module RubyJard
         end.compact
       end
 
-      def decorated_variable(kind, name, value)
-        text =
-          decorate_text
-          .text(decorated_type(value))
-          .with_highlight(true)
-          .text(name.to_s, kind_color(kind))
-          .text(addition_data(value), :white)
-          .text(' = ')
-          .with_highlight(false)
-        inspect_texts = inspect_value(text, value)
-        text.text(inspect_texts.first, :bright_white)
-
-        # TODO: Fix this ugly code
-        [text] +
-          inspect_texts[1..-1].map do |line|
-            decorate_text
-          .with_highlight(false)
-          .text(' ' * TYPE_SYMBOL_PADDING)
-          .text(line, :bright_white)
-          end
-      end
-
-      def addition_data(value)
-        if value.is_a?(Array) && !value.empty?
-          " (size: #{value.length})"
-        elsif value.is_a?(String) && value.length > 20
-          " (size: #{value.length})"
-        else
-          ''
-        end
-      end
-
-      def inspect_value(text, value)
-        # Split the lines, add padding to align with kind
-        length = @layout.width - TYPE_SYMBOL_PADDING - 1
-        value_inspect = value.inspect.to_s
-
-        start_pos = 0
-        end_pos = @layout.width - 2 - text.length
-
-        texts = []
-        3.times do |_index|
-          texts << value_inspect[start_pos..end_pos]
-          break if end_pos >= value_inspect.length
-
-          start_pos = end_pos + 1
-          end_pos += length
-        end
-
-        if end_pos < value_inspect.length
-          texts.last[texts.last.length - INSPECTION_ELLIPSIS.length - 1..texts.last.length - 1] = INSPECTION_ELLIPSIS
-        end
-
-        texts
-      end
-
-      def decorated_type(value)
-        type_name = TYPE_SYMBOLS[value.class] || DEFAULT_TYPE_SYMBOL
-        decorate_text
-          .with_highlight(false)
-          .text(type_name.to_s.ljust(TYPE_SYMBOL_PADDING), :white)
-      end
-
-      def kind_color(kind)
-        KIND_COLORS[kind] || :white
-      end
-
       def sort_variables(variables)
         # Sort by kind
         # Sort by "internal" character so that internal variable is pushed down
@@ -227,6 +197,33 @@ module RubyJard
           end
         end
       end
+
+      def inline?(kind, name)
+        tokens = inline_tokens[INLINE_TOKEN_KIND_MAPS[kind]] || []
+        tokens.include?(name)
+      end
+
+      def inline_tokens
+        return @inline_tokens if defined?(@inline_tokens)
+
+        current_file = RubyJard.current_session.frame.file
+        current_line = RubyJard.current_session.frame.line
+        source_decorator = RubyJard::Decorators::SourceDecorator.new(current_file, current_line, 1)
+        loc_decorator = RubyJard::Decorators::LocDecorator.new(
+          current_file,
+          source_decorator.codes[current_line - source_decorator.window_start]
+        )
+
+        @inline_tokens = {}
+        loc_decorator.tokens.each_slice(2) do |token, kind|
+          next unless INLINE_TOKEN_KINDS.include?(kind)
+
+          @inline_tokens[kind] ||= []
+          @inline_tokens[kind] << token.to_s.to_sym
+        end
+
+        @inline_tokens
+      end
     end
   end
 end

data/lib/ruby_jard/session.rb

@@ -11,7 +11,7 @@ module RubyJard
   # other processes. Therefore, an internal, jard-specific data mapping should
   # be built.
   class Session
-    attr_reader :screen_manager, :backtrace, :frame, :contexts, :current_context
+    attr_reader :backtrace, :frame, :contexts, :current_context
 
     def initialize(options = {})
       @options = options
@@ -21,14 +21,12 @@ module RubyJard
       @contexts = []
 
       @started = false
-      @screen_manager = RubyJard::ScreenManager.new(session: self)
+      @session_lock = Mutex.new
     end
 
     def start
       return if started?
 
-      @screen_manager.start
-
       @started = true
     end
 
@@ -43,12 +41,20 @@ module RubyJard
       Byebug.current_context.step_out(2, false)
     end
 
-    def refresh
+    def update
       @backtrace = Byebug.current_context.backtrace
       @frame = Byebug.current_context.frame
       @contexts = Byebug.contexts
-      @current_context = Byebug.current_context
-      @screen_manager.refresh
+    end
+
+    def lock
+      raise RubyJard::Error, 'This method requires a block' unless block_given?
+
+      # TODO: This doesn't solve anything. However, debugging a multi-threaded process is hard.
+      # Let's deal with that later.
+      @session_lock.synchronize do
+        yield
+      end
     end
   end
 end

data/lib/ruby_jard/span.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Span
+    extend Forwardable
+
+    attr_accessor :span_template, :content, :content_length, :styles
+
+    def_delegators :@span_template, :margin_left, :margin_right, :word_wrap, :ellipsis
+
+    def initialize(span_template:, content: '', content_length: 0, styles: [])
+      @span_template = span_template
+      @content = content
+      @content_length = content_length
+      @styles = styles
+    end
+  end
+end

data/lib/ruby_jard/templates/column_template.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Templates
+    ##
+    # Template for a column. All items in a column align with each other. A column includes one or more spans.
+    class ColumnTemplate
+      attr_reader :spans, :margin_right, :margin_left
+
+      def initialize(spans: [], margin_left: 0, margin_right: 0)
+        @spans = spans
+        @margin_left = margin_left
+        @margin_right = margin_right
+      end
+    end
+  end
+end