charming 0.1.2 → 0.1.3

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

@@ -1,133 +1,131 @@
 # 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
-
-        # Appends *node* (a child Split or Pane) to this Split.
-        def add_child(node)
-          children << node
-        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
 
-        # Returns the flattened list of focusable names from all child nodes.
-        def focusable_names
-          children.flat_map(&:focusable_names)
-        end
+      # Appends *node* (a child Split or Pane) to this Split.
+      def add_child(node)
+        children << node
+      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 the flattened list of focusable names from all child nodes.
+      def focusable_names
+        children.flat_map(&:focusable_names)
+      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/block_renderers.rb

@@ -1,119 +1,117 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Markdown
-      # BlockRenderer dispatches Kramdown block-level elements (paragraph, header, list,
-      # code block, etc.) to their individual rendering handlers. Handlers are built once
-      # at construction time as a frozen hash of element-type symbols to callables.
-      class BlockRenderer
-        # *renderer* is the parent Renderer (used to wrap text, render inlines, and look up styles).
-        def initialize(renderer:)
-          @renderer = renderer
-          build_handlers
-        end
+  module Markdown
+    # BlockRenderer dispatches Kramdown block-level elements (paragraph, header, list,
+    # code block, etc.) to their individual rendering handlers. Handlers are built once
+    # at construction time as a frozen hash of element-type symbols to callables.
+    class BlockRenderer
+      # *renderer* is the parent Renderer (used to wrap text, render inlines, and look up styles).
+      def initialize(renderer:)
+        @renderer = renderer
+        build_handlers
+      end
 
-        # Renders *element* using the handler registered for `element.type`. Unknown types
-        # fall through to `render_unknown`.
-        def render(element, context:)
-          handler = @handlers[element.type] || method(:render_unknown)
-          handler.call(element, context)
-        end
+      # Renders *element* using the handler registered for `element.type`. Unknown types
+      # fall through to `render_unknown`.
+      def render(element, context:)
+        handler = @handlers[element.type] || method(:render_unknown)
+        handler.call(element, context)
+      end
 
-        private
-
-        # The frozen hash of element-type → handler mapping.
-        attr_reader :handlers
-
-        # Builds the handler hash. Each handler is a small lambda that calls back into the
-        # parent renderer (or one of the private render_* methods below).
-        def build_handlers
-          r = @renderer
-          @handlers = {
-            p: ->(element, context) { r.wrap(r.render_inlines(element.children), width: context.width) },
-            header: ->(element, context) { send(:render_header, element, context) },
-            blockquote: ->(element, context) { send(:render_blockquote, element, context) },
-            ul: ->(element, context) { send(:render_list, element, ordered: false, context: context) },
-            ol: ->(element, context) { send(:render_list, element, ordered: true, context: context) },
-            li: ->(element, context) { r.render_blocks(element.children, list_depth: context.list_depth, width: context.width) },
-            codeblock: ->(element, _context) { send(:render_codeblock, element) },
-            hr: ->(element, context) { send(:render_rule, width: context.width) },
-            blank: ->(_element, _context) {}
-          }.freeze
-        end
+      private
+
+      # The frozen hash of element-type → handler mapping.
+      attr_reader :handlers
+
+      # Builds the handler hash. Each handler is a small lambda that calls back into the
+      # parent renderer (or one of the private render_* methods below).
+      def build_handlers
+        r = @renderer
+        @handlers = {
+          p: ->(element, context) { r.wrap(r.render_inlines(element.children), width: context.width) },
+          header: ->(element, context) { send(:render_header, element, context) },
+          blockquote: ->(element, context) { send(:render_blockquote, element, context) },
+          ul: ->(element, context) { send(:render_list, element, ordered: false, context: context) },
+          ol: ->(element, context) { send(:render_list, element, ordered: true, context: context) },
+          li: ->(element, context) { r.render_blocks(element.children, list_depth: context.list_depth, width: context.width) },
+          codeblock: ->(element, _context) { send(:render_codeblock, element) },
+          hr: ->(element, context) { send(:render_rule, width: context.width) },
+          blank: ->(_element, _context) {}
+        }.freeze
+      end
 
-        # Fallback for unknown block types: wraps the raw value when there are no children,
-        # otherwise recurses into the children.
-        def render_unknown(element, context)
-          return @renderer.wrap(element.value.to_s, width: context.width) if element.children.empty?
+      # Fallback for unknown block types: wraps the raw value when there are no children,
+      # otherwise recurses into the children.
+      def render_unknown(element, context)
+        return @renderer.wrap(element.value.to_s, width: context.width) if element.children.empty?
 
-          @renderer.render_blocks(element.children, list_depth: context.list_depth, width: context.width)
-        end
+        @renderer.render_blocks(element.children, list_depth: context.list_depth, width: context.width)
+      end
 
-        # Renders a header element, using the `markdown_heading` style for h1 and the
-        # `markdown_subheading` style for h2+.
-        def render_header(element, context)
-          rendered = @renderer.wrap(@renderer.render_inlines(element.children), width: context.width)
-          style = if element.options[:level].to_i == 1
-            @renderer.style_for(:markdown_heading, fallback: @renderer.theme_style(:title))
-          else
-            @renderer.style_for(:markdown_subheading, fallback: @renderer.theme_style(:title))
-          end
-          style.render(rendered)
+      # Renders a header element, using the `markdown_heading` style for h1 and the
+      # `markdown_subheading` style for h2+.
+      def render_header(element, context)
+        rendered = @renderer.wrap(@renderer.render_inlines(element.children), width: context.width)
+        style = if element.options[:level].to_i == 1
+          @renderer.style_for(:markdown_heading, fallback: @renderer.theme_style(:title))
+        else
+          @renderer.style_for(:markdown_subheading, fallback: @renderer.theme_style(:title))
         end
+        style.render(rendered)
+      end
 
-        def render_blockquote(element, context)
-          quote_width = context.width ? [context.width - 2, 1].max : nil
-          rendered = @renderer.render_blocks(element.children, list_depth: context.list_depth, width: quote_width)
-          border = @renderer.style_for(:markdown_quote_border, fallback: @renderer.theme_style(:border)).render("|")
-          quote_style = @renderer.style_for(:markdown_quote, fallback: @renderer.theme_style(:muted))
-
-          rendered.lines(chomp: true).map { |line| "#{border} #{quote_style.render(line)}" }.join("\n")
-        end
+      def render_blockquote(element, context)
+        quote_width = context.width ? [context.width - 2, 1].max : nil
+        rendered = @renderer.render_blocks(element.children, list_depth: context.list_depth, width: quote_width)
+        border = @renderer.style_for(:markdown_quote_border, fallback: @renderer.theme_style(:border)).render("|")
+        quote_style = @renderer.style_for(:markdown_quote, fallback: @renderer.theme_style(:muted))
 
-        def render_list(element, ordered:, context:)
-          element.children.each_with_index.map do |item, index|
-            marker = ordered ? "#{ordered_start(element) + index}." : "-"
-            render_list_item(item, marker: marker, context: context)
-          end.join("\n")
-        end
+        rendered.lines(chomp: true).map { |line| "#{border} #{quote_style.render(line)}" }.join("\n")
+      end
 
-        def render_list_item(element, marker:, context:)
-          indent = "  " * context.list_depth
-          first_prefix = "#{indent}#{marker} "
-          rest_prefix = "#{indent}#{" " * (marker.length + 1)}"
-          item_width = context.width ? [context.width - UI::Width.measure(first_prefix), 1].max : nil
-          body = @renderer.render_blocks(element.children, list_depth: context.list_depth + 1, width: item_width)
+      def render_list(element, ordered:, context:)
+        element.children.each_with_index.map do |item, index|
+          marker = ordered ? "#{ordered_start(element) + index}." : "-"
+          render_list_item(item, marker: marker, context: context)
+        end.join("\n")
+      end
 
-          body.lines(chomp: true).each_with_index.map do |line, index|
-            "#{index.zero? ? first_prefix : rest_prefix}#{line}"
-          end.join("\n")
-        end
+      def render_list_item(element, marker:, context:)
+        indent = "  " * context.list_depth
+        first_prefix = "#{indent}#{marker} "
+        rest_prefix = "#{indent}#{" " * (marker.length + 1)}"
+        item_width = context.width ? [context.width - UI::Width.measure(first_prefix), 1].max : nil
+        body = @renderer.render_blocks(element.children, list_depth: context.list_depth + 1, width: item_width)
 
-        def ordered_start(element)
-          element.options.fetch(:start, 1).to_i
-        end
+        body.lines(chomp: true).each_with_index.map do |line, index|
+          "#{index.zero? ? first_prefix : rest_prefix}#{line}"
+        end.join("\n")
+      end
 
-        def render_codeblock(element)
-          code = element.value.to_s
-          rendered = if @renderer.syntax_highlighting
-            SyntaxHighlighter.new(theme: @renderer.theme).render(code, language: code_language(element))
-          else
-            @renderer.style_for(:markdown_code, fallback: @renderer.theme_style(:warn)).render(code)
-          end
+      def ordered_start(element)
+        element.options.fetch(:start, 1).to_i
+      end
 
-          rendered.lines(chomp: true).map { |line| "  #{line}" }.join("\n")
+      def render_codeblock(element)
+        code = element.value.to_s
+        rendered = if @renderer.syntax_highlighting
+          SyntaxHighlighter.new(theme: @renderer.theme).render(code, language: code_language(element))
+        else
+          @renderer.style_for(:markdown_code, fallback: @renderer.theme_style(:warn)).render(code)
         end
 
-        def render_rule(width:)
-          @renderer.style_for(:markdown_rule, fallback: @renderer.theme_style(:border)).render("-" * (width || Renderer::DEFAULT_RULE_WIDTH))
-        end
+        rendered.lines(chomp: true).map { |line| "  #{line}" }.join("\n")
+      end
 
-        def code_language(element)
-          return element.options[:lang] if element.options[:lang]
+      def render_rule(width:)
+        @renderer.style_for(:markdown_rule, fallback: @renderer.theme_style(:border)).render("-" * (width || Renderer::DEFAULT_RULE_WIDTH))
+      end
 
-          element.attr["class"].to_s[/language-([^\s]+)/, 1]
-        end
+      def code_language(element)
+        return element.options[:lang] if element.options[:lang]
+
+        element.attr["class"].to_s[/language-([^\s]+)/, 1]
       end
     end
   end