ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/frame.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # This class is a wrapper for Byebug::Frame. This class prevents direct
+  # access to Byebug's internal data structure, provides some more helpers
+  # and make Jard easier to test.
+  class Frame
+    attr_reader :real_pos
+    attr_writer :visible
+    attr_accessor :virtual_pos
+
+    def initialize(context, real_pos, virtual_pos: nil)
+      @context = context
+      @real_pos = real_pos
+      @virtual_pos = virtual_pos
+
+      @visible = true
+    end
+
+    def visible?
+      @visible == true
+    end
+
+    def hidden?
+      @visible == false
+    end
+
+    def frame_file
+      @context.frame_file(@real_pos)
+    end
+
+    def frame_line
+      @context.frame_line(@real_pos)
+    end
+
+    def frame_location
+      frame_backtrace = @context.backtrace[@real_pos]
+      return nil if frame_backtrace.nil?
+
+      frame_backtrace.first
+    end
+
+    def frame_self
+      @context.frame_self(@real_pos)
+    end
+
+    def frame_class
+      @context.frame_class(@real_pos)
+    end
+
+    def frame_binding
+      @context.frame_binding(@real_pos)
+    end
+
+    def frame_method
+      @context.frame_method(@real_pos)
+    end
+
+    def c_frame?
+      frame_binding.nil?
+    end
+
+    def thread
+      @context.thread
+    end
+  end
+end

data/lib/ruby_jard/key_binding.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # A key binding object
+  class KeyBinding
+    attr_reader :sequence, :action
+
+    def initialize(sequence, action)
+      @sequence = sequence
+      @action = action
+    end
+  end
+end

data/lib/ruby_jard/key_bindings.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Register custom key bindings and corresponding action, try to
+  # match a key binding sequence from input.
+  # As this class is performant-sensitive, a lookup tree is built
+  # and updated whenever a new key is added.
+  class KeyBindings
+    attr_reader :indexes
+
+    def initialize
+      @key_bindings = []
+      @indexes = {}
+    end
+
+    def to_a
+      @key_bindings.dup
+    end
+
+    def push(sequence, action)
+      if sequence.is_a?(Array)
+        sequence.each { |s| push(s, action) }
+        return
+      end
+
+      raise RubyJard::Error if sequence.to_s.empty?
+
+      key_binding = RubyJard::KeyBinding.new(sequence, action)
+      reindex(key_binding)
+      @key_bindings << key_binding
+    end
+
+    def match(&read_key)
+      raise RubyJard::Error, 'This method requires a block' unless block_given?
+
+      buffer = ''
+      node = @indexes
+      loop do
+        keys = read_key.call
+        if keys.nil?
+          # No more key. Match the current node
+          if node[nil].nil?
+            return buffer
+          else
+            return node[nil]
+          end
+        end
+
+        buffer += keys
+        keys.bytes.each do |byte|
+          if node[byte].is_a?(Hash)
+            # Not sure, continue to match
+            node = node[byte]
+          elsif node[byte].nil?
+            # It's sure that no more bindings to match
+            return buffer
+          elsif buffer == node[byte].sequence
+            # Exact match current key binding
+            return node[byte]
+          else
+            return buffer
+          end
+        end
+      end
+    end
+
+    private
+
+    def reindex(key_binding)
+      parent = nil
+      node = @indexes
+      bytes = key_binding.sequence.bytes
+      bytes.each do |byte|
+        if node[byte].nil?
+          node[byte] = {}
+        elsif node[byte].is_a?(KeyBinding)
+          return if node[byte].sequence == key_binding.sequence
+
+          # Propagate the tree node
+          node[byte] = {
+            nil => node[byte]
+          }
+        end
+        parent = node
+        node = node[byte]
+      end
+
+      if node.empty?
+        parent[bytes.last] = key_binding
+      else
+        node[nil] = key_binding
+      end
+    end
+  end
+end

data/lib/ruby_jard/keys.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # A helper class to store pre-defined keys and key bindings
+  class Keys
+    # X-Term: https://invisible-island.net/xterm/xterm-function-keys.html
+    END_LINE = ["\n", "\r\n", "\r"].freeze
+    CTRL_C = "\u0003"
+    CTRL_D = "\u0004"
+
+    F1 = "\eOP"
+    F2 = "\eOQ"
+    F3 = "\eOR"
+    F4 = "\eOS"
+    F5 = "\e[15~"
+    F6 = "\e[17~"
+    F7 = "\e[18~"
+    F8 = "\e[19~"
+    F9 = "\e[20~"
+    F10 = "\e[21~"
+    F11 = "\e[23~"
+    F12 = "\e[24~"
+
+    SHIFT_F1 = "\e1;2P"
+    SHIFT_F2 = "\e1;2Q"
+    SHIFT_F3 = "\e1;2R"
+    SHIFT_F4 = "\e1;2S"
+    SHIFT_F5 = "\e[15;2~"
+    SHIFT_F6 = "\e[17;2~"
+    SHIFT_F7 = "\e[18;2~"
+    SHIFT_F8 = "\e[19;2~"
+    SHIFT_F9 = "\e[20;2~"
+    SHIFT_F10 = "\e[21;2~"
+    SHIFT_F11 = "\e[23;2~"
+    SHIFT_F12 = "\e[24;2~"
+    DEFAULT_KEY_BINDINGS = {
+      F2       => (ACTION_FILTER   = :switch_filter),
+      F5       => (ACTION_LIST     = :list),
+      F6       => (ACTION_UP       = :up),
+      SHIFT_F6 => (ACTION_DOWN     = :down),
+      F7       => (ACTION_STEP     = :step),
+      SHIFT_F7 => (ACTION_STEP_OUT = :step_out),
+      F8       => (ACTION_NEXT     = :next),
+      F9       => (ACTION_CONTINUE = :continue)
+    }.freeze
+  end
+end

data/lib/ruby_jard/layout.rb

@@ -2,98 +2,27 @@
 
 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.
+  # Data object to store calculated layout
   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)
+    attr_accessor :template, :parent_template,
+                  :box_width, :box_height, :box_x, :box_y,
+                  :width, :height, :x, :y
+
+    def initialize(
+      template: nil, parent_template: nil,
+      width: 0, height: 0, x: 0, y: 0,
+      box_width: 0, box_height: 0, box_x: 0, box_y: 0
+    )
       @template = template
+      @box_width = box_width
+      @box_height = box_height
+      @box_x = box_x
+      @box_y = box_y
       @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
+      @x = x
+      @y = y
+      @parent_template = parent_template
     end
   end
 end

data/lib/ruby_jard/layout_calculator.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength
+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 LayoutCalculator
+    def self.calculate(**args)
+      new(**args).calculate
+    end
+
+    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, nil)
+      @layouts
+    end
+
+    private
+
+    def calculate_layout(template, width, height, x, y, parent_template)
+      if template.is_a?(RubyJard::Templates::ScreenTemplate)
+        layout = RubyJard::Layout.new(
+          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
+        )
+        adjust_layout_overlap(layout)
+        @layouts << layout
+      else
+        overflow_width = 0
+        child_x = x
+        child_y = y
+        max_height = 0
+
+        lines = [[]]
+        visible_children(template).each do |child_template|
+          child_height = calculate_child_height(child_template, height)
+          child_width = calculate_child_width(child_template, width)
+
+          overflow_width += child_width
+          # Overflow. Break to next line
+          if overflow_width > width
+            child_y += max_height
+            child_x = x
+            overflow_width = 0
+            max_height = child_height
+            lines << []
+          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_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, 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
+        layout.x -= 1
+        layout.box_width += 1
+        layout.box_x -= 1
+      end
+
+      if layout.box_y != 0
+        layout.height += 1
+        layout.y -= 1
+        layout.box_height += 1
+        layout.box_y -= 1
+      end
+    end
+
+    # 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 =
+          if line_index == lines.length - 1
+            parent_height - total_height
+          else
+            line.map { |_child_template, _child_width, child_height, _x, _y| child_height }.max
+          end
+
+        total_width = 0
+        line.map!.with_index do |(child_template, child_width, child_height, x, y), index|
+          child_height = desired_height if parent_template.fill_height
+          child_width = parent_width - total_width if parent_template.fill_width && index == line.length - 1
+          total_width += child_width
+          [child_template, child_width, child_height, x, y]
+        end
+        total_height += desired_height
+      end
+    end
+
+    def calculate_child_height(child_template, parent_height)
+      height =
+        if !child_template.height.nil?
+          child_template.height
+        elsif child_template.height_ratio.nil?
+          parent_height
+        else
+          parent_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
+
+      height
+    end
+
+    def calculate_child_width(child_template, parent_width)
+      width =
+        if !child_template.width.nil?
+          child_template.width
+        elsif child_template.width_ratio.nil?
+          parent_width
+        else
+          parent_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
+
+      width
+    end
+  end
+end
+
+# rubocop:enable Metrics/MethodLength