ruby_jard 0.2.2 → 0.2.3

data/lib/ruby_jard/screen.rb

@@ -6,17 +6,15 @@ module RubyJard
   # generated based on input layout specifiation, screen data, and top-left
   # corner cordination.
   class Screen
-    attr_accessor :layout, :rows, :color_scheme, :window, :cursor, :selected
+    attr_accessor :layout, :rows, :window, :cursor, :selected
 
-    def initialize(session: nil, layout:, color_scheme:)
+    def initialize(session: nil, layout:)
       @session = session || RubyJard.current_session
       @layout = layout
-      @color_scheme = color_scheme
       @window = []
       @cursor = nil
       @selected = 0
       @rows = []
-      @need_to_render = true
     end
 
     def move_down; end
@@ -32,13 +30,5 @@ module RubyJard
     def build
       raise NotImplementedError, "#{self.class} should implement this method."
     end
-
-    def need_to_render?
-      @need_to_render == true
-    end
-
-    def mark_rendered!
-      @need_to_render = false
-    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

@@ -1,6 +1,9 @@
 # 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

data/lib/ruby_jard/screen_manager.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'tempfile'
 require 'ruby_jard/console'
 
 require 'ruby_jard/decorators/color_decorator'
@@ -8,36 +9,19 @@ require 'ruby_jard/decorators/loc_decorator'
 require 'ruby_jard/decorators/source_decorator'
 require 'ruby_jard/decorators/inspection_decorator'
 
-require 'ruby_jard/screen'
 require 'ruby_jard/screens'
-
-require 'ruby_jard/color_scheme'
 require 'ruby_jard/color_schemes'
-require 'ruby_jard/color_schemes/deep_space_color_scheme'
-require 'ruby_jard/color_schemes/256_color_scheme'
+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'
 
-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/templates/layout_template'
-require 'ruby_jard/templates/screen_template'
-
-require 'ruby_jard/layouts/wide_layout'
-require 'ruby_jard/layouts/narrow_layout'
-require 'ruby_jard/layout'
-require 'ruby_jard/layout_calculator'
-
 module RubyJard
   ##
   # This class acts as a coordinator, in which it combines the data and screen
@@ -46,7 +30,7 @@ module RubyJard
     class << self
       extend Forwardable
 
-      def_delegators :instance, :update, :draw_error, :started?, :updating?
+      def_delegators :instance, :update, :puts, :draw_error, :started?, :updating?
 
       def instance
         @instance ||= new
@@ -60,7 +44,7 @@ module RubyJard
       @screens = {}
       @started = false
       @updating = false
-      @output_storage = StringIO.new
+      @output_storage = Tempfile.new('jard')
     end
 
     def start
@@ -71,14 +55,16 @@ module RubyJard
       RubyJard::Console.start_alternative_terminal(@output)
       RubyJard::Console.clear_screen(@output)
 
-      def $stdout.write(string)
+      # rubocop:disable Lint/NestedMethodDefinition
+      def $stdout.write(*string, from_jard: false)
         # NOTE: `RubyJard::ScreenManager.instance` is a must. Jard doesn't work well with delegator
         # TODO: Debug and fix the issues permanently
-        if !RubyJard::ScreenManager.instance.updating? && RubyJard::ScreenManager.instance.started?
-          RubyJard::ScreenManager.instance.output_storage.write(string)
+        if !RubyJard::ScreenManager.instance.updating? && RubyJard::ScreenManager.instance.started? && !from_jard
+          RubyJard::ScreenManager.instance.output_storage.write(*string)
         end
-        super
+        super(*string)
       end
+      # rubocop:enable Lint/NestedMethodDefinition
 
       at_exit { stop }
       @started = true
@@ -102,12 +88,10 @@ module RubyJard
       RubyJard::Console.enable_echo!
       RubyJard::Console.enable_cursor!
 
-      unless @output_storage.string.empty?
-        @output.puts ''
-        @output.write @output_storage.string
-        @output.puts ''
-      end
+      @output_storage.rewind
+      @output.write @output_storage.read until @output_storage.eof?
       @output_storage.close
+      @output_storage.unlink
     end
 
     def update
@@ -119,13 +103,14 @@ module RubyJard
 
       @layouts = calculate_layouts(width, height)
       @screens = build_screens(@layouts)
+
+      RubyJard::Console.move_to(@output, 0, 0)
+
       draw_box(@screens)
       draw_screens(@screens)
 
       RubyJard::Console.move_to(@output, 0, total_screen_height(@layouts) + 1)
       RubyJard::Console.clear_screen_to_end(@output)
-
-      draw_debug(width, height)
     rescue StandardError => e
       RubyJard::Console.clear_screen(@output)
       draw_error(e, height)
@@ -156,10 +141,14 @@ module RubyJard
       @output.puts '-------------'
     end
 
+    def puts(content)
+      @output.write "#{content}\n", from_jard: true
+    end
+
     private
 
     def calculate_layouts(width, height)
-      layout = pick_layout(width, height)
+      layout = RubyJard::LayoutPicker.new(width, height).pick
       RubyJard::LayoutCalculator.calculate(
         layout_template: layout,
         width: width, height: height,
@@ -168,12 +157,17 @@ module RubyJard
     end
 
     def build_screens(layouts)
+      screens = layouts.map do |layout|
+        screen_class = fetch_screen(layout.template.screen)
+        screen = screen_class.new(layout: 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: layout,
-          color_scheme: pick_color_scheme
-        )
+        screen = screen_class.new(layout: layout)
         screen.build
         render_screen(screen)
         screen
@@ -222,23 +216,7 @@ module RubyJard
     end
 
     def total_screen_height(layouts)
-      layouts.map { |layout| layout.y + layout.height }.max
-    end
-
-    def pick_layout(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
+      layouts.map { |layout| layout.y + layout.height }.max || 0
     end
 
     def pick_color_scheme

data/lib/ruby_jard/screen_renderer.rb

@@ -11,15 +11,11 @@ module RubyJard
     end
 
     def render
-      return unless @screen.need_to_render?
-
       # Move this logic into a class called SreenRenderer
       calculate_content_lengths
       column_widths = calculate_column_widths
       adjust_column_widths(column_widths)
-      render_rows
       calculate_window
-      @screen.mark_rendered!
 
       @screen
     end
@@ -57,10 +53,8 @@ module RubyJard
     end
 
     def adjust_column_widths(column_widths)
-      dynamic_count = column_widths.values.select(&:nil?).length
-      fixed_width = column_widths.values.inject(0) do |sum, col|
-        col.nil? ? sum : sum + col
-      end
+      dynamic_count = count_dynamic_columns(column_widths)
+      fixed_width = sum_fixed_width(column_widths)
 
       @screen.rows.each do |row|
         total_width = 0
@@ -73,19 +67,26 @@ module RubyJard
             else
               column_widths[column_index]
             end
+          column.content_width = column.width
+          column.content_width -= 1 if column_index < row.columns.length - 1
+
           total_width += column.width
         end
       end
     end
 
+    def count_dynamic_columns(column_widths)
+      column_widths.values.select(&:nil?).length
+    end
+
+    def sum_fixed_width(column_widths)
+      column_widths.values.inject(0) do |sum, col|
+        col.nil? ? sum : sum + col
+      end
+    end
+
     def render_rows
       @screen.rows.each do |row|
-        RubyJard::RowRenderer.new(
-          row: row,
-          width: @screen.layout.width,
-          height: @screen.layout.height,
-          color_scheme: @color_scheme
-        ).render
       end
     end
 
@@ -101,7 +102,7 @@ module RubyJard
 
     def find_seleted_window
       @screen.rows.each_with_index do |row, row_index|
-        row.content.each_with_index do |line, line_index|
+        row_content(row).each_with_index do |line, line_index|
           if @screen.window.length < @screen.layout.height
             @screen.window << line
           elsif row_index < @screen.selected
@@ -123,7 +124,7 @@ module RubyJard
     def find_cursor_window
       cursor_line = -1
       @screen.rows.each do |row|
-        row.content.each do |line|
+        row_content(row).each do |line|
           cursor_line += 1
           @screen.window << line if cursor_line >= @screen.cursor
           return if @screen.window.length >= @screen.layout.height
@@ -134,5 +135,18 @@ module RubyJard
     def count_columns
       @screen.rows.map { |row| row.columns.count }.max.to_i
     end
+
+    def row_content(row)
+      unless row.rendered?
+        RubyJard::RowRenderer.new(
+          row: row,
+          width: @screen.layout.width,
+          height: @screen.layout.height,
+          color_scheme: @color_scheme
+        ).render
+      end
+
+      row.content
+    end
   end
 end

data/lib/ruby_jard/screens.rb

@@ -1,26 +1,45 @@
 # frozen_string_literal: true
 
+require 'ruby_jard/screen'
+
 module RubyJard
   ##
   # Screen registry. The screens call add_screen right after they are declared.
-  module Screens
+  class Screens
     class << self
-      def screen_registry
-        @screen_registry ||= {}
+      extend Forwardable
+      def_delegators :instance, :add_screen, :[], :get, :names
+
+      def instance
+        @instance ||= new
       end
+    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
+    def initialize
+      @screen_registry = {}
+    end
 
-        screen_registry[name] = screen_class
+    def add_screen(name, screen_class)
+      unless screen_class < RubyJard::Screen
+        raise RubyJard::Error, "#{screen_class} must implement, and inherit from #{RubyJard::Screen}"
       end
 
-      def [](name)
-        screen_registry[name]
-      end
-      alias get []
+      @screen_registry[name.to_s] = screen_class
+    end
+
+    def [](name)
+      @screen_registry[name.to_s]
+    end
+    alias_method :get, :[]
+
+    def names
+      @screen_registry.keys.sort.dup
     end
   end
 end
+
+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'