ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/screen.rb

@@ -6,56 +6,29 @@ module RubyJard
   # generated based on input layout specifiation, screen data, and top-left
   # corner cordination.
   class Screen
-    attr_reader :output
+    attr_accessor :layout, :rows, :window, :cursor, :selected
 
-    def initialize(layout:, output:, session:, row:, col:)
-      @output = output
-      @session = session
+    def initialize(layout, session: nil)
+      @session = session || RubyJard::Session
       @layout = layout
-      @row = row
-      @col = col
-      @color_decorator = Pastel.new
+      @window = []
+      @cursor = nil
+      @selected = 0
+      @rows = []
     end
 
-    def draw(_row, _col, _size)
-      raise NotImplementedError, "#{self.class} must implement #draw method"
-    end
+    def move_down; end
 
-    def decorate_text
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::TextDecorator.new(@color_decorator)
-    end
+    def move_up; end
 
-    def decorate_path(path, lineno)
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::PathDecorator.new(path, lineno)
-    end
+    def page_up; end
 
-    def decorate_source(file, lineno, window)
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::SourceDecorator.new(file, lineno, window)
-    end
+    def page_down; end
 
-    def decorate_loc(loc, highlighted)
-      # TODO: this interface is ugly as fuck
-      RubyJard::Decorators::LocDecorator.new(@color_decorator, loc, highlighted)
-    end
+    def click(relative_x, relative_y); end
 
-    private
-
-    def default_frame_styles
-      {
-        style: {
-          fg: :white
-        },
-        border: {
-          bottom_left: false,
-          bottom_right: false,
-          bottom: false,
-          left: :line,
-          right: false
-        }
-      }
+    def build
+      raise NotImplementedError, "#{self.class} should implement this method."
     end
   end
 end

data/lib/ruby_jard/screen_adjuster.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Implement elastic screen height. If a screen is shrinkable (which means)
+  # its current window is less than its height, it will be forced to give
+  # away those spaces to other screens. This layout adjustment is small, and
+  # should not affect the original generated layout too much, nor work with
+  # nested layout.
+  class ScreenAdjuster
+    def initialize(screens)
+      @screens = screens
+    end
+
+    def adjust
+      groups = @screens.group_by { |screen| screen.layout.parent_template }
+      groups.each do |_, grouped_screens|
+        next if grouped_screens.length <= 1
+        next unless same_column?(grouped_screens)
+
+        grouped_screens.sort_by! { |screen| screen.layout.box_y }
+        shrinkable_screens = grouped_screens.select { |s| shrinkable?(s) }
+        expandable_screens = grouped_screens.select { |s| expandable?(s) }
+
+        next if shrinkable_screens.empty? || expandable_screens.empty?
+
+        budget = shrinkable_screens.map { |s| shrinkable_height(s) }.sum
+        expand_screens(expandable_screens, budget)
+        shrink_screens(shrinkable_screens)
+        compact_screens(grouped_screens)
+      end
+    end
+
+    private
+
+    def same_column?(screens)
+      column_x = screens.first.layout.box_x
+      column_width = screens.first.layout.box_width
+      screens.all? { |s| s.layout.box_x == column_x && s.layout.box_width == column_width }
+    end
+
+    def expand_screens(expandable_screens, budget)
+      budget_each = budget / expandable_screens.length
+
+      expandable_screens.each_with_index do |screen, index|
+        if index == expandable_screens.length - 1
+          screen.layout.height += budget
+          screen.layout.box_height += budget
+        else
+          screen.layout.height += budget_each
+          screen.layout.box_height += budget_each
+          budget_each -= budget_each
+        end
+      end
+    end
+
+    def shrink_screens(shrinkable_screens)
+      shrinkable_screens.each do |screen|
+        delta = shrinkable_height(screen)
+        screen.layout.height -= delta
+        screen.layout.box_height -= delta
+      end
+    end
+
+    def compact_screens(screens)
+      box_y = screens.first.layout.box_y
+      screens.each do |screen|
+        screen.layout.box_y = box_y
+        screen.layout.y = box_y + 1
+        box_y += screen.layout.box_height - 1
+      end
+    end
+
+    def shrinkable?(screen)
+      case screen.layout.template.adjust_mode
+      when :expand
+        false
+      else
+        screen.window.length < screen.layout.height
+      end
+    end
+
+    def expandable?(screen)
+      case screen.layout.template.adjust_mode
+      when :expand
+        true
+      else
+        screen.window.length >= screen.layout.height
+      end
+    end
+
+    def shrinkable_height(screen)
+      if screen.window.length < screen.layout.height
+        window_height = screen.window.length
+        if !screen.layout.template.min_height.nil? && screen.layout.template.min_height > window_height
+          window_height = screen.layout.template.min_height
+        end
+        screen.layout.height - window_height
+      else
+        0
+      end
+    end
+  end
+end

data/lib/ruby_jard/screen_drawer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Draw rendered screen bitmap in current screen window onto the screen.
+  # Fulfill missing window if needed
+  class ScreenDrawer
+    def initialize(output:, screen:, color_scheme:)
+      @output = output
+      @screen = screen
+      @color_decorator = RubyJard::Decorators::ColorDecorator.new(color_scheme)
+    end
+
+    def draw
+      @screen.window.each_with_index do |line, index|
+        RubyJard::Console.move_to(@output, @screen.layout.x, @screen.layout.y + index)
+        @output.print line
+      end
+      (@screen.window.length..@screen.layout.height - 1).each do |index|
+        RubyJard::Console.move_to(@output, @screen.layout.x, @screen.layout.y + index)
+        @output.print @color_decorator.decorate(:background, ' ' * @screen.layout.width)
+      end
+    end
+  end
+end

data/lib/ruby_jard/screen_manager.rb

@@ -1,121 +1,206 @@
 # frozen_string_literal: true
 
-require 'ruby_jard/decorators/text_decorator'
+require 'ruby_jard/console'
+
+require 'ruby_jard/decorators/color_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/decorators/inspection_decorator'
+
 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'
+require 'ruby_jard/color_schemes'
+require 'ruby_jard/layouts'
+
+require 'ruby_jard/row'
+require 'ruby_jard/column'
+require 'ruby_jard/span'
+require 'ruby_jard/row_renderer'
+require 'ruby_jard/screen_renderer'
+require 'ruby_jard/screen_adjuster'
+require 'ruby_jard/box_drawer'
+require 'ruby_jard/screen_drawer'
 
 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
+    class << self
+      extend Forwardable
+
+      def_delegators :instance, :draw_screens, :puts, :draw_error, :start, :stop, :started?, :updating?
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    attr_reader :output, :output_storage
 
-    def initialize(session:, output: STDOUT)
+    def initialize(output: STDOUT)
       @output = output
-      @session = session
       @screens = {}
+      @started = false
+      @updating = false
     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
+      return if started?
+
+      # Load configurations
+      RubyJard.config
+      RubyJard::Console.clear_screen(@output)
+
+      @started = true
     end
 
-    private
+    def started?
+      @started == true
+    end
 
-    def clear_screen
-      @output.print TTY::Cursor.clear_screen
-      @output.print TTY::Cursor.move_to(0, 0)
+    def updating?
+      @updating == true
     end
 
-    def draw(layout, row, col)
-      @output.print TTY::Cursor.move_to(col, row)
+    def stop
+      return unless started?
 
-      if layout.screen.nil?
-        draw_children(layout, row, col)
-      else
-        screen = fetch_screen(layout.screen)
-        screen&.new(
+      @started = false
+
+      RubyJard::Console.cooked!
+      RubyJard::Console.enable_echo!
+      RubyJard::Console.enable_cursor!
+    end
+
+    def draw_screens
+      start unless started?
+      @updating = true
+
+      RubyJard::Console.clear_screen(@output)
+      RubyJard::Console.disable_cursor!
+      width, height = RubyJard::Console.screen_size(@output)
+
+      @layouts = calculate_layouts(width, height)
+      @screens = build_screens(@layouts)
+
+      RubyJard::Console.move_to(@output, 0, 0)
+
+      draw_box(@screens)
+      @screens.each do |screen|
+        RubyJard::ScreenDrawer.new(
           output: @output,
-          session: @session,
-          layout: layout,
-          row: row,
-          col: col
-        )&.draw
+          screen: screen,
+          color_scheme: pick_color_scheme
+        ).draw
       end
+
+      RubyJard::Console.move_to(@output, 0, total_screen_height(@layouts) + 1)
+      RubyJard::Console.clear_screen_to_end(@output)
+    rescue StandardError => e
+      RubyJard::Console.clear_screen(@output)
+      draw_error(e, height)
+    ensure
+      # You don't want to mess up previous user TTY no matter happens
+      RubyJard::Console.cooked!
+      RubyJard::Console.enable_echo!
+      RubyJard::Console.enable_cursor!
+      @updating = false
     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
+    def scroll; end
+
+    def click; end
+
+    def draw_error(exception, height = 0)
+      @output.print RubyJard::Decorators::ColorDecorator::CSI_RESET
+      @output.puts '--- Error ---'
+      @output.puts "Internal error from Jard. I'm sorry to mess up your debugging experience."
+      @output.puts 'It would be great if you can submit an issue in https://github.com/nguyenquangminh0711/ruby_jard/issues'
+      @output.puts ''
+      @output.puts exception
+      if height == 0
+        @output.puts exception.backtrace
+      else
+        @output.puts exception.backtrace.first(10)
       end
+      @output.puts '-------------'
+      RubyJard.error(exception)
+    end
+
+    def puts(content)
+      @output.write "#{content}\n", from_jard: true
+    end
 
-      @output.print TTY::Cursor.move_to(0, children_row + 1)
+    private
+
+    def calculate_layouts(width, height)
+      layout = RubyJard::LayoutPicker.new(width, height).pick
+      RubyJard::LayoutCalculator.calculate(
+        layout_template: layout,
+        width: width, height: height,
+        x: 0, y: 0
+      )
+    end
+
+    def build_screens(layouts)
+      screens = layouts.map do |layout|
+        screen_class = fetch_screen(layout.template.screen)
+        screen = screen_class.new(layout)
+        screen.build
+        render_screen(screen)
+        screen
+      end
+      RubyJard::ScreenAdjuster.new(screens).adjust
+      layouts.map do |layout|
+        screen_class = fetch_screen(layout.template.screen)
+        screen = screen_class.new(layout)
+        screen.build
+        render_screen(screen)
+        screen
+      end
+    end
+
+    def draw_box(screens)
+      RubyJard::BoxDrawer.new(
+        output: @output,
+        screens: screens,
+        color_scheme: pick_color_scheme
+      ).draw
+    end
+
+    def render_screen(screen)
+      RubyJard::ScreenRenderer.new(
+        screen: screen,
+        color_scheme: pick_color_scheme
+      ).render
+    end
+
+    def draw_debug(_width, height)
+      @output.print RubyJard::Decorators::ColorDecorator::CSI_RESET
+      unless RubyJard.debug_info.empty?
+        @output.puts '--- Debug ---'
+        RubyJard.debug_info.first(height - 2).each do |line|
+          @output.puts line
+        end
+        @output.puts '-------------'
+      end
+      RubyJard.clear_debug
     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
+    def total_screen_height(layouts)
+      layouts.map { |layout| layout.y + layout.height }.max || 0
+    end
+
+    def pick_color_scheme
+      color_scheme_class =
+        RubyJard::ColorSchemes[RubyJard.config.color_scheme] ||
+        RubyJard::ColorSchemes[RubyJard::Config::DEFAULT_COLOR_SCHEME]
+      color_scheme_class.new
     end
   end
 end