docyard 0.6.0 → 0.7.0

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

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../code_detector"
+
+module Docyard
+  module Components
+    module Support
+      module Tabs
+        class IconDetector
+          MANUAL_ICON_PATTERN = /^:([a-z0-9-]+):\s*(.+)$/i
+          CodeDetector = Support::CodeDetector
+
+          def self.detect(tab_name, tab_content)
+            new(tab_name, tab_content).detect
+          end
+
+          def initialize(tab_name, tab_content)
+            @tab_name = tab_name
+            @tab_content = tab_content
+          end
+
+          def detect
+            manual_icon || auto_detected_icon || no_icon
+          end
+
+          private
+
+          attr_reader :tab_name, :tab_content
+
+          def manual_icon
+            return nil unless tab_name.match(MANUAL_ICON_PATTERN)
+
+            {
+              name: Regexp.last_match(2).strip,
+              icon: Regexp.last_match(1),
+              icon_source: "phosphor"
+            }
+          end
+
+          def auto_detected_icon
+            detected = CodeDetector.detect(tab_content)
+            return nil unless detected
+
+            {
+              name: tab_name,
+              icon: detected[:icon],
+              icon_source: detected[:source]
+            }
+          end
+
+          def no_icon
+            {
+              name: tab_name,
+              icon: nil,
+              icon_source: nil
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/tabs/parser.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "../code_block/feature_extractor"
+require_relative "../code_block/icon_detector"
+require_relative "../code_block/line_wrapper"
+require_relative "icon_detector"
+require_relative "../../../rendering/icons"
+require_relative "../../../rendering/renderer"
+require "kramdown"
+require "kramdown-parser-gfm"
+require "cgi"
+
+module Docyard
+  module Components
+    module Support
+      module Tabs
+        class Parser
+          include Utils::HtmlHelpers
+
+          IconDetector = Tabs::IconDetector
+          CodeBlockFeatureExtractor = CodeBlock::FeatureExtractor
+          CodeBlockIconDetector = CodeBlock::IconDetector
+          CodeBlockLineWrapper = CodeBlock::LineWrapper
+
+          def self.parse(content)
+            new(content).parse
+          end
+
+          def initialize(content)
+            @content = content
+          end
+
+          def parse
+            sections.filter_map { |section| parse_section(section) }
+          end
+
+          private
+
+          attr_reader :content
+
+          def sections
+            content.split(/^==[ \t]+/)
+          end
+
+          def parse_section(section)
+            return nil if section.strip.empty?
+
+            tab_name, tab_content = extract_tab_parts(section)
+            return nil if tab_name.nil? || tab_name.empty?
+
+            build_tab_data(tab_name, tab_content)
+          end
+
+          def extract_tab_parts(section)
+            parts = section.split("\n", 2)
+            [parts[0]&.strip, parts[1]&.strip || ""]
+          end
+
+          def build_tab_data(tab_name, tab_content)
+            icon_data = IconDetector.detect(tab_name, tab_content)
+
+            extracted = CodeBlockFeatureExtractor.process_markdown(tab_content)
+            rendered_content = render_markdown(extracted[:cleaned_markdown])
+            enhanced_content = enhance_code_blocks(rendered_content, extracted[:blocks])
+
+            {
+              name: icon_data[:name],
+              content: enhanced_content,
+              icon: icon_data[:icon],
+              icon_source: icon_data[:icon_source]
+            }
+          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 = if needs_line_wrapping?(block_data)
+                               wrap_code_block_lines(original_html, block_data)
+                             else
+                               original_html
+                             end
+
+            Renderer.new.render_partial("_code_block", build_full_locals(processed_html, code_text, 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 wrap_code_block_lines(html, block_data)
+            wrapper_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])
+            }
+            CodeBlockLineWrapper.wrap_code_block(html, wrapper_data)
+          end
+
+          def build_full_locals(processed_html, code_text, block_data)
+            title_data = CodeBlockIconDetector.detect(block_data[:title], block_data[:lang])
+            show_line_numbers = line_numbers_enabled?(block_data[:option])
+            start_line = extract_start_line(block_data[:option])
+
+            base_locals(processed_html, code_text, show_line_numbers, start_line)
+              .merge(feature_locals(block_data))
+              .merge(title_locals(title_data))
+          end
+
+          def base_locals(processed_html, code_text, show_line_numbers, start_line)
+            {
+              code_block_html: processed_html,
+              code_text: escape_html_attribute(code_text),
+              copy_icon: Icons.render("copy", "regular") || "",
+              show_line_numbers: show_line_numbers,
+              line_numbers: show_line_numbers ? generate_line_numbers(code_text, start_line) : [],
+              start_line: start_line
+            }
+          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_data)
+            {
+              title: title_data[:title],
+              icon: title_data[:icon],
+              icon_source: title_data[:icon_source]
+            }
+          end
+
+          def line_numbers_enabled?(block_option)
+            return false if block_option == ":no-line-numbers"
+            return true if block_option&.start_with?(":line-numbers")
+
+            false
+          end
+
+          def extract_start_line(block_option)
+            return 1 unless block_option&.include?("=")
+
+            block_option.split("=").last.to_i
+          end
+
+          def generate_line_numbers(code_text, start_line)
+            line_count = code_text.lines.count
+            line_count = 1 if line_count.zero?
+            (start_line...(start_line + line_count)).to_a
+          end
+
+          def extract_code_text(html)
+            text = html.gsub(/<[^>]+>/, "")
+            text = CGI.unescapeHTML(text)
+            text.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/tabs/range_finder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    module Support
+      module Tabs
+        module RangeFinder
+          module_function
+
+          def find_ranges(html)
+            ranges = []
+            start_pattern = '<div class="docyard-tabs"'
+
+            pos = 0
+            while (start_pos = html.index(start_pattern, pos))
+              end_pos = find_matching_close_div(html, start_pos)
+              ranges << (start_pos...end_pos) if end_pos
+              pos = end_pos || (start_pos + 1)
+            end
+            ranges
+          end
+
+          def find_matching_close_div(html, start_pos)
+            depth = 0
+            pos = start_pos
+
+            while pos < html.length
+              if html[pos, 4] == "<div"
+                depth += 1
+                pos += 4
+              elsif html[pos, 6] == "</div>"
+                depth -= 1
+                return pos + 6 if depth.zero?
+
+                pos += 6
+              else
+                pos += 1
+              end
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/config/branding_resolver.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Docyard
+  class BrandingResolver
+    def initialize(config)
+      @config = config
+    end
+
+    def resolve
+      return default_branding unless config
+
+      default_branding.merge(config_branding_options)
+    end
+
+    private
+
+    attr_reader :config
+
+    def default_branding
+      {
+        site_title: Constants::DEFAULT_SITE_TITLE,
+        site_description: "",
+        logo: Constants::DEFAULT_LOGO_PATH,
+        logo_dark: Constants::DEFAULT_LOGO_DARK_PATH,
+        favicon: nil,
+        display_logo: true,
+        display_title: true
+      }
+    end
+
+    def config_branding_options
+      site_options.merge(logo_options).merge(search_options).merge(appearance_options)
+    end
+
+    def site_options
+      {
+        site_title: config.site.title || Constants::DEFAULT_SITE_TITLE,
+        site_description: config.site.description || "",
+        favicon: config.branding.favicon
+      }
+    end
+
+    def logo_options
+      branding = config.branding
+      {
+        logo: resolve_logo(branding.logo, branding.logo_dark),
+        logo_dark: resolve_logo_dark(branding.logo, branding.logo_dark)
+      }
+    end
+
+    def search_options
+      {
+        search_enabled: config.search.enabled != false,
+        search_placeholder: config.search.placeholder || "Search documentation..."
+      }
+    end
+
+    def appearance_options
+      appearance = config.branding.appearance || {}
+      {
+        display_logo: appearance["logo"] != false,
+        display_title: appearance["title"] != false
+      }
+    end
+
+    def resolve_logo(logo, logo_dark)
+      logo || logo_dark || Constants::DEFAULT_LOGO_PATH
+    end
+
+    def resolve_logo_dark(logo, logo_dark)
+      logo_dark || logo || Constants::DEFAULT_LOGO_DARK_PATH
+    end
+  end
+end

data/lib/docyard/{constants.rb → config/constants.rb}

@@ -9,6 +9,7 @@ module Docyard
 
     RELOAD_ENDPOINT = "/_docyard/reload"
     ASSETS_PREFIX = "/assets/"
+    PAGEFIND_PREFIX = "/pagefind/"
 
     INDEX_FILE = "index"
     INDEX_TITLE = "Home"

data/lib/docyard/config.rb

@@ -2,7 +2,7 @@
 
 require "yaml"
 require_relative "config/validator"
-require_relative "constants"
+require_relative "config/constants"
 
 module Docyard
   class Config
@@ -37,6 +37,11 @@ module Docyard
       },
       "markdown" => {
         "lineNumbers" => false
+      },
+      "search" => {
+        "enabled" => true,
+        "placeholder" => "Search documentation...",
+        "exclude" => []
       }
     }.freeze
 
@@ -81,6 +86,10 @@ module Docyard
       @markdown ||= ConfigSection.new(data["markdown"])
     end
 
+    def search
+      @search ||= ConfigSection.new(data["search"])
+    end
+
     private
 
     def load_config_data

data/lib/docyard/{prev_next_builder.rb → navigation/prev_next_builder.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "renderer"
-require_relative "utils/path_resolver"
+require_relative "../rendering/renderer"
+require_relative "../utils/path_resolver"
 
 module Docyard
   class PrevNextBuilder