docyard 0.6.0 → 0.8.0

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/renderer"
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class HeadingAnchorProcessor < BaseProcessor
+        self.priority = 30
+
+        def postprocess(html)
+          add_anchor_links(html)
+        end
+
+        private
+
+        def add_anchor_links(html)
+          html.gsub(%r{<(h[2-6])\s+id="([^"]+)">(.*?)</\1>}m) do |_match|
+            tag = Regexp.last_match(1)
+            id = Regexp.last_match(2)
+            content = Regexp.last_match(3)
+
+            anchor_html = render_anchor_link(id)
+
+            "<#{tag} id=\"#{id}\">#{content}#{anchor_html}</#{tag}>"
+          end
+        end
+
+        def render_anchor_link(id)
+          renderer = Renderer.new
+          renderer.render_partial("_heading_anchor", {
+                                    id: id
+                                  })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/icons"
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class IconProcessor < BaseProcessor
+        self.priority = 20
+
+        ICON_PATTERN = /:([a-z][a-z0-9-]*):(?:([a-z]+):)?/i
+
+        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(ICON_PATTERN) do
+            icon_name = Regexp.last_match(1)
+            weight = Regexp.last_match(2) || "regular"
+            Icons.render(icon_name, weight) || Regexp.last_match(0)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class TableOfContentsProcessor < BaseProcessor
+        self.priority = 35
+
+        def postprocess(html)
+          headings = extract_headings(html)
+          context[:toc] = headings
+          html
+        end
+
+        private
+
+        def extract_headings(html)
+          headings = []
+
+          html.scan(%r{<(h[2-4])\s+id="([^"]+)">(.*?)</\1>}m) do
+            level = Regexp.last_match(1)[1].to_i
+            id = Regexp.last_match(2)
+            text = strip_html(Regexp.last_match(3))
+
+            headings << {
+              level: level,
+              id: id,
+              text: text
+            }
+          end
+
+          build_hierarchy(headings)
+        end
+
+        def build_hierarchy(headings)
+          return [] if headings.empty?
+
+          root = []
+          stack = []
+
+          headings.each do |heading|
+            heading[:children] = []
+
+            stack.pop while stack.any? && stack.last[:level] >= heading[:level]
+
+            if stack.empty?
+              root << heading
+            else
+              stack.last[:children] << heading
+            end
+
+            stack << heading
+          end
+
+          root
+        end
+
+        def strip_html(text)
+          text.gsub(%r{<a[^>]*class="heading-anchor"[^>]*>.*?</a>}, "")
+            .gsub(/<[^>]+>/, "")
+            .strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class TableWrapperProcessor < BaseProcessor
+        self.priority = 100
+
+        def postprocess(html)
+          wrapped = html.gsub(/<table([^>]*)>/) do
+            attributes = Regexp.last_match(1)
+            "<div class=\"table-wrapper\"><table#{attributes}>"
+          end
+
+          wrapped.gsub("</table>", "</table></div>")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/renderer"
+require_relative "../base_processor"
+require_relative "../support/tabs/parser"
+require "securerandom"
+
+module Docyard
+  module Components
+    module Processors
+      class TabsProcessor < BaseProcessor
+        self.priority = 15
+
+        TabsParser = Support::Tabs::Parser
+
+        def preprocess(content)
+          return content unless content.include?(":::tabs")
+
+          content.gsub(/^:::[ \t]*tabs[ \t]*\n(.*?)^:::[ \t]*$/m) do
+            process_tabs_block(Regexp.last_match(1))
+          end
+        end
+
+        private
+
+        def process_tabs_block(tabs_content)
+          tabs = TabsParser.parse(tabs_content)
+          return "" if tabs.empty?
+
+          wrap_in_nomarkdown(render_tabs(tabs))
+        end
+
+        def render_tabs(tabs)
+          Renderer.new.render_partial(
+            "_tabs", {
+              tabs: tabs,
+              group_id: SecureRandom.hex(4)
+            }
+          )
+        end
+
+        def wrap_in_nomarkdown(html)
+          "{::nomarkdown}\n#{html}\n{:/nomarkdown}"
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_block/feature_extractor.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "patterns"
+
+module Docyard
+  module Components
+    module Support
+      module CodeBlock
+        module FeatureExtractor
+          include Patterns
+
+          CODE_FENCE_REGEX = /^```(\w+)(?:\s*\[([^\]]+)\])?(:\S+)?(?:\s*\{([^}\n]+)\})?[ \t]*\n(.*?)^```/m
+
+          module_function
+
+          def process_markdown(markdown)
+            blocks = []
+            cleaned = markdown.gsub(CODE_FENCE_REGEX) do
+              block_data = extract_block_data(Regexp.last_match)
+              blocks << block_data
+              "```#{block_data[:lang]}\n#{block_data[:cleaned_content]}```"
+            end
+            { cleaned_markdown: cleaned, blocks: blocks }
+          end
+
+          def extract_block_data(match)
+            code_content = match[5]
+            diff_info = extract_diff_lines(code_content)
+            focus_info = extract_focus_lines(diff_info[:cleaned_content])
+            error_info = extract_error_lines(focus_info[:cleaned_content])
+            warning_info = extract_warning_lines(error_info[:cleaned_content])
+
+            build_block_result(match, diff_info, focus_info, error_info, warning_info)
+          end
+
+          def build_block_result(match, diff_info, focus_info, error_info, warning_info)
+            {
+              lang: match[1],
+              title: match[2],
+              option: match[3],
+              highlights: parse_highlights(match[4]),
+              diff_lines: diff_info[:lines],
+              focus_lines: focus_info[:lines],
+              error_lines: error_info[:lines],
+              warning_lines: warning_info[:lines],
+              cleaned_content: warning_info[:cleaned_content]
+            }
+          end
+
+          def parse_highlights(highlights_str)
+            return [] if highlights_str.nil? || highlights_str.strip.empty?
+
+            highlights_str.split(",").flat_map { |part| parse_highlight_part(part.strip) }.uniq.sort
+          end
+
+          def parse_highlight_part(part)
+            return (part.split("-")[0].to_i..part.split("-")[1].to_i).to_a if part.include?("-")
+
+            [part.to_i]
+          end
+
+          def extract_diff_lines(code_content)
+            lines = code_content.lines
+            diff_lines = {}
+            cleaned_lines = []
+
+            lines.each_with_index do |line, index|
+              line_num = index + 1
+
+              if (match = line.match(DIFF_MARKER_PATTERN))
+                diff_type = match.captures.compact.first
+                diff_lines[line_num] = diff_type == "++" ? :addition : :deletion
+                cleaned_line = line.gsub(DIFF_MARKER_PATTERN, "")
+                cleaned_lines << cleaned_line
+              else
+                cleaned_lines << line
+              end
+            end
+
+            { lines: diff_lines, cleaned_content: cleaned_lines.join }
+          end
+
+          def extract_focus_lines(code_content)
+            extract_marker_lines(code_content, FOCUS_MARKER_PATTERN)
+          end
+
+          def extract_error_lines(code_content)
+            extract_marker_lines(code_content, ERROR_MARKER_PATTERN)
+          end
+
+          def extract_warning_lines(code_content)
+            extract_marker_lines(code_content, WARNING_MARKER_PATTERN)
+          end
+
+          def extract_marker_lines(code_content, pattern)
+            lines = code_content.lines
+            marker_lines = {}
+            cleaned_lines = []
+
+            lines.each_with_index do |line, index|
+              line_num = index + 1
+
+              if line.match?(pattern)
+                marker_lines[line_num] = true
+                cleaned_lines << line.gsub(pattern, "")
+              else
+                cleaned_lines << line
+              end
+            end
+
+            { lines: marker_lines, cleaned_content: cleaned_lines.join }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_block/icon_detector.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../../rendering/language_mapping"
+
+module Docyard
+  module Components
+    module Support
+      module CodeBlock
+        module IconDetector
+          MANUAL_ICON_PATTERN = /^:([a-z0-9-]+):\s*(.+)$/i
+
+          module_function
+
+          def detect(title, language)
+            return { title: nil, icon: nil, icon_source: nil } if title.nil?
+
+            if (match = title.match(MANUAL_ICON_PATTERN))
+              return {
+                title: match[2].strip,
+                icon: match[1],
+                icon_source: "phosphor"
+              }
+            end
+
+            icon, icon_source = auto_detect_icon(language)
+            { title: title, icon: icon, icon_source: icon_source }
+          end
+
+          def auto_detect_icon(language)
+            return [nil, nil] if language.nil?
+
+            if LanguageMapping.terminal_language?(language)
+              %w[terminal-window phosphor]
+            elsif (ext = LanguageMapping.extension_for(language))
+              [ext, "file-extension"]
+            else
+              %w[file phosphor]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_block/line_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    module Support
+      module CodeBlock
+        class LineParser
+          def initialize(code_content)
+            @code_content = code_content
+            @lines = []
+            @current_line = ""
+            @open_tags = []
+            @in_tag = false
+            @tag_buffer = ""
+          end
+
+          def parse
+            @code_content.each_char { |char| process_char(char) }
+            finalize
+          end
+
+          private
+
+          def process_char(char)
+            case char
+            when "<" then start_tag(char)
+            when ">" then end_tag_if_applicable(char)
+            when "\n" then handle_newline
+            else handle_regular_char(char)
+            end
+          end
+
+          def start_tag(char)
+            @in_tag = true
+            @tag_buffer = char
+          end
+
+          def end_tag_if_applicable(char)
+            if @in_tag
+              @in_tag = false
+              @tag_buffer += char
+
+              if @tag_buffer.start_with?("</")
+                @open_tags.pop
+              elsif !@tag_buffer.end_with?("/>")
+                @open_tags << @tag_buffer
+              end
+
+              @current_line += @tag_buffer
+              @tag_buffer = ""
+            else
+              @current_line += char
+            end
+          end
+
+          def handle_newline
+            closing_tags = @open_tags.reverse.map { |tag| closing_tag_for(tag) }.join
+            @lines << "#{@current_line}#{closing_tags}\n"
+            @current_line = @open_tags.join
+          end
+
+          def handle_regular_char(char)
+            if @in_tag
+              @tag_buffer += char
+            else
+              @current_line += char
+            end
+          end
+
+          def finalize
+            @lines << @current_line unless @current_line.empty?
+            @lines << "" if @lines.empty?
+            @lines
+          end
+
+          def closing_tag_for(open_tag)
+            tag_name = open_tag.match(/<(\w+)/)[1]
+            "</#{tag_name}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_block/line_wrapper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "line_parser"
+
+module Docyard
+  module Components
+    module Support
+      module CodeBlock
+        module LineWrapper
+          module_function
+
+          def wrap_code_block(html, block_data)
+            html.gsub(%r{<pre[^>]*><code[^>]*>(.*?)</code></pre>}m) do
+              pre_match = Regexp.last_match(0)
+              code_content = Regexp.last_match(1)
+              lines = LineParser.new(code_content).parse
+              wrapped_lines = wrap_lines_with_classes(lines, block_data)
+              pre_match.sub(code_content, wrapped_lines.join)
+            end
+          end
+
+          def wrap_lines_with_classes(lines, block_data)
+            lines.each_with_index.map do |line, index|
+              source_line = index + 1
+              display_line = block_data[:start_line] + index
+              classes = build_line_classes(source_line, display_line, block_data)
+              %(<span class="#{classes}">#{line}</span>)
+            end
+          end
+
+          DIFF_CLASSES = { addition: "docyard-code-line--diff-add", deletion: "docyard-code-line--diff-remove" }.freeze
+
+          def build_line_classes(source_line, display_line, block_data)
+            (["docyard-code-line"] + feature_classes(source_line, display_line, block_data)).join(" ")
+          end
+
+          def feature_classes(source_line, display_line, block_data)
+            [
+              ("docyard-code-line--highlighted" if block_data[:highlights].include?(display_line)),
+              DIFF_CLASSES[block_data[:diff_lines][source_line]],
+              ("docyard-code-line--focus" if block_data[:focus_lines][source_line]),
+              ("docyard-code-line--error" if block_data[:error_lines][source_line]),
+              ("docyard-code-line--warning" if block_data[:warning_lines][source_line])
+            ].compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_block/patterns.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    module Support
+      module CodeBlock
+        module Patterns
+          DIFF_MARKER_PATTERN = %r{
+            (?:
+              //\s*\[!code\s*([+-]{2})\]              |
+              \#\s*\[!code\s*([+-]{2})\]              |
+              /\*\s*\[!code\s*([+-]{2})\]\s*\*/       |
+              --\s*\[!code\s*([+-]{2})\]              |
+              <!--\s*\[!code\s*([+-]{2})\]\s*-->      |
+              ;\s*\[!code\s*([+-]{2})\]
+            )[^\S\n]*
+          }x
+
+          FOCUS_MARKER_PATTERN = %r{
+            (?:
+              //\s*\[!code\s+focus\]              |
+              \#\s*\[!code\s+focus\]              |
+              /\*\s*\[!code\s+focus\]\s*\*/       |
+              --\s*\[!code\s+focus\]              |
+              <!--\s*\[!code\s+focus\]\s*-->      |
+              ;\s*\[!code\s+focus\]
+            )[^\S\n]*
+          }x
+
+          ERROR_MARKER_PATTERN = %r{
+            (?:
+              //\s*\[!code\s+error\]              |
+              \#\s*\[!code\s+error\]              |
+              /\*\s*\[!code\s+error\]\s*\*/       |
+              --\s*\[!code\s+error\]              |
+              <!--\s*\[!code\s+error\]\s*-->      |
+              ;\s*\[!code\s+error\]
+            )[^\S\n]*
+          }x
+
+          WARNING_MARKER_PATTERN = %r{
+            (?:
+              //\s*\[!code\s+warning\]              |
+              \#\s*\[!code\s+warning\]              |
+              /\*\s*\[!code\s+warning\]\s*\*/       |
+              --\s*\[!code\s+warning\]              |
+              <!--\s*\[!code\s+warning\]\s*-->      |
+              ;\s*\[!code\s+warning\]
+            )[^\S\n]*
+          }x
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/language_mapping"
+
+module Docyard
+  module Components
+    module Support
+      class CodeDetector
+        def self.detect(content)
+          new(content).detect
+        end
+
+        def initialize(content)
+          @content = content
+        end
+
+        def detect
+          return nil unless code_only?
+
+          language = extract_language
+          return nil unless language
+
+          icon_for_language(language)
+        end
+
+        private
+
+        attr_reader :content
+
+        def code_only?
+          stripped = content.strip
+          return false unless stripped.start_with?("```") && stripped.end_with?("```")
+
+          parts = stripped.split("```")
+          parts.length == 2 && parts[0].empty?
+        end
+
+        def extract_language
+          parts = content.strip.split("```")
+          return nil unless parts[1]
+
+          lines = parts[1].split("\n", 2)
+          lang_line = lines[0].strip
+          return nil if lang_line.empty? || lang_line.include?(" ")
+
+          lang_line.downcase
+        end
+
+        def icon_for_language(language)
+          if LanguageMapping.terminal_language?(language)
+            { icon: "terminal-window", source: "phosphor" }
+          elsif (extension = LanguageMapping.extension_for(language))
+            { icon: extension, source: "file-extension" }
+          else
+            { icon: "file", source: "phosphor" }
+          end
+        end
+      end
+    end
+  end
+end