ruby_jard 0.1.0 → 0.2.0

data/lib/ruby_jard/decorators/source_decorator.rb

@@ -25,7 +25,7 @@ module RubyJard
         end
 
         @window_start = @lineno - @window / 2
-        @window_start = 0 if @window_start.negative?
+        @window_start = 1 if @window_start.negative?
         @window_end = @window_start + @window
 
         until file.eof?

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,49 @@
+# 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~"
+
+    # rubocop:disable Layout/HashAlignment
+    DEFAULT_KEY_BINDINGS = {
+      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
+    # rubocop:enable Layout/HashAlignment
+  end
+end

data/lib/ruby_jard/layout.rb

@@ -1,99 +1,111 @@
 # 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,
   # 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
+    def self.calculate(**args)
+      new(**args).calculate
     end
 
-    attr_accessor :width, :height, :screen, :children
-
-    def initialize(template:, width: 0, height: 0)
-      @template = template
+    def initialize(layout:, width: 0, height: 0, x: 0, y: 0)
+      @layout = layout
       @width = width
       @height = height
-      @screen = nil
-      @children = []
+      @x = x
+      @y = y
     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
+    def calculate
+      screens = []
+      calculate_layout(screens, @layout, @width, @height, @x, @y)
+      screens
     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
+    def calculate_layout(screens, layout, width, height, x, y)
+      if layout.is_a?(RubyJard::Templates::ScreenTemplate)
+        screens << [layout, width, height, x, y]
+      else
+        total_height = 0
+        total_width = 0
+        overflow_width = 0
+        child_x = x
+        child_y = y
+        max_height = 0
+
+        layout.children.each_with_index do |child_layout, index|
+          child_height = calculate_child_height(child_layout, layout, height, index, total_height)
+          child_width = calculate_child_width(child_layout, layout, width, index, total_width)
+
+          calculate_layout(screens, child_layout, child_width, child_height, child_x, child_y)
+
+          overflow_width += child_width
+          max_height = child_height if max_height < child_height
+          # Overflow. Break to next line
+          if overflow_width >= width
+            child_y += max_height - 1
+            child_x = x
+            overflow_width = 0
+            max_height = 0
+          else
+            child_x += child_width - 1
+          end
+
+          total_width += child_width - 1
+          total_height += child_height - 1
+        end
       end
     end
 
-    def calculate_child_height(child_template, index, total_height)
+    def calculate_child_height(child_layout, parent_layout, parent_height, index, total_height)
       height =
-        if !child_template.height.nil?
-          child_template.height
-        elsif child_template.height_ratio.nil?
-          @height
+        if !child_layout.height.nil?
+          child_layout.height
+        elsif child_layout.height_ratio.nil?
+          parent_height
         else
-          @height * child_template.height_ratio / 100
+          parent_height * child_layout.height_ratio / 100
         end
 
-      unless child_template.min_height.nil?
-        height = child_template.min_height if height < child_template.min_height
+      unless child_layout.min_height.nil?
+        height = child_layout.min_height if height < child_layout.min_height
       end
 
-      if @template.fill_height && index == @template.children.length - 1
-        height = @height - total_height if height < (@height - total_height)
+      if parent_layout.fill_height && index == parent_layout.children.length - 1
+        height = parent_height - total_height if height < (parent_height - total_height)
       end
 
       height
     end
 
-    def calculate_child_width(child_template, index, total_width)
+    def calculate_child_width(child_layout, parent_layout, parent_width, index, total_width)
       width =
-        if !child_template.width.nil?
-          child_template.width
-        elsif child_template.width_ratio.nil?
-          @width
+        if !child_layout.width.nil?
+          child_layout.width
+        elsif child_layout.width_ratio.nil?
+          parent_width
         else
-          @width * child_template.width_ratio / 100
+          parent_width * child_layout.width_ratio / 100
         end
 
-      unless child_template.min_width.nil?
-        width = child_template.min_width if width < child_template.min_width
+      unless child_layout.min_width.nil?
+        width = child_layout.min_width if width < child_layout.min_width
       end
 
-      if @template.fill_width && index == @template.children.length - 1
-        width = @width - total_width if width < (@width - total_width)
+      if parent_layout.fill_width && index == parent_layout.children.length - 1
+        width = parent_width - total_width if width < (parent_width - total_width)
       end
 
       width
     end
   end
 end
+
+# rubocop:enable Metrics/MethodLength
+# rubocop:enable Metrics/CyclomaticComplexity

data/lib/ruby_jard/layouts/wide_layout.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubyJard
+  module Layouts
+    WideLayout = RubyJard::Templates::LayoutTemplate.new(
+      min_width: 120,
+      min_height: 10,
+      fill_width: true,
+      fill_height: false,
+      children: [
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 50,
+          min_height: 7,
+          fill_width: true,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :source,
+              width_ratio: 50,
+              row_template: RubyJard::Templates::RowTemplate.new(
+                columns: [
+                  RubyJard::Templates::ColumnTemplate.new(
+                    margin_right: 1,
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:mark, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:lineno)
+                    ]
+                  ),
+                  RubyJard::Templates::ColumnTemplate.new(
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:code)
+                    ]
+                  )
+                ]
+              )
+            ),
+            RubyJard::Templates::LayoutTemplate.new(
+              width_ratio: 50,
+              fill_height: true,
+              children: [
+                RubyJard::Templates::ScreenTemplate.new(
+                  screen: :variables,
+                  width_ratio: 100,
+                  height_ratio: 100,
+                  min_height: 3,
+                  row_template: RubyJard::Templates::RowTemplate.new(
+                    line_limit: 3,
+                    columns: [
+                      RubyJard::Templates::ColumnTemplate.new(
+                        spans: [
+                          RubyJard::Templates::SpanTemplate.new(:inline, margin_right: 1)
+                        ]
+                      ),
+                      RubyJard::Templates::ColumnTemplate.new(
+                        margin_right: 1,
+                        spans: [
+                          RubyJard::Templates::SpanTemplate.new(:type)
+                        ]
+                      ),
+                      RubyJard::Templates::ColumnTemplate.new(
+                        spans: [
+                          RubyJard::Templates::SpanTemplate.new(:name, margin_right: 1),
+                          RubyJard::Templates::SpanTemplate.new(:size, margin_right: 1),
+                          RubyJard::Templates::SpanTemplate.new(:indicator, margin_right: 1),
+                          RubyJard::Templates::SpanTemplate.new(:inspection)
+                        ]
+                      )
+                    ]
+                  )
+                )
+              ]
+            )
+          ]
+        ),
+        RubyJard::Templates::LayoutTemplate.new(
+          height_ratio: 30,
+          min_height: 3,
+          fill_width: true,
+          children: [
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :backtrace,
+              width_ratio: 50,
+              row_template: RubyJard::Templates::RowTemplate.new(
+                columns: [
+                  RubyJard::Templates::ColumnTemplate.new(
+                    margin_right: 1,
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:mark, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:frame_id)
+                    ]
+                  ),
+                  RubyJard::Templates::ColumnTemplate.new(
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:klass_label, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:label_preposition, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:method_label, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:path_preposition, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:path)
+                    ]
+                  )
+                ]
+              )
+            ),
+            RubyJard::Templates::ScreenTemplate.new(
+              screen: :threads,
+              width_ratio: 50,
+              row_template: RubyJard::Templates::RowTemplate.new(
+                columns: [
+                  RubyJard::Templates::ColumnTemplate.new(
+                    margin_right: 1,
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:mark, margin_right: 1),
+                      RubyJard::Templates::SpanTemplate.new(:thread_id)
+                    ]
+                  ),
+                  RubyJard::Templates::ColumnTemplate.new(
+                    margin_right: 1,
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:thread_status)
+                    ]
+                  ),
+                  RubyJard::Templates::ColumnTemplate.new(
+                    spans: [
+                      RubyJard::Templates::SpanTemplate.new(:thread_name)
+                    ]
+                  )
+                ]
+              )
+            )
+          ]
+        ),
+        RubyJard::Templates::ScreenTemplate.new(
+          height: 3,
+          screen: :menu
+        )
+      ]
+    )
+  end
+end