ruby_jard 0.2.2 → 0.2.3

data/lib/ruby_jard/layout_calculator.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 # rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/CyclomaticComplexity
 module RubyJard
   ##
   # Layout calculator based on screen resolution to decide the height, width,
@@ -12,27 +11,31 @@ module RubyJard
       new(**args).calculate
     end
 
-    def initialize(layout_template:, width: 0, height: 0, x: 0, y: 0)
+    def initialize(
+      layout_template:, width: 0, height: 0, x: 0, y: 0,
+      config: RubyJard.config
+    )
       @layout_template = layout_template
       @width = width
       @height = height
       @x = x
       @y = y
       @layouts = []
+      @config = config
     end
 
     def calculate
       @layouts = []
-      calculate_layout(@layout_template, @width, @height, @x, @y)
+      calculate_layout(@layout_template, @width, @height, @x, @y, nil)
       @layouts
     end
 
     private
 
-    def calculate_layout(template, width, height, x, y)
+    def calculate_layout(template, width, height, x, y, parent_template)
       if template.is_a?(RubyJard::Templates::ScreenTemplate)
         layout = RubyJard::Layout.new(
-          template: template,
+          template: template, parent_template: parent_template,
           width: width - 2, height: height - 2, x: x + 1, y: y + 1,
           box_width: width, box_height: height, box_x: x, box_y: y
         )
@@ -45,7 +48,7 @@ module RubyJard
         max_height = 0
 
         lines = [[]]
-        template.children.each do |child_template|
+        visible_children(template).each do |child_template|
           child_height = calculate_child_height(child_template, height)
           child_width = calculate_child_width(child_template, width)
 
@@ -57,23 +60,37 @@ module RubyJard
             overflow_width = 0
             max_height = child_height
             lines << []
-          else
-            max_height = child_height if max_height < child_height
+          elsif max_height < child_height
+            max_height = child_height
           end
 
           lines.last << [child_template, child_width, child_height, child_x, child_y]
           child_x += child_width
         end
 
-        stretch_lines(template, width, height, lines)
+        stretch_children_layouts(template, width, height, lines)
         lines.each do |line|
           line.each do |child_template, child_width, child_height, xx, yy|
-            calculate_layout(child_template, child_width, child_height, xx, yy)
+            calculate_layout(child_template, child_width, child_height, xx, yy, template)
           end
         end
       end
     end
 
+    def visible_children(template)
+      template.children.select do |child|
+        visible?(child)
+      end
+    end
+
+    def visible?(template)
+      if template.is_a?(RubyJard::Templates::ScreenTemplate)
+        @config.enabled_screens.include?(template.screen.to_s.strip)
+      else
+        template.children.any? { |child| visible?(child) }
+      end
+    end
+
     def adjust_layout_overlap(layout)
       if layout.box_x != 0
         layout.width += 1
@@ -90,7 +107,8 @@ module RubyJard
       end
     end
 
-    def stretch_lines(parent_template, parent_width, parent_height, lines)
+    # Stretch the children layouts to fill the gaps, remove redundant spaces inside the parent layout
+    def stretch_children_layouts(parent_template, parent_width, parent_height, lines)
       total_height = 0
       lines.each_with_index do |line, line_index|
         desired_height =
@@ -148,4 +166,3 @@ module RubyJard
 end
 
 # rubocop:enable Metrics/MethodLength
-# rubocop:enable Metrics/CyclomaticComplexity

data/lib/ruby_jard/layout_picker.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Pick layout smartly depending on current window height and width
+  class LayoutPicker
+    def initialize(width, height, layouts: RubyJard::Layouts, config: RubyJard.config)
+      @width = width
+      @height = height
+      @layouts = layouts
+      @config = config
+    end
+
+    def pick
+      unless @config.layout.nil?
+        return @layouts[@config.layout] || @layouts.fallback_layout
+      end
+
+      @layouts.each do |_name, 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
+      @layouts.fallback_layout
+    end
+  end
+end

data/lib/ruby_jard/layouts.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'ruby_jard/layout'
+require 'ruby_jard/templates/layout_template'
+require 'ruby_jard/templates/screen_template'
+require 'ruby_jard/layout_picker'
+require 'ruby_jard/layout_calculator'
+
+module RubyJard
+  ##
+  # Layouts registry.
+  class Layouts
+    class << self
+      extend Forwardable
+      def_delegators :instance, :fallback_layout, :add_layout, :[], :get, :each
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    attr_reader :fallback_layout
+
+    def initialize(fallback_layout = RubyJard::Layouts::WideLayout)
+      @layout_registry = {}
+      @fallback_layout = fallback_layout
+    end
+
+    def add_layout(name, layout_class)
+      unless layout_class.is_a?(RubyJard::Templates::LayoutTemplate)
+        raise RubyJard::Error, "#{layout_class} must be a #{RubyJard::Templates::LayoutTemplate}"
+      end
+
+      @layout_registry[name] = layout_class
+    end
+
+    def [](name)
+      @layout_registry[name.to_s.strip]
+    end
+    alias_method :get, :[]
+
+    def each(&block)
+      @layout_registry.each(&block)
+    end
+  end
+end
+
+# Registering order is also priority when picking layout
+require 'ruby_jard/layouts/wide_layout'
+require 'ruby_jard/layouts/narrow_vertical_layout'
+require 'ruby_jard/layouts/narrow_horizontal_layout'
+require 'ruby_jard/layouts/tiny_layout'

data/lib/ruby_jard/layouts/narrow_horizontal_layout.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    NarrowHorizontalLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_width: 80,
+      min_height: 10,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 100,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              width_ratio: 60
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :variables,
+              width_ratio: 40
+            )
+          ]
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('narrow-horizontal', RubyJard::Layouts::NarrowHorizontalLayout)

data/lib/ruby_jard/layouts/narrow_vertical_layout.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    NarrowVerticalLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_width: 40,
+      min_height: 24,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 100,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              height_ratio: 60
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :variables,
+              height_ratio: 40
+            )
+          ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 2,
+          screen: :menu
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('narrow-vertical', RubyJard::Layouts::NarrowVerticalLayout)

data/lib/ruby_jard/layouts/tiny_layout.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyJard
+  class Layouts
+    TinyLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_height: 10,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 80,
+          width_ratio: 100,
+          min_height: 7,
+          fill_height: true,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              height_ratio: 100
+            )
+          ]
+        )
+      ]
+    )
+  end
+end
+RubyJard::Layouts.add_layout('tiny', RubyJard::Layouts::TinyLayout)

data/lib/ruby_jard/layouts/wide_layout.rb

@@ -1,26 +1,24 @@
 # frozen_string_literal: true
 
 module RubyJard
-  module Layouts
+  class Layouts
     WideLayout = RubyJard::Templates::LayoutTemplate.new(
       min_width: 120,
-      min_height: 10,
-      fill_width: true,
+      min_height: 24,
+      fill_height: false,
       children: [
         RubyJard::Templates::LayoutTemplate.new(
           height_ratio: 80,
           width_ratio: 50,
-          min_height: 7,
-          fill_height: true,
           children: [
             RubyJard::Templates::ScreenTemplate.new(
               screen: :source,
-              height_ratio: 60
+              height_ratio: 70,
+              adjust_mode: :expand
             ),
             RubyJard::Templates::ScreenTemplate.new(
-              screen: :variables,
-              width_ratio: 100,
-              height_ratio: 40,
+              screen: :backtrace,
+              height_ratio: 30,
               min_height: 3
             )
           ]
@@ -28,17 +26,16 @@ module RubyJard
         RubyJard::Templates::LayoutTemplate.new(
           height_ratio: 80,
           width_ratio: 50,
-          fill_height: true,
           children: [
             RubyJard::Templates::ScreenTemplate.new(
-              screen: :backtrace,
-              height_ratio: 50,
-              fill_height: true
+              screen: :variables,
+              height_ratio: 80,
+              adjust_mode: :expand
             ),
             RubyJard::Templates::ScreenTemplate.new(
               screen: :threads,
-              height_ratio: 50,
-              fill_height: true
+              height_ratio: 20,
+              min_height: 3
             )
           ]
         ),
@@ -50,3 +47,4 @@ module RubyJard
     )
   end
 end
+RubyJard::Layouts.add_layout('wide', RubyJard::Layouts::WideLayout)

data/lib/ruby_jard/pager.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Override Pry's pager system. Again, Pry doesn't support customizing pager. So...
+  class Pager
+    def initialize(pry_instance)
+      @pry_instance = pry_instance
+    end
+
+    def page(text)
+      open do |pager|
+        pager << text
+      end
+    end
+
+    def open(options = {})
+      pager = LessPager.new(@pry_instance, **options)
+      yield pager
+    rescue Pry::Pager::StopPaging
+      # Ignore
+    ensure
+      pager.close
+    end
+
+    private
+
+    def enabled?
+      !!@enabled
+    end
+
+    ##
+    # Pager using GNU Less
+    class LessPager < Pry::Pager::NullPager
+      def initialize(pry_instance, force_open: false, pager_start_at_the_end: false)
+        super(pry_instance.output)
+        @pry_instance = pry_instance
+        @buffer = ''
+
+        @pager_start_at_the_end = pager_start_at_the_end
+
+        @tracker = Pry::Pager::PageTracker.new(height, width)
+        @pager = force_open ? open_pager : nil
+      end
+
+      def write(str)
+        if invoked_pager?
+          write_into_pager str
+        else
+          @tracker.record str
+          @buffer += str
+          if @tracker.page?
+            @pager = open_pager
+            write_into_pager(@buffer)
+          end
+        end
+      rescue Errno::EPIPE
+        raise Pry::Pager::StopPaging
+      end
+
+      def close
+        if invoked_pager?
+          @pager.close
+          @pry_instance.exec_hook :after_pager, self
+
+          prompt = @pry_instance.prompt.wait_proc.call
+          # TODO: should show this tip even pager not invoked, when the size exceed a certain height
+          @out.puts "#{prompt}Tips: You can use `list` command to show back debugger screens"
+        else
+          @out.write @buffer
+        end
+      end
+
+      def invoked_pager?
+        @pager
+      end
+
+      def open_pager
+        @pry_instance.exec_hook :before_pager, self
+        less_command = ['less', '-R', '-X']
+        less_command << '+G' if @pager_start_at_the_end
+
+        IO.popen(
+          less_command.join(' '), 'w',
+          out: @pry_instance.output, err: @pry_instance.output
+        )
+      end
+
+      def write_into_pager(str)
+        return unless invoked_pager?
+
+        @pager.write str.encode('UTF-8', undef: :replace)
+      end
+    end
+  end
+end

data/lib/ruby_jard/repl_processor.rb

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
 
+require 'ruby_jard/commands/validation_helpers'
+require 'ruby_jard/commands/continue_command'
+require 'ruby_jard/commands/exit_command'
+require 'ruby_jard/commands/up_command'
+require 'ruby_jard/commands/down_command'
+require 'ruby_jard/commands/next_command'
+require 'ruby_jard/commands/step_command'
+require 'ruby_jard/commands/step_out_command'
+require 'ruby_jard/commands/frame_command'
+require 'ruby_jard/commands/list_command'
+require 'ruby_jard/commands/jard_command'
+
 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)
@@ -10,8 +22,8 @@ module RubyJard
   # repl, and triggers Byebug debugger if needed.
   #
   class ReplProcessor < Byebug::CommandProcessor
-    def initialize(context, interface = LocalInterface.new)
-      super(context, interface)
+    def initialize(context, *args)
+      super(context, *args)
       @repl_proxy = RubyJard::ReplProxy.new(
         key_bindings: RubyJard.global_key_bindings
       )
@@ -21,7 +33,7 @@ module RubyJard
       process_commands_with_lock
     end
 
-    def at_return(_)
+    def at_return(_return_value)
       process_commands_with_lock
     end
 
@@ -61,44 +73,39 @@ module RubyJard
       raise
     end
 
-    def handle_next_command(_options = {})
-      Byebug.current_context.step_over(1, Byebug.current_context.frame.pos)
+    def handle_next_command(options = {})
+      times = options[:times] || 1
+      Byebug.current_context.step_over(times, Byebug.current_context.frame.pos)
       proceed!
     end
 
-    def handle_step_command(_options = {})
-      Byebug.current_context.step_into(1, Byebug.current_context.frame.pos)
+    def handle_step_command(options = {})
+      times = options[:times] || 1
+      Byebug.current_context.step_into(times, Byebug.current_context.frame.pos)
       proceed!
     end
 
-    def handle_step_out_command(_options = {})
-      # TODO: handle c-frame and out of range frames
-      Byebug.current_context.frame = 1
-      proceed!
+    def handle_step_out_command(options = {})
+      times = options[:times] || 1
+
+      next_frame = up_n_frames(Byebug.current_context.frame.pos, times)
+      Byebug.current_context.frame = next_frame
       Byebug.current_context.step_over(1, Byebug.current_context.frame.pos)
       proceed!
     end
 
-    def handle_up_command(_options = {})
-      next_frame = [
-        Byebug.current_context.frame.pos + 1,
-        Byebug.current_context.backtrace.length - 1
-      ].min
-      while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
-            next_frame < Byebug.current_context.backtrace.length - 1
-        next_frame += 1
-      end
+    def handle_up_command(options = {})
+      times = options[:times] || 1
+
+      next_frame = up_n_frames(Byebug.current_context.frame.pos, times)
       Byebug.current_context.frame = next_frame
       proceed!
       process_commands
     end
 
-    def handle_down_command(_options = {})
-      next_frame = [Byebug.current_context.frame.pos - 1, 0].max
-      while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
-            next_frame > 0
-        next_frame -= 1
-      end
+    def handle_down_command(options = {})
+      times = options[:times] || 1
+      next_frame = down_n_frames(Byebug.current_context.frame.pos, times)
       Byebug.current_context.frame = next_frame
       proceed!
       process_commands
@@ -107,7 +114,7 @@ module RubyJard
     def handle_frame_command(options)
       next_frame = options[:frame].to_i
       if Byebug::Frame.new(Byebug.current_context, next_frame).c_frame?
-        puts "Error: Frame #{next_frame} is a c-frame. Not able to inspect c layer!"
+        RubyJard::ScreenManager.puts "Error: Frame #{next_frame} is a c-frame. Not able to inspect c layer!"
         process_commands(false)
       else
         Byebug.current_context.frame = next_frame
@@ -117,7 +124,11 @@ module RubyJard
     end
 
     def handle_continue_command(_options = {})
-      # Do nothing
+      RubyJard::ScreenManager.puts '► ► Program resumed ► ►'
+    end
+
+    def handle_exit_command(_options = {})
+      Kernel.exit
     end
 
     def handle_key_binding_command(options = {})
@@ -134,9 +145,28 @@ module RubyJard
       process_commands
     end
 
-    def handle_color_scheme_command(options = {})
-      RubyJard.config.color_scheme = options[:color_scheme]
-      process_commands
+    def up_n_frames(current_frame, times)
+      next_frame = current_frame
+      times.times do
+        next_frame = [next_frame + 1, Byebug.current_context.backtrace.length - 1].min
+        while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
+              next_frame < Byebug.current_context.backtrace.length - 1
+          next_frame += 1
+        end
+      end
+      next_frame
+    end
+
+    def down_n_frames(current_frame, times)
+      next_frame = current_frame
+      times.times do
+        next_frame = [next_frame - 1, 0].max
+        while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
+              next_frame > 0
+          next_frame -= 1
+        end
+      end
+      next_frame
     end
   end
 end