ruby_jard 0.1.0 → 0.2.0

data/lib/ruby_jard/screens/backtrace_screen.rb

@@ -2,133 +2,116 @@
 
 module RubyJard
   module 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
-
-          # 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
+      def title
+        "Backtrace (#{frames_count})"
       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
-        )
+        [@height, frames_count].min
       end
 
-      def decorate_frames
+      def data_window
         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
+        @data_window ||= backtrace[data_window_start..data_window_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)
+      def data_window_start
+        return 0 if data_size.zero?
 
-        [left, right]
+        current_frame / data_size * data_size
       end
 
-      def reset
-        @color = Pastel.new
+      def data_window_end
+        [frames_count, data_window_start + data_size - 1].min
       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)
+      def span_mark(_frame, index)
+        [
+          current_frame?(index) ? '→' : ' ',
+          [:bright_yellow, current_frame?(index) ? :bold : nil]
+        ]
       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_frame_id(_frame, index)
+        frame_id = index + data_window_start
+        [
+          frame_id.to_s,
+          [
+            current_frame?(index) ? :bright_yellow : :white,
+            current_frame?(index) ? :bold : nil
+          ]
+        ]
       end
 
-      def decorate_object_label(object, klass)
-        if klass.nil? || object.class == klass
-          if object.is_a?(Class)
+      def span_klass_label(frame, index)
+        object = frame[1]
+        klass = frame[2]
+        klass_label =
+          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
-            object.class.name
+            klass.name
           end
-        elsif klass.singleton_class?
-          # No easy way to get the original class of a singleton class
-          object.name
-        else
-          klass.name
-        end
+        c_frame = frame_at(index).last.nil? ? '[c] ' : ''
+        [
+          "#{c_frame}#{klass_label}",
+          [:green, current_frame?(index) ? :bold : nil]
+        ]
       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_label_preposition(_frame, index)
+        ['in', current_frame?(index) ? [:bright_white] : [:white]]
       end
 
-      def decorate_location_path(frame_id, location)
+      def span_method_label(frame, index)
+        location = frame[0]
+        method_label =
+          if location.label != location.base_label
+            "#{location.base_label} (#{location.label.split(' ').first})"
+          else
+            location.base_label
+          end
+        [method_label, [:green, current_frame?(index) ? :bold : nil]]
+      end
+
+      def span_path_preposition(frame, index)
+        location = frame[0]
         decorated_path = decorate_path(location.absolute_path, location.lineno)
+        preposition = decorated_path.gem? ? 'in' : 'at'
+        [preposition, current_frame?(index) ? [:bright_white] : [:white]]
+      end
 
-        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
+      def span_path(frame, index)
+        location = frame[0]
+        decorated_path = decorate_path(location.absolute_path, location.lineno)
+
+        path_label =
+          if decorated_path.gem?
+            "#{decorated_path.gem} (#{decorated_path.gem_version})"
+          else
+            "#{decorated_path.path}:#{decorated_path.lineno}"
+          end
+        [path_label, current_frame?(index) ? [:bold, :bright_white] : [:white]]
       end
 
-      def frame_pos
+      private
+
+      def current_frame?(index)
+        index + data_window_start == current_frame
+      end
+
+      def current_frame
         if @session.frame.nil?
           0
         else
@@ -136,6 +119,10 @@ module RubyJard
         end
       end
 
+      def frame_at(index)
+        backtrace[index + data_window_start]
+      end
+
       def frames_count
         @session.backtrace.length
       end
@@ -143,6 +130,10 @@ module RubyJard
       def backtrace
         @session.backtrace
       end
+
+      def decorate_path(path, lineno)
+        RubyJard::Decorators::PathDecorator.new(path, lineno)
+      end
     end
   end
 end

data/lib/ruby_jard/screens/menu_screen.rb

@@ -3,38 +3,23 @@
 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
+      def draw(output)
+        RubyJard::Console.move_to(output, @x, @y)
 
         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
+        left_menu.each do |text, length|
+          RubyJard::Console.move_to(output, @x + 1 + margin, @y)
+          output.print text
+          margin += 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
+        right_menu.reverse.each do |text, length|
+          RubyJard::Console.move_to(output, @x + @width - margin - length - 1, @y)
+          output.print text
+          margin += length + 3
         end
       end
 
@@ -42,19 +27,26 @@ module RubyJard
 
       def generate_left_menu
         [
-          decorate_text.with_highlight(true).text('Debug console (F5)', :bright_yellow),
-          decorate_text.text('Program output (F6)', :white)
+          # Fill in later
         ]
       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)
+          decorate_text('Step (F7)', :white),
+          decorate_text('Step Out (Shift+F7)', :white),
+          decorate_text('Next (F8)', :white),
+          decorate_text('Continue (F9)', :white)
         ]
       end
+
+      def decorate_text(str, *styles)
+        [color_decorator.decorate(str, *styles), str.length]
+      end
+
+      def color_decorator
+        @color_decorator ||= RubyJard::Decorators::ColorDecorator.new
+      end
     end
   end
 end

data/lib/ruby_jard/screens/source_screen.rb

@@ -3,75 +3,50 @@
 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
+      def title
+        return 'Source' if RubyJard.current_session.frame.nil?
+
+        decorated_path = path_decorator(current_file, current_line)
+        if decorated_path.gem?
+          "Source (#{decorated_path.gem} - #{decorated_path.path}:#{decorated_path.lineno})"
+        else
+          "Source (#{decorated_path.path}:#{decorated_path.lineno})"
         end
       end
 
-      private
-
       def data_size
-        @layout.height - 1
+        @height
       end
 
-      def decorate_codes
+      def data_window
         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
+        @data_window ||= source_decorator.codes
       end
 
-      def file_path
-        return '' if RubyJard.current_session.frame.nil?
+      def span_mark(_loc, index)
+        lineno = source_lineno(index)
+        [
+          current_line == lineno ? '→' : ' ',
+          [:bright_yellow, current_line == lineno ? :bold : nil]
+        ]
+      end
 
-        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
+      def span_lineno(_loc, index)
+        lineno = source_lineno(index)
+        [
+          lineno.to_s,
+          current_line == lineno ? [:bold, :bright_yellow] : [:dim, :white]
+        ]
+      end
+
+      def span_code(loc, index)
+        lineno = source_lineno(index)
+        [loc_decorator(loc).spans, current_line == lineno ? [:brighter] : [:dim]]
       end
 
+      private
+
       def current_binding
         RubyJard.current_session.frame._binding
       end
@@ -88,43 +63,20 @@ module RubyJard
         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?
+      def path_decorator(path, lineno)
+        @path_decorator ||= RubyJard::Decorators::PathDecorator.new(path, lineno)
+      end
 
-        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)
+      def source_decorator
+        @source_decorator ||= RubyJard::Decorators::SourceDecorator.new(current_file, current_line, data_size)
+      end
 
-          variables_text.with_highlight(false).text(', ', :white) if index != variables.length - 1
-        end
+      def loc_decorator(loc)
+        RubyJard::Decorators::LocDecorator.new(current_file, loc)
+      end
 
-        variables_text
+      def source_lineno(index)
+        source_decorator.window_start + index
       end
     end
   end