docyard 0.7.0 → 0.9.0

data/lib/docyard/components/processors/accordion_processor.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/icons"
+require_relative "../../rendering/renderer"
+require_relative "../base_processor"
+require_relative "../support/markdown_code_block_helper"
+require "kramdown"
+require "kramdown-parser-gfm"
+
+module Docyard
+  module Components
+    module Processors
+      class AccordionProcessor < BaseProcessor
+        include Support::MarkdownCodeBlockHelper
+
+        self.priority = 10
+
+        DETAILS_PATTERN = /^:::details(?:\{([^}]*)\})?\s*\n(.*?)^:::\s*$/m
+
+        def preprocess(markdown)
+          @code_block_ranges = find_code_block_ranges(markdown)
+
+          markdown.gsub(DETAILS_PATTERN) do
+            match = Regexp.last_match
+            next match[0] if inside_code_block?(match.begin(0), @code_block_ranges)
+
+            attributes = parse_attributes(match[1])
+            content_markdown = match[2]
+
+            title = attributes["title"] || "Details"
+            open = attributes.key?("open")
+            content_html = render_markdown_content(content_markdown.strip)
+
+            wrap_in_nomarkdown(render_accordion_html(title, content_html, open))
+          end
+        end
+
+        private
+
+        def parse_attributes(attr_string)
+          return {} if attr_string.nil? || attr_string.empty?
+
+          attrs = {}
+          attr_string.scan(/(\w+)(?:="([^"]*)")?/) do |key, value|
+            attrs[key] = value || true
+          end
+          attrs
+        end
+
+        def render_markdown_content(content_markdown)
+          return "" if content_markdown.empty?
+
+          Kramdown::Document.new(
+            content_markdown,
+            input: "GFM",
+            hard_wrap: false,
+            syntax_highlighter: "rouge"
+          ).to_html
+        end
+
+        def wrap_in_nomarkdown(html)
+          "{::nomarkdown}\n#{html}\n{:/nomarkdown}"
+        end
+
+        def render_accordion_html(title, content_html, open)
+          icon_svg = Icons.render("caret-right") || ""
+          renderer = Renderer.new
+
+          renderer.render_partial(
+            "_accordion", {
+              title: title,
+              content_html: content_html,
+              icon_svg: icon_svg,
+              open: open
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/processors/badge_processor.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class BadgeProcessor < BaseProcessor
+        self.priority = 15
+
+        BADGE_PATTERN = /:badge\[([^\]]*)\](?:\{([^}]*)\})?/
+
+        VALID_TYPES = %w[default success warning danger].freeze
+
+        def postprocess(html)
+          segments = split_preserving_code_blocks(html)
+
+          segments.map do |segment|
+            segment[:type] == :code ? segment[:content] : process_segment(segment[:content])
+          end.join
+        end
+
+        private
+
+        def split_preserving_code_blocks(html)
+          segments = []
+          current_pos = 0
+
+          html.scan(%r{<(code|pre)[^>]*>.*?</\1>}m) do
+            match_start = Regexp.last_match.begin(0)
+            match_end = Regexp.last_match.end(0)
+
+            segments << { type: :text, content: html[current_pos...match_start] } if match_start > current_pos
+            segments << { type: :code, content: html[match_start...match_end] }
+
+            current_pos = match_end
+          end
+
+          segments << { type: :text, content: html[current_pos..] } if current_pos < html.length
+
+          segments.empty? ? [{ type: :text, content: html }] : segments
+        end
+
+        def process_segment(content)
+          content.gsub(BADGE_PATTERN) do
+            text = Regexp.last_match(1)
+            attrs = Regexp.last_match(2)
+
+            render_badge(text, parse_attributes(attrs))
+          end
+        end
+
+        def parse_attributes(attrs_string)
+          return {} if attrs_string.nil? || attrs_string.empty?
+
+          attrs = {}
+          attrs_string.scan(/(\w+)=["'\u201C\u201D]([^"'\u201C\u201D]*)["'\u201C\u201D]/) do |key, value|
+            attrs[key] = value
+          end
+          attrs
+        end
+
+        def render_badge(text, attrs)
+          type = attrs["type"] || "default"
+          type = "default" unless VALID_TYPES.include?(type)
+
+          %(<span class="docyard-badge docyard-badge--#{type}">#{text}</span>)
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/processors/callout_processor.rb

@@ -3,6 +3,7 @@
 require_relative "../../rendering/icons"
 require_relative "../../rendering/renderer"
 require_relative "../base_processor"
+require_relative "../support/markdown_code_block_helper"
 require "kramdown"
 require "kramdown-parser-gfm"
 
@@ -10,6 +11,8 @@ module Docyard
   module Components
     module Processors
       class CalloutProcessor < BaseProcessor
+        include Support::MarkdownCodeBlockHelper
+
         self.priority = 10
 
         CALLOUT_TYPES = {
@@ -29,6 +32,7 @@ module Docyard
         }.freeze
 
         def preprocess(markdown)
+          @code_block_ranges = find_code_block_ranges(markdown)
           process_container_syntax(markdown)
         end
 
@@ -40,8 +44,10 @@ module Docyard
 
         def process_container_syntax(markdown)
           markdown.gsub(/^:::[ \t]*(\w+)(?:[ \t]+([^\n]+?))?[ \t]*\n(.*?)^:::[ \t]*$/m) do
-            process_callout_match(Regexp.last_match(0), Regexp.last_match(1), Regexp.last_match(2),
-                                  Regexp.last_match(3))
+            match = Regexp.last_match
+            next match[0] if inside_code_block?(match.begin(0), @code_block_ranges)
+
+            process_callout_match(match[0], match[1], match[2], match[3])
           end
         end
 

data/lib/docyard/components/processors/cards_processor.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/icons"
+require_relative "../../rendering/renderer"
+require_relative "../base_processor"
+require_relative "../support/markdown_code_block_helper"
+require "kramdown"
+require "kramdown-parser-gfm"
+
+module Docyard
+  module Components
+    module Processors
+      class CardsProcessor < BaseProcessor
+        include Support::MarkdownCodeBlockHelper
+
+        self.priority = 10
+
+        CARDS_PATTERN = /^:::cards\s*\n(.*?)^:::\s*$/m
+        CARD_PATTERN = /^::card\{([^}]*)\}\s*\n(.*?)^::\s*$/m
+
+        def preprocess(markdown)
+          @code_block_ranges = find_code_block_ranges(markdown)
+
+          markdown.gsub(CARDS_PATTERN) do
+            match = Regexp.last_match
+            next match[0] if inside_code_block?(match.begin(0), @code_block_ranges)
+
+            content = match[1]
+            cards = parse_cards(content)
+
+            wrap_in_nomarkdown(render_cards_html(cards))
+          end
+        end
+
+        private
+
+        def parse_cards(content)
+          cards = []
+
+          content.scan(CARD_PATTERN) do |attrs_string, card_content|
+            attrs = parse_attributes(attrs_string)
+            cards << {
+              title: attrs["title"] || "Card",
+              icon: attrs["icon"],
+              href: attrs["href"],
+              content: card_content.strip
+            }
+          end
+
+          cards
+        end
+
+        def parse_attributes(attr_string)
+          return {} if attr_string.nil? || attr_string.empty?
+
+          attrs = {}
+          attr_string.scan(/(\w+)="([^"]*)"/) do |key, value|
+            attrs[key] = value
+          end
+          attrs
+        end
+
+        def render_cards_html(cards)
+          renderer = Renderer.new
+
+          cards_html = cards.map do |card|
+            icon_svg = card[:icon] ? Icons.render(card[:icon]) : nil
+            content_html = render_markdown_content(card[:content])
+
+            renderer.render_partial(
+              "_card", {
+                title: card[:title],
+                icon_svg: icon_svg,
+                href: card[:href],
+                content_html: content_html
+              }
+            )
+          end.join("\n")
+
+          "<div class=\"docyard-cards\">\n#{cards_html}\n</div>"
+        end
+
+        def render_markdown_content(content_markdown)
+          return "" if content_markdown.empty?
+
+          Kramdown::Document.new(
+            content_markdown,
+            input: "GFM",
+            hard_wrap: false,
+            syntax_highlighter: "rouge"
+          ).to_html
+        end
+
+        def wrap_in_nomarkdown(html)
+          "{::nomarkdown}\n#{html}\n{:/nomarkdown}"
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/processors/code_block_options_preprocessor.rb

@@ -10,10 +10,12 @@ module Docyard
 
         CODE_FENCE_REGEX = /^```(\w+)(?:\s*\[([^\]]+)\])?(:\S+)?(?:\s*\{([^}\n]+)\})?/
         TABS_BLOCK_REGEX = /^:::[ \t]*tabs[ \t]*\n.*?^:::[ \t]*$/m
+        CODE_GROUP_BLOCK_REGEX = /^:::[ \t]*code-group[ \t]*\n.*?^:::[ \t]*$/m
 
         def preprocess(content)
           context[:code_block_options] ||= []
           @tabs_ranges = find_tabs_ranges(content)
+          @code_group_ranges = find_code_group_ranges(content)
 
           process_code_fences(content)
         end
@@ -35,10 +37,21 @@ module Docyard
         end
 
         def process_fence_match(match)
-          store_code_block_options(match) unless inside_tabs?(match.begin(0))
+          position = match.begin(0)
+          return match[0] if inside_special_block?(position)
+
+          store_code_block_options(match)
           "```#{match[1]}"
         end
 
+        def inside_special_block?(position)
+          inside_tabs?(position) || inside_code_group?(position)
+        end
+
+        def inside_code_group?(position)
+          @code_group_ranges.any? { |range| range.cover?(position) }
+        end
+
         def store_code_block_options(match)
           context[:code_block_options] << {
             lang: match[1],
@@ -53,8 +66,16 @@ module Docyard
         end
 
         def find_tabs_ranges(content)
+          find_block_ranges(content, TABS_BLOCK_REGEX)
+        end
+
+        def find_code_group_ranges(content)
+          find_block_ranges(content, CODE_GROUP_BLOCK_REGEX)
+        end
+
+        def find_block_ranges(content, regex)
           ranges = []
-          content.scan(TABS_BLOCK_REGEX) do
+          content.scan(regex) do
             match = Regexp.last_match
             ranges << (match.begin(0)...match.end(0))
           end

data/lib/docyard/components/processors/code_block_processor.rb

@@ -67,10 +67,16 @@ module Docyard
         def process_code_block(original_html, inner_html)
           block_data = extract_block_data(inner_html)
           processed_html = process_html_for_highlighting(original_html, block_data)
+          processed_html = inject_scroll_spacer(processed_html) unless block_data[:title]
 
           render_code_block_with_copy(block_data.merge(html: processed_html))
         end
 
+        def inject_scroll_spacer(html)
+          spacer = '<span class="docyard-code-block__scroll-spacer" aria-hidden="true"></span>'
+          html.sub("\n", "#{spacer}\n")
+        end
+
         def extract_block_data(inner_html)
           opts = current_block_options
           code_text = extract_code_text(inner_html)

data/lib/docyard/components/processors/code_group_processor.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+require_relative "../support/code_block/feature_extractor"
+require_relative "../support/code_block/line_wrapper"
+require_relative "../support/code_group/html_builder"
+require_relative "../support/markdown_code_block_helper"
+require_relative "../../rendering/icons"
+require_relative "../../rendering/renderer"
+require "securerandom"
+require "kramdown"
+require "kramdown-parser-gfm"
+require "cgi"
+
+module Docyard
+  module Components
+    module Processors
+      class CodeGroupProcessor < BaseProcessor
+        include Utils::HtmlHelpers
+        include Support::MarkdownCodeBlockHelper
+
+        self.priority = 12
+
+        CODE_GROUP_PATTERN = /^:::[ \t]*code-group[ \t]*\n(.*?)^:::[ \t]*$/m
+        CODE_BLOCK_PATTERN = /```(\w*)\s*\[([^\]]+)\]([^\n]*)\n(.*?)```/m
+
+        CodeBlockFeatureExtractor = Support::CodeBlock::FeatureExtractor
+        CodeBlockLineWrapper = Support::CodeBlock::LineWrapper
+        CodeGroupHtmlBuilder = Support::CodeGroup::HtmlBuilder
+
+        def preprocess(content)
+          return content unless content.include?(":::code-group")
+
+          @code_block_ranges = find_code_block_ranges(content)
+
+          content.gsub(CODE_GROUP_PATTERN) do
+            match = ::Regexp.last_match
+            next match[0] if inside_code_block?(match.begin(0), @code_block_ranges)
+
+            process_code_group(match[1])
+          end
+        end
+
+        private
+
+        def process_code_group(inner_content)
+          blocks = extract_code_blocks(inner_content)
+          return "" if blocks.empty?
+
+          group_id = SecureRandom.hex(4)
+          html = CodeGroupHtmlBuilder.new(blocks, group_id).build
+          wrap_in_nomarkdown(html)
+        end
+
+        def extract_code_blocks(content)
+          blocks = []
+          content.scan(CODE_BLOCK_PATTERN) do
+            blocks << build_block_data(::Regexp.last_match)
+          end
+          blocks
+        end
+
+        def build_block_data(match)
+          lang = match[1] || ""
+          label = match[2]
+          options = match[3].strip
+          code = match[4]
+
+          code_with_newline = code.end_with?("\n") ? code : "#{code}\n"
+          markdown = "```#{lang}#{format_options(options)}\n#{code_with_newline}```"
+          extracted = CodeBlockFeatureExtractor.process_markdown(markdown)
+          rendered = render_and_enhance(extracted)
+
+          { label: label, lang: lang, content: rendered, code_text: code.strip }
+        end
+
+        def format_options(options)
+          return "" if options.empty?
+          return options if options.start_with?(":")
+
+          " #{options}"
+        end
+
+        def render_and_enhance(extracted)
+          html = render_markdown(extracted[:cleaned_markdown])
+          enhance_code_blocks(html, extracted[:blocks])
+        end
+
+        def render_markdown(markdown_content)
+          return "" if markdown_content.empty?
+
+          Kramdown::Document.new(
+            markdown_content,
+            input: "GFM",
+            hard_wrap: false,
+            syntax_highlighter: "rouge"
+          ).to_html
+        end
+
+        def enhance_code_blocks(html, blocks)
+          return html unless html.include?('<div class="highlight">')
+
+          block_index = 0
+          html.gsub(%r{<div class="highlight">(.*?)</div>}m) do
+            block_data = blocks[block_index] || {}
+            block_index += 1
+            render_enhanced_code_block(Regexp.last_match, block_data)
+          end
+        end
+
+        def render_enhanced_code_block(match, block_data)
+          original_html = match[0]
+          inner_html = match[1]
+          code_text = extract_code_text(inner_html)
+
+          processed_html = process_html_if_needed(original_html, block_data)
+          Renderer.new.render_partial("_code_block", build_locals(processed_html, code_text, block_data))
+        end
+
+        def process_html_if_needed(original_html, block_data)
+          return original_html unless needs_line_wrapping?(block_data)
+
+          CodeBlockLineWrapper.wrap_code_block(original_html, wrapper_data(block_data))
+        end
+
+        def needs_line_wrapping?(block_data)
+          %i[highlights diff_lines focus_lines error_lines warning_lines].any? do |key|
+            block_data[key]&.any?
+          end
+        end
+
+        def wrapper_data(block_data)
+          {
+            highlights: block_data[:highlights] || [],
+            diff_lines: block_data[:diff_lines] || {},
+            focus_lines: block_data[:focus_lines] || {},
+            error_lines: block_data[:error_lines] || {},
+            warning_lines: block_data[:warning_lines] || {},
+            start_line: extract_start_line(block_data[:option])
+          }
+        end
+
+        def build_locals(processed_html, code_text, block_data)
+          base_locals(processed_html, code_text, block_data).merge(feature_locals(block_data)).merge(title_locals)
+        end
+
+        def base_locals(processed_html, code_text, block_data)
+          show_ln = line_numbers_enabled?(block_data[:option])
+          start = extract_start_line(block_data[:option])
+
+          {
+            code_block_html: processed_html, code_text: escape_html_attribute(code_text),
+            copy_icon: Icons.render("copy", "regular") || "", show_line_numbers: show_ln,
+            line_numbers: show_ln ? generate_line_numbers(code_text, start) : [], start_line: start
+          }
+        end
+
+        def feature_locals(block_data)
+          {
+            highlights: block_data[:highlights] || [], diff_lines: block_data[:diff_lines] || {},
+            focus_lines: block_data[:focus_lines] || {}, error_lines: block_data[:error_lines] || {},
+            warning_lines: block_data[:warning_lines] || {}
+          }
+        end
+
+        def title_locals
+          { title: nil, icon: nil, icon_source: nil }
+        end
+
+        def line_numbers_enabled?(option)
+          return false if option == ":no-line-numbers"
+          return true if option&.start_with?(":line-numbers")
+
+          false
+        end
+
+        def extract_start_line(option)
+          return 1 unless option&.include?("=")
+
+          option.split("=").last.to_i
+        end
+
+        def generate_line_numbers(code_text, start_line)
+          count = [code_text.lines.count, 1].max
+          (start_line...(start_line + count)).to_a
+        end
+
+        def extract_code_text(html)
+          CGI.unescapeHTML(html.gsub(/<[^>]+>/, "")).strip
+        end
+
+        def wrap_in_nomarkdown(html)
+          "{::nomarkdown}\n#{html}\n{:/nomarkdown}"
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/processors/code_snippet_import_preprocessor.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "../base_processor"
+require_relative "../support/markdown_code_block_helper"
 
 module Docyard
   module Components
     module Processors
       class CodeSnippetImportPreprocessor < BaseProcessor
+        include Support::MarkdownCodeBlockHelper
+
         EXTENSION_MAP = {
           "rb" => "ruby",
           "js" => "javascript",
@@ -25,7 +28,9 @@ module Docyard
 
         def preprocess(content)
           @docs_root = context[:docs_root] || "docs"
-          content.gsub(IMPORT_PATTERN) { |_| process_import(Regexp.last_match) }
+          process_outside_code_blocks(content) do |segment|
+            segment.gsub(IMPORT_PATTERN) { |_| process_import(Regexp.last_match) }
+          end
         end
 
         private

data/lib/docyard/components/processors/custom_anchor_processor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class CustomAnchorProcessor < BaseProcessor
+        CUSTOM_ID_PATTERN = /\s*\{#([\w-]+)\}\s*$/
+
+        self.priority = 25
+
+        def postprocess(html)
+          process_custom_anchors(html)
+        end
+
+        private
+
+        def process_custom_anchors(html)
+          html.gsub(%r{<(h[1-6])(\s+id="[^"]*")?>(.+?)</\1>}m) do
+            tag = Regexp.last_match(1)
+            existing_attr = Regexp.last_match(2) || ""
+            content = Regexp.last_match(3)
+
+            if content.match?(CUSTOM_ID_PATTERN)
+              process_heading_with_custom_id(tag, content)
+            else
+              "<#{tag}#{existing_attr}>#{content}</#{tag}>"
+            end
+          end
+        end
+
+        def process_heading_with_custom_id(tag, content)
+          custom_id = content.match(CUSTOM_ID_PATTERN)[1]
+          clean_content = content.sub(CUSTOM_ID_PATTERN, "")
+
+          "<#{tag} id=\"#{custom_id}\">#{clean_content}</#{tag}>"
+        end
+      end
+    end
+  end
+end