ruby_jard 0.1.0

data/lib/ruby_jard/layout.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Layout calculator based on screen resolution to decide the height, width,
+  # visibility, data size of each children screen.
+  # TODO: Right now, the sizes are fixed regardless of current screen data size.
+  class Layout
+    def self.generate(**args)
+      layout = new(**args)
+      layout.generate
+      layout
+    end
+
+    attr_accessor :width, :height, :screen, :children
+
+    def initialize(template:, width: 0, height: 0)
+      @template = template
+      @width = width
+      @height = height
+      @screen = nil
+      @children = []
+    end
+
+    def generate
+      if @template.screen.nil? && !@template.children.empty?
+        generate_childen
+      else
+        # Ignore children if a layout is a screen
+        @screen = @template.screen
+      end
+
+      self
+    end
+
+    private
+
+    def generate_childen
+      total_height = 0
+      total_width = 0
+
+      @children = @template.children.map.with_index do |child_template, index|
+        child = RubyJard::Layout.new(
+          template: child_template,
+          height: calculate_child_height(child_template, index, total_height),
+          width: calculate_child_width(child_template, index, total_width)
+        )
+        child.generate
+
+        total_width += child.width
+        total_height += child.height
+
+        child
+      end
+    end
+
+    def calculate_child_height(child_template, index, total_height)
+      height =
+        if !child_template.height.nil?
+          child_template.height
+        elsif child_template.height_ratio.nil?
+          @height
+        else
+          @height * child_template.height_ratio / 100
+        end
+
+      unless child_template.min_height.nil?
+        height = child_template.min_height if height < child_template.min_height
+      end
+
+      if @template.fill_height && index == @template.children.length - 1
+        height = @height - total_height if height < (@height - total_height)
+      end
+
+      height
+    end
+
+    def calculate_child_width(child_template, index, total_width)
+      width =
+        if !child_template.width.nil?
+          child_template.width
+        elsif child_template.width_ratio.nil?
+          @width
+        else
+          @width * child_template.width_ratio / 100
+        end
+
+      unless child_template.min_width.nil?
+        width = child_template.min_width if width < child_template.min_width
+      end
+
+      if @template.fill_width && index == @template.children.length - 1
+        width = @width - total_width if width < (@width - total_width)
+      end
+
+      width
+    end
+  end
+end

data/lib/ruby_jard/layout_template.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Template of a layout. Templates are hierarchy. Each template includes the
+  # sizing configuration, including absolute values, min, max, or ratio
+  # relative to its parant.
+  class LayoutTemplate
+    attr_reader :screen, :height_ratio, :width_ratio,
+                :min_width, :min_height,
+                :height, :width,
+                :children,
+                :fill_width, :fill_height
+
+    def initialize(
+      screen: nil, height_ratio: nil, width_ratio: nil,
+      min_width: nil, min_height: nil,
+      height: nil, width: nil,
+      children: [],
+      fill_width: nil, fill_height: nil
+    )
+      @screen = screen
+      @height_ratio = height_ratio
+      @width_ratio = width_ratio
+      @min_width = min_width
+      @min_height = min_height
+      @height = height
+      @width = width
+      @children = children
+      @fill_width = fill_width
+      @fill_height = fill_height
+    end
+  end
+
+  WideLayoutTemplate = LayoutTemplate.new(
+    min_width: 120,
+    min_height: 10,
+    fill_width: true,
+    fill_height: false,
+    children: [
+      LayoutTemplate.new(
+        height_ratio: 50,
+        min_height: 7,
+        fill_width: true,
+        children: [
+          LayoutTemplate.new(
+            screen: :source,
+            width_ratio: 60
+          ),
+          LayoutTemplate.new(
+            width_ratio: 40,
+            fill_height: true,
+            children: [
+              LayoutTemplate.new(
+                screen: :variables,
+                width_ratio: 100,
+                height_ratio: 100,
+                min_height: 3
+              )
+              # LayoutTemplate.new(
+              #   screen: :breakpoints,
+              #   width_ratio: 100,
+              #   height_ratio: 25,
+              #   min_height: 3
+              # ),
+              # LayoutTemplate.new(
+              #   screen: :expressions,
+              #   width_ratio: 100,
+              #   height_ratio: 25,
+              #   min_height: 3
+              # )
+            ]
+          )
+        ]
+      ),
+      LayoutTemplate.new(
+        height_ratio: 20,
+        min_height: 3,
+        fill_width: true,
+        children: [
+          LayoutTemplate.new(
+            screen: :backtrace,
+            width_ratio: 60
+          ),
+          LayoutTemplate.new(
+            screen: :threads,
+            width_ratio: 40
+          )
+        ]
+      ),
+      LayoutTemplate.new(
+        height: 2,
+        screen: :menu
+      )
+    ]
+  )
+
+  DEFAULT_LAYOUT_TEMPLATES = [
+    WideLayoutTemplate
+  ].freeze
+end

data/lib/ruby_jard/repl_processor.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Byebug allows customizing processor with a series of hooks (https://github.com/deivid-rodriguez/byebug/blob/e1fb8209d56922f7bafd128af84e61568b6cd6a7/lib/byebug/processors/command_processor.rb)
+  #
+  # This class is a bridge between Pry and Byebug. It is inherited from
+  # Byebug::CommandProcessor, the processor is triggered. It starts draw the
+  # UI, starts a new pry session, listen for control-flow events threw from
+  # pry commands (lib/commands/*), and triggers Byebug debugger if needed.
+  #
+  class ReplProcessor < Byebug::CommandProcessor
+    # Some commands overlaps with Jard, Ruby, and even cause confusion for
+    # users. It's better ignore or re-implement those commands.
+    PRY_EXCLUDED_COMMANDS = [
+      'pry-backtrace', # Redundant method for normal user
+      'watch',         # Conflict with byebug and jard watch
+      'whereami',      # Jard already provides similar. Keeping this command makes conflicted experience
+      'edit',          # Sorry, but a file should not be editted while debugging, as it made breakpoints shifted
+      'play',          # What if the played files or methods include jard again?
+      'stat',          # Included in jard UI
+      'backtrace',     # Re-implemented later
+      'break',         # Re-implemented later
+      'exit',          # Conflicted with continue
+      'exit-all',      # Conflicted with continue
+      'exit-program',  # We already have `exit` native command
+      '!pry',          # No need to complicate things
+      'jump-to',       # No need to complicate things
+      'nesting',       # No need to complicate things
+      'switch-to',     # No need to complicate things
+      'disable-pry'    # No need to complicate things
+    ].freeze
+
+    def initialize(context, interface = LocalInterface.new)
+      super(context, interface)
+    end
+
+    def at_line
+      process_commands
+    end
+
+    def at_return(_)
+      process_commands
+    end
+
+    def at_end
+      process_commands
+    end
+
+    private
+
+    def process_commands
+      RubyJard.current_session.refresh
+      return_value = nil
+
+      flow = catch(:control_flow) do
+        return_value = allowing_other_threads do
+          start_pry_session
+        end
+        {}
+      end
+
+      @pry = flow[:pry]
+      if @pry
+        @pry.binding_stack.clear
+        send("handle_#{flow[:command]}_command", @pry, flow[:options])
+      end
+
+      return_value
+    end
+
+    def start_pry_session
+      if @pry.nil?
+        @pry = Pry.start(
+          frame._binding,
+          prompt: pry_jard_prompt,
+          quiet: true,
+          commands: pry_command_set
+        )
+      else
+        @pry.repl(frame._binding)
+      end
+    end
+
+    def handle_next_command(_pry_instance, _options)
+      Byebug::NextCommand.new(self, 'next').execute
+    end
+
+    def handle_step_command(_pry_instance, _options)
+      Byebug::StepCommand.new(self, 'step').execute
+    end
+
+    def handle_up_command(_pry_instance, _options)
+      Byebug::UpCommand.new(self, 'up 1').execute
+
+      process_commands
+    end
+
+    def handle_down_command(_pry_instance, _options)
+      Byebug::DownCommand.new(self, 'down 1').execute
+
+      process_commands
+    end
+
+    def handle_finish_command(_pry_instance, _options)
+      RubyJard.current_session.disable
+      context.step_out(2, true)
+      Byebug::NextCommand.new(self, 'next').execute
+      RubyJard.current_session.enable
+    end
+
+    def handle_continue_command(_pry_instance, _options)
+      # Do nothing
+    end
+
+    def pry_command_set
+      @pry_command_set ||=
+        begin
+          set = Pry::CommandSet.new
+          set.import_from(
+            Pry.config.commands,
+            *(Pry.config.commands.list_commands - PRY_EXCLUDED_COMMANDS)
+          )
+          set
+        end
+    end
+
+    def pry_jard_prompt
+      @pry_jard_prompt ||=
+        Pry::Prompt.new(
+          :jard,
+          'Custom pry promt for Jard', [
+            proc do |_context, _nesting, _pry_instance|
+              'jard >> '
+            end,
+            proc do |_context, _nesting, _pry_instance|
+              'jard *> '
+            end
+          ]
+        )
+    end
+  end
+end

data/lib/ruby_jard/screen.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # A screen is a unit of information drawing on the terminal. Each screen is
+  # generated based on input layout specifiation, screen data, and top-left
+  # corner cordination.
+  class Screen
+    attr_reader :output
+
+    def initialize(layout:, output:, session:, row:, col:)
+      @output = output
+      @session = session
+      @layout = layout
+      @row = row
+      @col = col
+      @color_decorator = Pastel.new
+    end
+
+    def draw(_row, _col, _size)
+      raise NotImplementedError, "#{self.class} must implement #draw method"
+    end
+
+    def decorate_text
+      # TODO: this interface is ugly as fuck
+      RubyJard::Decorators::TextDecorator.new(@color_decorator)
+    end
+
+    def decorate_path(path, lineno)
+      # TODO: this interface is ugly as fuck
+      RubyJard::Decorators::PathDecorator.new(path, lineno)
+    end
+
+    def decorate_source(file, lineno, window)
+      # TODO: this interface is ugly as fuck
+      RubyJard::Decorators::SourceDecorator.new(file, lineno, window)
+    end
+
+    def decorate_loc(loc, highlighted)
+      # TODO: this interface is ugly as fuck
+      RubyJard::Decorators::LocDecorator.new(@color_decorator, loc, highlighted)
+    end
+
+    private
+
+    def default_frame_styles
+      {
+        style: {
+          fg: :white
+        },
+        border: {
+          bottom_left: false,
+          bottom_right: false,
+          bottom: false,
+          left: :line,
+          right: false
+        }
+      }
+    end
+  end
+end

data/lib/ruby_jard/screen_manager.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'ruby_jard/decorators/text_decorator'
+require 'ruby_jard/decorators/path_decorator'
+require 'ruby_jard/decorators/loc_decorator'
+require 'ruby_jard/decorators/source_decorator'
+require 'ruby_jard/screen'
+require 'ruby_jard/screens'
+require 'ruby_jard/screens/breakpoints_screen'
+require 'ruby_jard/screens/expressions_sreen'
+require 'ruby_jard/screens/source_screen'
+require 'ruby_jard/screens/backtrace_screen'
+require 'ruby_jard/screens/threads_screen'
+require 'ruby_jard/screens/variables_screen'
+require 'ruby_jard/screens/menu_screen'
+require 'ruby_jard/layout_template'
+require 'ruby_jard/layout'
+
+module RubyJard
+  ##
+  # This class acts as a coordinator, in which it combines the data and screen
+  # layout template, triggers each screen to draw on the terminal.
+  class ScreenManager
+    attr_reader :output
+
+    def initialize(session:, output: STDOUT)
+      @output = output
+      @session = session
+      @screens = {}
+    end
+
+    def start
+      refresh
+    end
+
+    def refresh
+      clear_screen
+      width = TTY::Screen.width
+      height = TTY::Screen.height
+      template = pick_template(width, height)
+      layout = RubyJard::Layout.generate(template: template, width: width, height: height)
+      begin
+        draw(layout, 0, 0)
+      rescue StandardError => e
+        clear_screen
+        @output.puts e
+        @output.puts e.backtrace
+      end
+    end
+
+    private
+
+    def clear_screen
+      @output.print TTY::Cursor.clear_screen
+      @output.print TTY::Cursor.move_to(0, 0)
+    end
+
+    def draw(layout, row, col)
+      @output.print TTY::Cursor.move_to(col, row)
+
+      if layout.screen.nil?
+        draw_children(layout, row, col)
+      else
+        screen = fetch_screen(layout.screen)
+        screen&.new(
+          output: @output,
+          session: @session,
+          layout: layout,
+          row: row,
+          col: col
+        )&.draw
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def draw_children(layout, row, col)
+      children_row = row
+      children_col = col
+      drawing_width = 0
+      max_height = 0
+      layout.children.each do |child|
+        draw(child, children_row, children_col)
+
+        drawing_width += child.width
+        max_height = child.height if max_height < child.height
+        # Overflow. Break to next line
+        if drawing_width >= layout.width
+          children_row += max_height
+          children_col = col
+          drawing_width = 0
+          max_height = 0
+        else
+          children_col += child.width
+        end
+      end
+
+      @output.print TTY::Cursor.move_to(0, children_row + 1)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def fetch_screen(name)
+      RubyJard::Screens[name]
+    end
+
+    def pick_template(width, height)
+      RubyJard::DEFAULT_LAYOUT_TEMPLATES.each do |template|
+        matched = true
+        matched &&= (
+          template.min_width.nil? ||
+          width > template.min_width
+        )
+        matched &&= (
+          template.min_height.nil? ||
+          height > template.min_height
+        )
+        return template if matched
+      end
+      RubyJard::DEFAULT_LAYOUT_TEMPLATES.first
+    end
+  end
+end