charming 0.1.2 → 0.1.4

data/lib/charming/presentation/layout/split.rb

@@ -1,133 +1,138 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Layout
-      # Split divides a parent Rect among its child nodes horizontally or vertically.
-      # Children with a configured `width`/`height` are placed at that fixed size; children
-      # without a fixed size share the remaining space according to their `grow` weight.
-      class Split
-        # The fixed width/height of the split (when set) and the grow weight for the split itself.
-        attr_reader :width, :height, :grow
-
-        # *direction* is `:horizontal` or `:vertical`. *gap* (in cells) separates children.
-        # *width*/*height* are optional fixed dimensions for the split as a whole.
-        # *grow* is the weight for distributing remaining space (used when this Split is a
-        # child of another Split).
-        def initialize(direction:, gap: 0, width: nil, height: nil, grow: nil)
-          @direction = direction.to_sym
-          @gap = gap.to_i
-          @width = width
-          @height = height
-          @grow = grow
-          @children = []
-        end
+  module Layout
+    # Split divides a parent Rect among its child nodes horizontally or vertically.
+    # Children with a configured `width`/`height` are placed at that fixed size; children
+    # without a fixed size share the remaining space according to their `grow` weight.
+    class Split
+      # The fixed width/height of the split (when set) and the grow weight for the split itself.
+      attr_reader :width, :height, :grow
+
+      # *direction* is `:horizontal` or `:vertical`. *gap* (in cells) separates children.
+      # *width*/*height* are optional fixed dimensions for the split as a whole.
+      # *grow* is the weight for distributing remaining space (used when this Split is a
+      # child of another Split).
+      def initialize(direction:, gap: 0, width: nil, height: nil, grow: nil)
+        @direction = direction.to_sym
+        @gap = gap.to_i
+        @width = width
+        @height = height
+        @grow = grow
+        @children = []
+      end
 
-        # Appends *node* (a child Split or Pane) to this Split.
-        def add_child(node)
-          children << node
-        end
+      # Appends *node* (a child Split or Pane) to this Split.
+      def add_child(node)
+        children << node
+      end
 
-        # Returns the flattened list of focusable names from all child nodes.
-        def focusable_names
-          children.flat_map(&:focusable_names)
-        end
+      # Returns the flattened list of focusable names from all child nodes.
+      def focusable_names
+        children.flat_map(&:focusable_names)
+      end
 
-        # Renders each child into its own sub-rect, then overlays them on a blank canvas
-        # of the parent's dimensions.
-        def render(rect)
-          frame = UI.place("", width: rect.width, height: rect.height)
+      # Returns all named pane mouse targets in this split, preserving declaration order.
+      def mouse_targets(rect)
+        child_rects(rect).zip(children).flat_map do |child_rect, child|
+          child.respond_to?(:mouse_targets) ? child.mouse_targets(child_rect) : []
+        end
+      end
 
-          child_rects(rect).zip(children).each do |child_rect, child|
-            frame = UI.overlay(frame, child.render(child_rect), top: child_rect.y - rect.y, left: child_rect.x - rect.x)
-          end
+      # Renders each child into its own sub-rect, then overlays them on a blank canvas
+      # of the parent's dimensions.
+      def render(rect)
+        frame = UI.place("", width: rect.width, height: rect.height)
 
-          frame
+        child_rects(rect).zip(children).each do |child_rect, child|
+          frame = UI.overlay(frame, child.render(child_rect), top: child_rect.y - rect.y, left: child_rect.x - rect.x)
         end
 
-        private
-
-        # The split direction (`:horizontal` or `:vertical`) and the inter-child gap.
-        attr_reader :direction, :gap, :children
+        frame
+      end
 
-        # Returns an array of child rects sized according to each child's fixed dimensions
-        # and grow weights. Raises ArgumentError when *direction* is neither horizontal nor vertical.
-        def child_rects(rect)
-          return horizontal_rects(rect) if direction == :horizontal
-          return vertical_rects(rect) if direction == :vertical
+      private
 
-          raise ArgumentError, "unknown split direction: #{direction.inspect}"
-        end
+      # The split direction (`:horizontal` or `:vertical`) and the inter-child gap.
+      attr_reader :direction, :gap, :children
 
-        # Computes per-child rects for a horizontal split.
-        def horizontal_rects(rect)
-          sizes = child_sizes(axis: :horizontal, available: rect.width)
-          left = rect.x
+      # Returns an array of child rects sized according to each child's fixed dimensions
+      # and grow weights. Raises ArgumentError when *direction* is neither horizontal nor vertical.
+      def child_rects(rect)
+        return horizontal_rects(rect) if direction == :horizontal
+        return vertical_rects(rect) if direction == :vertical
 
-          sizes.map do |width|
-            child_rect = Rect.new(x: left, y: rect.y, width: width, height: rect.height)
-            left += width + gap
-            child_rect
-          end
-        end
+        raise ArgumentError, "unknown split direction: #{direction.inspect}"
+      end
 
-        # Computes per-child rects for a vertical split.
-        def vertical_rects(rect)
-          sizes = child_sizes(axis: :vertical, available: rect.height)
-          top = rect.y
+      # Computes per-child rects for a horizontal split.
+      def horizontal_rects(rect)
+        sizes = child_sizes(axis: :horizontal, available: rect.width)
+        left = rect.x
 
-          sizes.map do |height|
-            child_rect = Rect.new(x: rect.x, y: top, width: rect.width, height: height)
-            top += height + gap
-            child_rect
-          end
+        sizes.map do |width|
+          child_rect = Rect.new(x: left, y: rect.y, width: width, height: rect.height)
+          left += width + gap
+          child_rect
         end
+      end
 
-        # Computes the size of each child along the *axis* given the *available* cells.
-        # Subtracts the total gap, allocates fixed sizes first, and distributes the remainder
-        # among flexible (non-fixed) children by their grow weights.
-        def child_sizes(axis:, available:)
-          gap_size = gap * [children.length - 1, 0].max
-          available_for_children = [available - gap_size, 0].max
-          fixed = children.map { |child| fixed_size(child, axis) }
-          flexible_indexes = fixed.each_index.select { |index| fixed[index].nil? }
-          sizes = fixed.map { |size| size&.to_i }
-          remaining = [available_for_children - sizes.compact.sum, 0].max
-
-          distribute_remaining(sizes, flexible_indexes, remaining)
-        end
+      # Computes per-child rects for a vertical split.
+      def vertical_rects(rect)
+        sizes = child_sizes(axis: :vertical, available: rect.height)
+        top = rect.y
 
-        # Returns the fixed size of *child* along *axis* (`:horizontal` reads width, `:vertical` reads height).
-        def fixed_size(child, axis)
-          (axis == :horizontal) ? child.width : child.height
+        sizes.map do |height|
+          child_rect = Rect.new(x: rect.x, y: top, width: rect.width, height: height)
+          top += height + gap
+          child_rect
         end
+      end
 
-        # Distributes the *remaining* cells across *flexible_indexes* by grow weight, with the
-        # last flexible child absorbing any rounding remainder.
-        def distribute_remaining(sizes, flexible_indexes, remaining)
-          return sizes.map { |size| size || 0 } if flexible_indexes.empty?
+      # Computes the size of each child along the *axis* given the *available* cells.
+      # Subtracts the total gap, allocates fixed sizes first, and distributes the remainder
+      # among flexible (non-fixed) children by their grow weights.
+      def child_sizes(axis:, available:)
+        gap_size = gap * [children.length - 1, 0].max
+        available_for_children = [available - gap_size, 0].max
+        fixed = children.map { |child| fixed_size(child, axis) }
+        flexible_indexes = fixed.each_index.select { |index| fixed[index].nil? }
+        sizes = fixed.map { |size| size&.to_i }
+        remaining = [available_for_children - sizes.compact.sum, 0].max
+
+        distribute_remaining(sizes, flexible_indexes, remaining)
+      end
+
+      # Returns the fixed size of *child* along *axis* (`:horizontal` reads width, `:vertical` reads height).
+      def fixed_size(child, axis)
+        (axis == :horizontal) ? child.width : child.height
+      end
 
-          total_grow = flexible_indexes.sum { |index| grow_weight(children[index]) }
-          used = 0
+      # Distributes the *remaining* cells across *flexible_indexes* by grow weight, with the
+      # last flexible child absorbing any rounding remainder.
+      def distribute_remaining(sizes, flexible_indexes, remaining)
+        return sizes.map { |size| size || 0 } if flexible_indexes.empty?
 
-          flexible_indexes.each_with_index do |index, flexible_index|
-            size = if flexible_index == flexible_indexes.length - 1
-              remaining - used
-            else
-              (remaining * grow_weight(children[index]) / total_grow).floor
-            end
+        total_grow = flexible_indexes.sum { |index| grow_weight(children[index]) }
+        used = 0
 
-            sizes[index] = size
-            used += size
+        flexible_indexes.each_with_index do |index, flexible_index|
+          size = if flexible_index == flexible_indexes.length - 1
+            remaining - used
+          else
+            (remaining * grow_weight(children[index]) / total_grow).floor
           end
 
-          sizes
+          sizes[index] = size
+          used += size
         end
 
-        # Returns the grow weight of *child*, defaulting to 1 when unset.
-        def grow_weight(child)
-          [child.grow.to_i, 1].max
-        end
+        sizes
+      end
+
+      # Returns the grow weight of *child*, defaulting to 1 when unset.
+      def grow_weight(child)
+        [child.grow.to_i, 1].max
       end
     end
   end

data/lib/charming/presentation/layout.rb

@@ -1,43 +1,41 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    # Layout contains generic screen-size math and composition helpers. It is
-    # intentionally unaware of application shells such as sidebars or nav panes.
-    module Layout
-      module_function
+  # Layout contains generic screen-size math and composition helpers. It is
+  # intentionally unaware of application shells such as sidebars or nav panes.
+  module Layout
+    module_function
 
-      def clamp_size(value, min: nil, max: nil)
-        size = value.to_i
-        size = [size, min].max if min
-        size = [size, max].min if max
-        size
-      end
+    def clamp_size(value, min: nil, max: nil)
+      size = value.to_i
+      size = [size, min].max if min
+      size = [size, max].min if max
+      size
+    end
 
-      def available_width(screen, reserved: 0, min: nil, max: nil)
-        clamp_size(screen.width - reserved, min: min, max: max)
-      end
+    def available_width(screen, reserved: 0, min: nil, max: nil)
+      clamp_size(screen.width - reserved, min: min, max: max)
+    end
 
-      def available_height(screen, reserved: 0, min: nil, max: nil)
-        clamp_size(screen.height - reserved, min: min, max: max)
-      end
+    def available_height(screen, reserved: 0, min: nil, max: nil)
+      clamp_size(screen.height - reserved, min: min, max: max)
+    end
 
-      def stack_or_row(*blocks, narrow:, gap: 0)
-        if narrow
-          UI.join_vertical(*blocks, gap: gap)
-        else
-          UI.join_horizontal(*blocks, gap: gap)
-        end
+    def stack_or_row(*blocks, narrow:, gap: 0)
+      if narrow
+        UI.join_vertical(*blocks, gap: gap)
+      else
+        UI.join_horizontal(*blocks, gap: gap)
       end
+    end
 
-      def selected_window_start(selected_index:, item_count:, window_size:)
-        count = item_count.to_i
-        size = [window_size.to_i, 1].max
-        selected = selected_index.to_i.clamp(0, [count - 1, 0].max)
-        max_start = [count - size, 0].max
+    def selected_window_start(selected_index:, item_count:, window_size:)
+      count = item_count.to_i
+      size = [window_size.to_i, 1].max
+      selected = selected_index.to_i.clamp(0, [count - 1, 0].max)
+      max_start = [count - size, 0].max
 
-        (selected - size + 1).clamp(0, max_start)
-      end
+      (selected - size + 1).clamp(0, max_start)
     end
   end
 end

data/lib/charming/presentation/markdown/render_context.rb

@@ -1,21 +1,37 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Markdown
-      # RenderContext carries the state needed to render nested Markdown blocks: the current
-      # list nesting depth (used for indentation) and the wrap width.
-      RenderContext = Data.define(:list_depth, :width) do
-        # Builds a new RenderContext with the given *width* and optional starting *list_depth*.
-        def self.from(width:, list_depth: 0)
-          new(list_depth: list_depth, width: width)
-        end
+  module Markdown
+    # RenderContext carries render-time state that needs to flow down the Markdown AST.
+    RenderContext = Data.define(:width, :list_depth, :style, :current_style, :base_url, :source_lines) do
+      def self.from(width:, style:, base_url: nil, source_lines: [], list_depth: 0, current_style: nil)
+        new(
+          width: width,
+          list_depth: list_depth,
+          style: style,
+          current_style: current_style || style[:document],
+          base_url: base_url,
+          source_lines: source_lines
+        )
+      end
+
+      def with(width: self.width, list_depth: self.list_depth, current_style: self.current_style)
+        self.class.new(
+          width: width,
+          list_depth: list_depth,
+          style: style,
+          current_style: current_style,
+          base_url: base_url,
+          source_lines: source_lines
+        )
+      end
+
+      def nested_list(width: self.width)
+        with(width: width, list_depth: list_depth + 1)
+      end
 
-        # Returns a derived context with the list depth incremented by *depth_increment*
-        # and the wrap width overridden to *width* (defaults to the current width).
-        def nested(depth_increment: 0, width: self.width)
-          self.class.new(list_depth: list_depth + depth_increment, width: width)
-        end
+      def inherit(style_name)
+        current_style.inherit_visual(style[style_name])
       end
     end
   end