charming 0.1.2 → 0.1.4

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

@@ -1,112 +1,335 @@
 # frozen_string_literal: true
 
-require "kramdown"
+require "commonmarker"
+require "uri"
 
 module Charming
-  module Presentation
-    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.
-      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
-
-        # *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)
-          @content = content
-          @width = width
-          @theme = theme || UI::Theme.default
-          @syntax_highlighting = syntax_highlighting
-        end
+  module Markdown
+    # Renderer parses CommonMark/GFM with Commonmarker and renders it as ANSI text.
+    class Renderer
+      DEFAULT_RULE_WIDTH = 40
+
+      attr_reader :content, :width, :theme, :syntax_highlighting, :style, :base_url
+
+      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
+
+      def render
+        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
+
+      def render_blocks(elements, context:)
+        elements.filter_map do |element|
+          rendered = render_block(element, context: context)
+          rendered unless rendered.to_s.empty?
+        end.join("\n\n")
+      end
+
+      def render_inlines(elements, context:)
+        elements.map { |element| render_inline(element, context: context) }.join
+      end
+
+      def wrap(value, width:)
+        return value unless width
+
+        value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
+      end
+
+      def style_for(name, fallback:)
+        return theme.public_send(name) if theme.respond_to?(name)
+
+        fallback
+      end
+
+      def theme_style(name)
+        return theme.public_send(name) if theme.respond_to?(name)
+
+        UI::Theme::DEFAULT_TOKENS.fetch(name).then { |token| UI::Theme.new(name => token).public_send(name) }
+      end
+
+      private
 
-        # 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)
+      def parse_document
+        Commonmarker.parse(
+          content.to_s,
+          options: {
+            extension: {
+              autolink: true,
+              description_lists: true,
+              footnotes: true,
+              strikethrough: true,
+              table: true,
+              tasklist: true
+            }
+          }
+        )
+      end
+
+      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
 
-        # 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)
-          elements.filter_map do |element|
-            rendered = block_renderer.render(element, context: context)
-            rendered unless rendered.to_s.empty?
-          end.join("\n\n")
+      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
 
-        # 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_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
 
-        # 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
+        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
 
-          value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
+      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
 
-        # 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)
+        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?
 
-          fallback
+        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
 
-        # 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)
+        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
 
-          UI::Theme::DEFAULT_TOKENS.fetch(name).then { |token| UI::Theme.new(name => token).public_send(name) }
+      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
 
-        private
+        image_style.render([label, href].reject(&:empty?).join(" "))
+      end
+
+      def render_block_with_style(style, body)
+        style.render(style.apply_block_layout(body))
+      end
 
-        # The BlockRenderer instance, lazily built.
-        def block_renderer
-          @block_renderer ||= BlockRenderer.new(renderer: self)
+      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
 
-        # The InlineRenderer instance, lazily built.
-        def inline_renderer
-          @inline_renderer ||= InlineRenderer.new(renderer: self)
+      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
 
-        # 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
+      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?
 
-          lines = []
-          current = +""
+        UI::Width.measure((style.indent_token || " ") * style.indent)
+      end
 
-          line.split(/\s+/).each do |word|
-            candidate = current.empty? ? word : "#{current} #{word}"
+      def resolve_url(value, context:)
+        return value if context.base_url.to_s.empty? || value.empty?
 
-            if !current.empty? && UI::Width.measure(candidate) > width
-              lines << current.rstrip
-              current = word
-            else
-              current = candidate
-            end
-          end
+        uri = URI.parse(value)
+        return value if uri.absolute?
 
-          lines << current.rstrip unless current.empty?
-          lines.join("\n")
+        URI.join(context.base_url, value).to_s
+      rescue URI::InvalidURIError
+        value
+      end
+
+      def children_of(node)
+        node.each.to_a
+      end
+
+      def wrap_line(line, width)
+        return line if UI::Width.measure(line) <= width
+
+        lines = []
+        current = +""
+
+        line.split(/\s+/).each do |word|
+          candidate = current.empty? ? word : "#{current} #{word}"
+
+          if !current.empty? && UI::Width.measure(candidate) > width
+            lines << current.rstrip
+            current = word
+          else
+            current = candidate
+          end
         end
+
+        lines << current.rstrip unless current.empty?
+        lines.join("\n")
       end
     end
   end

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Charming
+  module Markdown
+    class StyleConfig
+      ELEMENTS = %i[
+        document paragraph block_quote list heading h1 h2 h3 h4 h5 h6 text
+        strikethrough emph strong hr item enumeration task link link_text image
+        image_text code code_block table definition_list definition_term
+        definition_description html_block html_span
+      ].freeze
+
+      BUILT_INS = {
+        notty: {
+          block_quote: {indent: 1, indent_token: "| "},
+          list: {level_indent: 2},
+          h1: {prefix: "# "},
+          h2: {prefix: "## "},
+          h3: {prefix: "### "},
+          h4: {prefix: "#### "},
+          h5: {prefix: "##### "},
+          h6: {prefix: "###### "},
+          emph: {block_prefix: "*", block_suffix: "*"},
+          strong: {block_prefix: "**", block_suffix: "**"},
+          strikethrough: {block_prefix: "~~", block_suffix: "~~"},
+          hr: {format: "--------"},
+          item: {block_prefix: "- "},
+          enumeration: {block_prefix: ". "},
+          task: {ticked: "[x] ", unticked: "[ ] "},
+          code: {block_prefix: "`", block_suffix: "`"},
+          code_block: {margin: 1},
+          table: {column_separator: "|", row_separator: "-"},
+          image_text: {format: "Image: {{text}} ->"}
+        },
+        dark: {
+          document: {color: "252"},
+          block_quote: {color: "244", indent: 1, indent_token: "│ "},
+          list: {level_indent: 2},
+          heading: {color: "39", bold: true},
+          h1: {prefix: " ", suffix: " ", color: "228", background_color: "63", bold: true},
+          h2: {prefix: "## "},
+          h3: {prefix: "### "},
+          h4: {prefix: "#### "},
+          h5: {prefix: "##### "},
+          h6: {prefix: "###### ", color: "35", bold: false},
+          strikethrough: {crossed_out: true},
+          emph: {italic: true},
+          strong: {bold: true},
+          hr: {color: "240", format: "--------"},
+          item: {block_prefix: "• "},
+          enumeration: {block_prefix: ". "},
+          task: {ticked: "[✓] ", unticked: "[ ] "},
+          link: {color: "30", underline: true},
+          link_text: {color: "35", bold: true},
+          image: {color: "212", underline: true},
+          image_text: {color: "243", format: "Image: {{text}} ->"},
+          code: {prefix: " ", suffix: " ", color: "203", background_color: "236"},
+          code_block: {color: "244", margin: 1},
+          table: {column_separator: "|", row_separator: "-"}
+        },
+        light: {
+          document: {color: "236"},
+          block_quote: {color: "244", indent: 1, indent_token: "│ "},
+          list: {level_indent: 2},
+          heading: {color: "25", bold: true},
+          h1: {prefix: " ", suffix: " ", color: "255", background_color: "33", bold: true},
+          h2: {prefix: "## "},
+          h3: {prefix: "### "},
+          h4: {prefix: "#### "},
+          h5: {prefix: "##### "},
+          h6: {prefix: "###### ", color: "30", bold: false},
+          strikethrough: {crossed_out: true},
+          emph: {italic: true},
+          strong: {bold: true},
+          hr: {color: "250", format: "--------"},
+          item: {block_prefix: "• "},
+          enumeration: {block_prefix: ". "},
+          task: {ticked: "[✓] ", unticked: "[ ] "},
+          link: {color: "25", underline: true},
+          link_text: {color: "90", bold: true},
+          image: {color: "162", underline: true},
+          image_text: {color: "244", format: "Image: {{text}} ->"},
+          code: {prefix: " ", suffix: " ", color: "161", background_color: "255"},
+          code_block: {color: "244", margin: 1},
+          table: {column_separator: "|", row_separator: "-"}
+        }
+      }.freeze
+
+      ATTRIBUTES = %i[bold faint italic underline reverse strikethrough].freeze
+
+      Style = Data.define(
+        :block_prefix, :block_suffix, :prefix, :suffix, :color, :background_color,
+        :bold, :faint, :italic, :underline, :reverse, :strikethrough, :format,
+        :indent, :indent_token, :margin, :level_indent, :ticked, :unticked,
+        :column_separator, :row_separator
+      ) do
+        def self.from(value)
+          value = symbolize_keys(value || {})
+          new(
+            block_prefix: value[:block_prefix].to_s,
+            block_suffix: value[:block_suffix].to_s,
+            prefix: value[:prefix].to_s,
+            suffix: value[:suffix].to_s,
+            color: normalize_color(value[:color] || value[:foreground] || value[:fg]),
+            background_color: normalize_color(value[:background_color] || value[:background] || value[:bg]),
+            bold: value[:bold],
+            faint: value[:faint],
+            italic: value[:italic],
+            underline: value[:underline],
+            reverse: value[:reverse] || value[:inverse],
+            strikethrough: value[:strikethrough] || value[:crossed_out],
+            format: value[:format].to_s,
+            indent: value[:indent]&.to_i,
+            indent_token: value[:indent_token]&.to_s,
+            margin: value[:margin]&.to_i,
+            level_indent: value[:level_indent]&.to_i,
+            ticked: value[:ticked]&.to_s,
+            unticked: value[:unticked]&.to_s,
+            column_separator: value[:column_separator]&.to_s,
+            row_separator: value[:row_separator]&.to_s
+          )
+        end
+
+        def inherit_visual(child)
+          child = self.class.from(child) unless child.is_a?(self.class)
+          self.class.new(**child.to_h.merge(
+            color: child.color || color,
+            background_color: child.background_color || background_color,
+            bold: child.bold.nil? ? bold : child.bold,
+            faint: child.faint.nil? ? faint : child.faint,
+            italic: child.italic.nil? ? italic : child.italic,
+            underline: child.underline.nil? ? underline : child.underline,
+            reverse: child.reverse.nil? ? reverse : child.reverse,
+            strikethrough: child.strikethrough.nil? ? strikethrough : child.strikethrough
+          ))
+        end
+
+        def render(value)
+          ansi_codes.apply("#{block_prefix}#{prefix}#{value}#{suffix}#{block_suffix}")
+        end
+
+        def apply_block_layout(value)
+          lines = value.to_s.lines(chomp: true)
+          lines = [""] if lines.empty?
+
+          if indent&.positive?
+            indentation = (indent_token || " ") * indent
+            lines = lines.map { |line| "#{indentation}#{line}" }
+          end
+
+          rendered = lines.join("\n")
+          return rendered unless margin.to_i.positive?
+
+          blank = Array.new(margin.to_i, "").join("\n")
+          "#{blank}\n#{rendered}\n#{blank}"
+        end
+
+        private
+
+        def ansi_codes
+          UI::ANSICodes.new(
+            attributes: ATTRIBUTES.select { |attribute| public_send(attribute) },
+            foreground: color,
+            background: background_color
+          )
+        end
+
+        def self.symbolize_keys(value)
+          value.to_h.each_with_object({}) { |(key, item), result| result[key.to_sym] = item }
+        end
+
+        def self.normalize_color(value)
+          return if value.nil?
+          return value if value.is_a?(Integer)
+          return value.to_i if value.to_s.match?(/\A\d+\z/)
+
+          value
+        end
+      end
+
+      def self.builtin(name)
+        key = name.to_s.tr("-", "_").to_sym
+        raise ArgumentError, "unknown markdown style: #{name.inspect}" unless BUILT_INS.key?(key)
+
+        from_hash(BUILT_INS.fetch(key))
+      end
+
+      def self.from(value)
+        return value if value.is_a?(self)
+        return builtin(value) if value.is_a?(String) || value.is_a?(Symbol)
+
+        from_hash(value || BUILT_INS.fetch(:dark))
+      end
+
+      def self.from_hash(value)
+        new(value.to_h)
+      end
+
+      def initialize(styles = {})
+        styles = styles.transform_keys(&:to_sym)
+        @styles = ELEMENTS.each_with_object({}) do |element, result|
+          result[element] = Style.from(styles[element] || {})
+        end.freeze
+      end
+
+      def [](name)
+        @styles.fetch(name.to_sym) { Style.from({}) }
+      end
+
+      def heading(level)
+        self[:heading].inherit_visual(self[:"h#{level}"])
+      end
+    end
+  end
+end