charming 0.1.3 → 0.1.4

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

@@ -2,17 +2,15 @@
 
 module Charming
   module Components
-    # Markdown renders Markdown source as ANSI-styled terminal text. Parsing is delegated to
-    # `Charming::Markdown::Renderer`; set *syntax_highlighting* to false to disable
-    # Rouge-backed code block highlighting.
+    # Markdown renders CommonMark/GFM source as ANSI-styled terminal text.
     class Markdown < Component
-      # *content* is the Markdown source string. *width* optionally sets the wrap width.
-      # *syntax_highlighting* enables Rouge for code blocks (defaults to true).
-      def initialize(content:, width: nil, theme: nil, syntax_highlighting: true)
+      def initialize(content:, width: nil, theme: nil, syntax_highlighting: true, style: :dark, base_url: nil)
         super(theme: theme)
         @content = content
         @width = width
         @syntax_highlighting = syntax_highlighting
+        @style = style
+        @base_url = base_url
       end
 
       # Renders the Markdown body to a styled, terminal-safe string.
@@ -21,7 +19,9 @@ module Charming
           content: @content,
           width: @width,
           theme: theme,
-          syntax_highlighting: @syntax_highlighting
+          syntax_highlighting: @syntax_highlighting,
+          style: @style,
+          base_url: @base_url
         ).render
       end
     end

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

@@ -44,6 +44,13 @@ module Charming
         (focus && name) ? [name] : []
       end
 
+      # Returns the mouse target represented by this pane, if it has a name.
+      def mouse_targets(rect)
+        return [] unless name
+
+        [{name: name, rect: rect, inner_rect: inner_rect(rect)}]
+      end
+
       # Renders the pane into *rect*, applying the configured style, border, and padding
       # around the evaluated content.
       def render(rect)

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

@@ -6,6 +6,11 @@ module Charming
     # (width, height). Layout operations produce new Rect instances rather than mutating
     # existing ones.
     Rect = Data.define(:x, :y, :width, :height) do
+      # Returns true when the zero-based cell coordinate falls within this rectangle.
+      def cover?(point_x, point_y)
+        point_x >= x && point_x < x + width && point_y >= y && point_y < y + height
+      end
+
       # Returns a new Rect inset by *top*/*right*/*bottom*/*left* cells. The result is
       # clamped to a minimum width/height of 0.
       def inset(top: 0, right: 0, bottom: 0, left: 0)

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

@@ -32,6 +32,13 @@ module Charming
         child ? child.focusable_names : []
       end
 
+      # Returns all named pane mouse targets for the full screen layout.
+      def mouse_targets
+        return [] unless child
+
+        child.mouse_targets(Rect.new(x: 0, y: 0, width: screen.width, height: screen.height))
+      end
+
       # Renders the child into the full-screen rect, then overlays each registered overlay
       # on top in order.
       def render

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

@@ -32,6 +32,13 @@ module Charming
         children.flat_map(&:focusable_names)
       end
 
+      # 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
+
       # Renders each child into its own sub-rect, then overlays them on a blank canvas
       # of the parent's dimensions.
       def render(rect)

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

@@ -2,18 +2,36 @@
 
 module Charming
   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)
+    # 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
 
-      # 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)
+      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
+
+      def inherit(style_name)
+        current_style.inherit_visual(style[style_name])
       end
     end
   end

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

@@ -1,72 +1,58 @@
 # frozen_string_literal: true
 
-require "kramdown"
+require "commonmarker"
+require "uri"
 
 module Charming
   module Markdown
-    # Renderer is the top-level Markdown-to-ANSI renderer. Parses the *content* with
-    # Kramdown, then walks the document's block and inline trees to produce styled
-    # terminal output. Code blocks are highlighted via Rouge when `syntax_highlighting`
-    # is enabled.
+    # Renderer parses CommonMark/GFM with Commonmarker and renders it as ANSI text.
     class Renderer
-      # Wrap width used by `render_rule` when no width is otherwise specified.
       DEFAULT_RULE_WIDTH = 40
 
-      # The Markdown source, configured wrap width, theme, and syntax-highlighting flag.
-      attr_reader :content, :width, :theme, :syntax_highlighting
+      attr_reader :content, :width, :theme, :syntax_highlighting, :style, :base_url
 
-      # *content* is the Markdown source string. *width* optionally wraps paragraphs to that
-      # many display columns. *theme* is the Charming theme used to style blocks/inlines.
-      # *syntax_highlighting* enables Rouge-backed code block highlighting (default true).
-      def initialize(content:, width: nil, theme: UI::Theme.default, syntax_highlighting: true)
+      def initialize(content:, width: nil, theme: UI::Theme.default, syntax_highlighting: true, style: :dark, base_url: nil)
         @content = content
         @width = width
         @theme = theme || UI::Theme.default
         @syntax_highlighting = syntax_highlighting
+        @style = StyleConfig.from(style)
+        @base_url = base_url
       end
 
-      # Parses the content and returns the fully-rendered Markdown as a single string.
       def render
-        document = Kramdown::Document.new(content.to_s)
-        render_blocks(document.root.children)
+        context = RenderContext.from(
+          width: width,
+          style: style,
+          base_url: base_url,
+          source_lines: content.to_s.lines(chomp: true)
+        )
+        render_document(parse_document, context: context)
       end
 
-      # Renders a list of Kramdown block *elements* into a string, joined by blank lines.
-      # *list_depth* is forwarded to the render context for list indentation. *width*
-      # defaults to the renderer's configured width.
-      def render_blocks(elements, list_depth: 0, width: @width)
-        context = RenderContext.from(width: width, list_depth: list_depth)
+      def render_blocks(elements, context:)
         elements.filter_map do |element|
-          rendered = block_renderer.render(element, context: context)
+          rendered = render_block(element, context: context)
           rendered unless rendered.to_s.empty?
         end.join("\n\n")
       end
 
-      # Renders a list of Kramdown inline *elements* into a single concatenated string.
-      # *width* defaults to the renderer's configured width.
-      def render_inlines(elements, width: @width)
-        context = RenderContext.from(width: width)
-        elements.map { |element| inline_renderer.render(element, context: context) }.join
+      def render_inlines(elements, context:)
+        elements.map { |element| render_inline(element, context: context) }.join
       end
 
-      # Word-wraps *value* to *width* display columns (when *width* is given), preserving
-      # any ANSI styling on each line. Returns *value* unchanged when *width* is nil.
       def wrap(value, width:)
         return value unless width
 
         value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
       end
 
-      # Returns the theme's style for *name* if the theme defines it, otherwise returns
-      # *fallback*. Lets views override markdown-specific theme tokens.
       def style_for(name, fallback:)
         return theme.public_send(name) if theme.respond_to?(name)
 
         fallback
       end
 
-      # Returns the theme's style for *name*, building a one-token default theme when
-      # the active theme doesn't define it. Used as a final fallback for markdown styling.
       def theme_style(name)
         return theme.public_send(name) if theme.respond_to?(name)
 
@@ -75,17 +61,256 @@ module Charming
 
       private
 
-      # The BlockRenderer instance, lazily built.
-      def block_renderer
-        @block_renderer ||= BlockRenderer.new(renderer: self)
+      def parse_document
+        Commonmarker.parse(
+          content.to_s,
+          options: {
+            extension: {
+              autolink: true,
+              description_lists: true,
+              footnotes: true,
+              strikethrough: true,
+              table: true,
+              tasklist: true
+            }
+          }
+        )
       end
 
-      # The InlineRenderer instance, lazily built.
-      def inline_renderer
-        @inline_renderer ||= InlineRenderer.new(renderer: self)
+      def render_document(node, context:)
+        document_style = context.style[:document]
+        body = render_blocks(children_of(node), context: context.with(current_style: document_style))
+        document_style.render(document_style.apply_block_layout(body))
+      end
+
+      def render_block(node, context:)
+        case node.type
+        when :paragraph
+          render_paragraph(node, context: context)
+        when :heading
+          render_heading(node, context: context)
+        when :block_quote
+          render_block_quote(node, context: context)
+        when :list
+          render_list(node, context: context)
+        when :code_block
+          render_code_block(node, context: context)
+        when :thematic_break
+          render_rule(context: context)
+        when :table
+          render_table(node, context: context)
+        when :html_block
+          render_html_block(node, context: context)
+        else
+          render_blocks(children_of(node), context: context)
+        end
+      end
+
+      def render_inline(node, context:)
+        case node.type
+        when :text
+          context.current_style.inherit_visual(context.style[:text]).render(node.string_content)
+        when :softbreak
+          " "
+        when :linebreak
+          "\n"
+        when :code
+          context.inherit(:code).render(node.string_content)
+        when :emph
+          render_styled_inline(node, :emph, context: context)
+        when :strong
+          render_styled_inline(node, :strong, context: context)
+        when :strikethrough
+          render_styled_inline(node, :strikethrough, context: context)
+        when :link
+          render_link(node, context: context)
+        when :image
+          render_image(node, context: context)
+        when :html_inline
+          ""
+        else
+          render_inlines(children_of(node), context: context)
+        end
+      end
+
+      def render_paragraph(node, context:)
+        paragraph_style = context.current_style.inherit_visual(context.style[:paragraph])
+        body = render_inlines(children_of(node), context: context.with(current_style: paragraph_style))
+        render_block_with_style(paragraph_style, wrap(body, width: context.width))
+      end
+
+      def render_heading(node, context:)
+        heading_style = context.current_style.inherit_visual(context.style.heading(node.header_level))
+        body = render_inlines(children_of(node), context: context.with(current_style: heading_style))
+        render_block_with_style(heading_style, wrap(body, width: context.width))
+      end
+
+      def render_block_quote(node, context:)
+        quote_style = context.current_style.inherit_visual(context.style[:block_quote])
+        quote_width = context.width ? [context.width - quote_indent_width(quote_style), 1].max : nil
+        body = render_blocks(children_of(node), context: context.with(width: quote_width, current_style: quote_style))
+        render_block_with_style(quote_style, body)
+      end
+
+      def render_list(node, context:)
+        list_style = context.current_style.inherit_visual(context.style[:list])
+        children_of(node).each_with_index.map do |item, index|
+          render_list_item(item, index: index, ordered: node.list_type == :ordered, list: node, context: context.with(current_style: list_style))
+        end.join("\n")
+      end
+
+      def render_list_item(node, index:, ordered:, list:, context:)
+        marker_style = context.current_style.inherit_visual(context.style[ordered ? :enumeration : :item])
+        marker = if node.type == :taskitem
+          task_marker(node, context: context)
+        elsif ordered
+          "#{list.list_start.to_i + index}. "
+        else
+          marker_style.block_prefix.empty? ? "- " : marker_style.block_prefix
+        end
+
+        indent = " " * (context.style[:list].level_indent || 2) * context.list_depth
+        first_prefix = "#{indent}#{marker}"
+        rest_prefix = "#{indent}#{" " * UI::Width.measure(marker)}"
+        item_width = context.width ? [context.width - UI::Width.measure(first_prefix), 1].max : nil
+        body = render_blocks(children_of(node), context: context.nested_list(width: item_width))
+
+        body.lines(chomp: true).each_with_index.map do |line, line_index|
+          "#{line_index.zero? ? first_prefix : rest_prefix}#{line}"
+        end.join("\n")
+      end
+
+      def task_marker(node, context:)
+        task_style = context.current_style.inherit_visual(context.style[:task])
+        checked_task?(node, context: context) ? (task_style.ticked || "[x] ") : (task_style.unticked || "[ ] ")
+      end
+
+      def checked_task?(node, context:)
+        line = context.source_lines[node.source_position[:start_line].to_i - 1].to_s
+        line.match?(/\[[xX]\]/)
+      end
+
+      def render_code_block(node, context:)
+        code_style = context.current_style.inherit_visual(context.style[:code_block])
+        code = node.string_content.to_s.chomp
+        rendered = if syntax_highlighting
+          SyntaxHighlighter.new(theme: theme, style: style).render(code, language: node.fence_info.to_s.split.first)
+        else
+          code_style.render(code)
+        end
+
+        body = rendered.lines(chomp: true).map { |line| "  #{line}" }.join("\n")
+        syntax_highlighting ? code_style.apply_block_layout(body) : render_block_with_style(code_style, body)
+      end
+
+      def render_rule(context:)
+        rule_style = context.current_style.inherit_visual(context.style[:hr])
+        body = rule_style.format.empty? ? "-" * (context.width || DEFAULT_RULE_WIDTH) : rule_style.format
+        render_block_with_style(rule_style, body)
+      end
+
+      def render_table(node, context:)
+        table_style = context.current_style.inherit_visual(context.style[:table])
+        rows = children_of(node).map do |row|
+          children_of(row).map { |cell| render_inlines(children_of(cell), context: context.with(current_style: table_style)) }
+        end
+        return "" if rows.empty?
+
+        widths = table_widths(rows)
+        rendered_rows = rows.each_with_index.map do |row, index|
+          line = table_row(row, widths, table_style)
+          index.zero? ? [line, table_separator(widths, table_style)].join("\n") : line
+        end
+
+        render_block_with_style(table_style, rendered_rows.join("\n"))
+      end
+
+      def render_html_block(_node, context:)
+        html_style = context.current_style.inherit_visual(context.style[:html_block])
+        return "" if html_style.format.empty?
+
+        render_block_with_style(html_style, html_style.format)
+      end
+
+      def render_styled_inline(node, style_name, context:)
+        inline_style = context.inherit(style_name)
+        inline_style.render(render_inlines(children_of(node), context: context.with(current_style: inline_style)))
+      end
+
+      def render_link(node, context:)
+        href = resolve_url(node.url.to_s, context: context)
+        text_style = context.inherit(:link_text)
+        link_style = context.inherit(:link)
+        label = render_inlines(children_of(node), context: context.with(current_style: text_style))
+        rendered = if href.empty? || UI::Width.strip_ansi(label) == href
+          label
+        else
+          "#{label} <#{href}>"
+        end
+        link_style.render(rendered)
+      end
+
+      def render_image(node, context:)
+        href = resolve_url(node.url.to_s, context: context)
+        image_style = context.inherit(:image)
+        text_style = context.inherit(:image_text)
+        alt = render_inlines(children_of(node), context: context.with(current_style: text_style))
+        label = if text_style.format.empty?
+          "Image: #{UI::Width.strip_ansi(alt)} ->"
+        else
+          text_style.format.gsub("{{text}}", UI::Width.strip_ansi(alt))
+        end
+
+        image_style.render([label, href].reject(&:empty?).join(" "))
+      end
+
+      def render_block_with_style(style, body)
+        style.render(style.apply_block_layout(body))
+      end
+
+      def table_widths(rows)
+        column_count = rows.map(&:length).max || 0
+        Array.new(column_count) do |index|
+          rows.map { |row| UI::Width.measure(row[index].to_s) }.max || 0
+        end
+      end
+
+      def table_row(row, widths, style)
+        separator = style.column_separator || "|"
+        cells = widths.each_with_index.map do |width, index|
+          value = row[index].to_s
+          " #{value}#{" " * [width - UI::Width.measure(value), 0].max} "
+        end
+        "#{separator}#{cells.join(separator)}#{separator}"
+      end
+
+      def table_separator(widths, style)
+        separator = style.column_separator || "|"
+        row = style.row_separator || "-"
+        "#{separator}#{widths.map { |table_width| row * (table_width + 2) }.join(separator)}#{separator}"
+      end
+
+      def quote_indent_width(style)
+        return 0 unless style.indent&.positive?
+
+        UI::Width.measure((style.indent_token || " ") * style.indent)
+      end
+
+      def resolve_url(value, context:)
+        return value if context.base_url.to_s.empty? || value.empty?
+
+        uri = URI.parse(value)
+        return value if uri.absolute?
+
+        URI.join(context.base_url, value).to_s
+      rescue URI::InvalidURIError
+        value
+      end
+
+      def children_of(node)
+        node.each.to_a
       end
 
-      # Word-wraps a single *line* to *width* display columns using greedy space-splitting.
       def wrap_line(line, width)
         return line if UI::Width.measure(line) <= width