docyard 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34bf24256bf638697dbc86f9d146667a4f17594c365070313eb19e74f8ab5134
-  data.tar.gz: 357ea04d8822f47c98e2aee4e09ca9e8cc69b7e4d11cbdce1491874aaa459b5c
+  metadata.gz: e127990af44c6db555b00cfd2c7a89be408e6e4bfddf2bed9a753387f708ee87
+  data.tar.gz: ed54f92691fe29fc8dd83b8b797504162283bba12840c49c120a4341ac22a66c
 SHA512:
-  metadata.gz: bc5c55d5ad69b73ef286eec3b4e202c7312b3dfd7d67b79d491612357e1c4e6e03d255a78af97706bdd5fe19353b7dd96f2da046a4c17f2e363342fc265b5628
-  data.tar.gz: 855fdcdcf312f3778fd204ca1fd36825c183b1abf0a5c938edff599693930d519668b8fdb0770f65ae00f9db43d1b794e31ca922b29dbde73143caf6abd2f64c
+  metadata.gz: 7ae09bfea3ce92e5b5b8cee3e7317d6d57b253e17314adcfbf9f468cc0635a54d3cbd55a90f28807514875359e4d93b4e1c68fee99b7ec65a9ab12d34a21c6c2
+  data.tar.gz: 3c2148376ab27c804a148666795420afe24fe23cb890fa76fa2602af5434d9e60d589fcbb460454210d2dfe1cc38f1f8584db41b1209db14b8b21ec3d7abeb68

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-01-01
+
+### Added
+- **Full-text Search** - Pagefind-powered search with Cmd/Ctrl+K modal, keyboard navigation, and highlighting (#41)
+- **Search Configuration** - Customize placeholder text, enable/disable search, and exclude paths via `docyard.yml` (#41)
+- **Dev Server Search** - Opt-in search indexing during development with `--search` flag (#41)
+
+### Changed
+- Major codebase reorganization for improved maintainability (#42)
+- Components reorganized into `processors/` and `support/` subdirectories (#42)
+- Consolidated `server/`, `rendering/`, `navigation/`, `config/`, and `search/` modules (#42)
+- Extracted shared utilities into `utils/` module (#42)
+
 ## [0.6.0] - 2025-12-25
 
 ### Added
@@ -109,7 +122,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial gem structure
 - Project scaffolding
 
-[Unreleased]: https://github.com/sanifhimani/docyard/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/sanifhimani/docyard/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/sanifhimani/docyard/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/sanifhimani/docyard/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/sanifhimani/docyard/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/sanifhimani/docyard/compare/v0.3.0...v0.4.0

data/lib/docyard/build/static_generator.rb

@@ -18,7 +18,7 @@ module Docyard
         puts "\n[✓] Found #{markdown_files.size} markdown files"
 
         progress = TTY::ProgressBar.new(
-          "Generating pages [:bar] :current/:total (:percent%)",
+          "Generating pages [:bar] :current/:total (:percent)",
           total: markdown_files.size,
           width: 50
         )
@@ -89,48 +89,7 @@ module Docyard
       end
 
       def branding_options
-        default_branding.merge(config_branding_options)
-      end
-
-      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 = config.site
-        branding = config.branding
-
-        {
-          site_title: site.title || Constants::DEFAULT_SITE_TITLE,
-          site_description: site.description || "",
-          logo: resolve_logo(branding.logo, branding.logo_dark),
-          logo_dark: resolve_logo_dark(branding.logo, branding.logo_dark),
-          favicon: branding.favicon
-        }.merge(appearance_options(branding.appearance))
-      end
-
-      def appearance_options(appearance)
-        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
+        BrandingResolver.new(config).resolve
       end
 
       def log(message)

data/lib/docyard/builder.rb

@@ -22,8 +22,9 @@ module Docyard
       bundles_created = bundle_assets
       assets_copied = copy_static_files
       generate_seo_files
+      pages_indexed = generate_search_index
 
-      display_summary(pages_built, bundles_created, assets_copied)
+      display_summary(pages_built, bundles_created, assets_copied, pages_indexed)
       true
     rescue StandardError => e
       error "Build failed: #{e.message}"
@@ -68,7 +69,12 @@ module Docyard
       sitemap_gen.generate
 
       File.write(File.join(config.build.output_dir, "robots.txt"), robots_txt_content)
-      log "[✓] Generated robots.txt"
+      log "[+] Generated robots.txt"
+    end
+
+    def generate_search_index
+      indexer = Search::BuildIndexer.new(config, verbose: verbose)
+      indexer.index
     end
 
     def robots_txt_content
@@ -83,13 +89,17 @@ module Docyard
       ROBOTS
     end
 
-    def display_summary(pages, bundles, assets)
+    def display_summary(pages, bundles, assets, indexed = 0)
       elapsed = Time.now - start_time
 
       puts "\n#{'=' * 50}"
       puts "Build complete in #{format('%.2f', elapsed)}s"
       puts "Output: #{config.build.output_dir}/"
-      puts "#{pages} pages, #{bundles} bundles, #{assets} static files"
+
+      summary = "#{pages} pages, #{bundles} bundles, #{assets} static files"
+      summary += ", #{indexed} pages indexed" if indexed.positive?
+      puts summary
+
       puts "=" * 50
     end
 

data/lib/docyard/cli.rb

@@ -34,18 +34,21 @@ module Docyard
     desc "preview", "Preview the built site locally"
     method_option :port, type: :numeric, default: 4000, aliases: "-p", desc: "Port to run preview server on"
     def preview
-      require_relative "preview_server"
+      require_relative "server/preview_server"
       Docyard::PreviewServer.new(port: options[:port]).start
     end
 
     desc "serve", "Start the development server"
     method_option :port, type: :numeric, default: 4200, aliases: "-p", desc: "Port to run the server on"
     method_option :host, type: :string, default: "localhost", aliases: "-h", desc: "Host to bind the server to"
+    method_option :search, type: :boolean, default: false, aliases: "-s",
+                           desc: "Enable search indexing (slower startup)"
     def serve
-      require_relative "server"
+      require_relative "server/dev_server"
       server = Docyard::Server.new(
         port: options[:port],
-        host: options[:host]
+        host: options[:host],
+        search: options[:search]
       )
       server.start
     end

data/lib/docyard/components/aliases.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    CalloutProcessor = Processors::CalloutProcessor
+    CodeBlockProcessor = Processors::CodeBlockProcessor
+    CodeBlockDiffPreprocessor = Processors::CodeBlockDiffPreprocessor
+    CodeBlockFocusPreprocessor = Processors::CodeBlockFocusPreprocessor
+    CodeBlockOptionsPreprocessor = Processors::CodeBlockOptionsPreprocessor
+    CodeSnippetImportPreprocessor = Processors::CodeSnippetImportPreprocessor
+    HeadingAnchorProcessor = Processors::HeadingAnchorProcessor
+    IconProcessor = Processors::IconProcessor
+    TableOfContentsProcessor = Processors::TableOfContentsProcessor
+    TableWrapperProcessor = Processors::TableWrapperProcessor
+    TabsProcessor = Processors::TabsProcessor
+
+    CodeDetector = Support::CodeDetector
+    IconDetector = Support::Tabs::IconDetector
+
+    CodeBlockFeatureExtractor = Support::CodeBlock::FeatureExtractor
+    CodeBlockIconDetector = Support::CodeBlock::IconDetector
+    CodeBlockLineWrapper = Support::CodeBlock::LineWrapper
+    CodeBlockPatterns = Support::CodeBlock::Patterns
+    CodeLineParser = Support::CodeBlock::LineParser
+
+    TabsParser = Support::Tabs::Parser
+    TabsRangeFinder = Support::Tabs::RangeFinder
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../../rendering/icons"
+require_relative "../../rendering/renderer"
+require_relative "../base_processor"
+require "kramdown"
+require "kramdown-parser-gfm"
+
+module Docyard
+  module Components
+    module Processors
+      class CalloutProcessor < BaseProcessor
+        self.priority = 10
+
+        CALLOUT_TYPES = {
+          "note" => { title: "Note", icon: "info", color: "note" },
+          "tip" => { title: "Tip", icon: "lightbulb", color: "tip" },
+          "important" => { title: "Important", icon: "warning-circle", color: "important" },
+          "warning" => { title: "Warning", icon: "warning", color: "warning" },
+          "danger" => { title: "Danger", icon: "siren", color: "danger" }
+        }.freeze
+
+        GITHUB_ALERT_TYPES = {
+          "NOTE" => "note",
+          "TIP" => "tip",
+          "IMPORTANT" => "important",
+          "WARNING" => "warning",
+          "CAUTION" => "danger"
+        }.freeze
+
+        def preprocess(markdown)
+          process_container_syntax(markdown)
+        end
+
+        def postprocess(html)
+          process_github_alerts(html)
+        end
+
+        private
+
+        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))
+          end
+        end
+
+        def process_callout_match(original_match, type_raw, custom_title, content_markdown)
+          type = type_raw.downcase
+          return original_match unless CALLOUT_TYPES.key?(type)
+
+          config = CALLOUT_TYPES[type]
+          title = determine_title(custom_title, config[:title])
+          content_html = render_markdown_content(content_markdown.strip)
+
+          wrap_in_nomarkdown(render_callout_html(type, title, content_html, config[:icon]))
+        end
+
+        def determine_title(custom_title, default_title)
+          title = custom_title&.strip
+          title.nil? || title.empty? ? default_title : title
+        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 process_github_alerts(html)
+          github_alert_regex = %r{
+            <blockquote>\s*
+            <p>\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*
+            (?:<br\s*/>)?\s*
+            (.*?)</p>
+            (.*?)
+            </blockquote>
+          }mx
+
+          html.gsub(github_alert_regex) do
+            process_github_alert_match(Regexp.last_match(1), Regexp.last_match(2), Regexp.last_match(3))
+          end
+        end
+
+        def process_github_alert_match(alert_type, first_para, rest_content)
+          type = GITHUB_ALERT_TYPES[alert_type]
+          config = CALLOUT_TYPES[type]
+          content_html = combine_alert_content(first_para.strip, rest_content.strip)
+
+          render_callout_html(type, config[:title], content_html, config[:icon])
+        end
+
+        def combine_alert_content(first_para, rest_content)
+          return "<p>#{first_para}</p>" if rest_content.empty?
+
+          "<p>#{first_para}</p>#{rest_content}"
+        end
+
+        def render_callout_html(type, title, content_html, icon_name)
+          icon_svg = Icons.render(icon_name, "duotone") || ""
+          renderer = Renderer.new
+
+          renderer.render_partial(
+            "_callout", {
+              type: type,
+              title: title,
+              content_html: content_html,
+              icon_svg: icon_svg
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+require_relative "../support/code_block/patterns"
+
+module Docyard
+  module Components
+    module Processors
+      class CodeBlockDiffPreprocessor < BaseProcessor
+        include Support::CodeBlock::Patterns
+
+        self.priority = 6
+
+        CODE_BLOCK_REGEX = /^```(\w*).*?\n(.*?)^```/m
+        TABS_BLOCK_REGEX = /^:::[ \t]*tabs[ \t]*\n.*?^:::[ \t]*$/m
+
+        def preprocess(content)
+          context[:code_block_diff_lines] ||= []
+          context[:code_block_error_lines] ||= []
+          context[:code_block_warning_lines] ||= []
+          @block_index = 0
+          @tabs_ranges = find_tabs_ranges(content)
+
+          content.gsub(CODE_BLOCK_REGEX) { |_| process_code_block(Regexp.last_match) }
+        end
+
+        private
+
+        def process_code_block(match)
+          return match[0] if inside_tabs?(match.begin(0))
+
+          result = extract_all_markers(match[2])
+          store_extracted_markers(result)
+          @block_index += 1
+          match[0].sub(match[2], result[:cleaned_content])
+        end
+
+        def store_extracted_markers(result)
+          context[:code_block_diff_lines][@block_index] = result[:diff_lines]
+          context[:code_block_error_lines][@block_index] = result[:error_lines]
+          context[:code_block_warning_lines][@block_index] = result[:warning_lines]
+        end
+
+        def extract_all_markers(code_content)
+          diff_info = extract_diff_lines(code_content)
+          error_info = extract_error_lines(diff_info[:cleaned_content])
+          warning_info = extract_warning_lines(error_info[:cleaned_content])
+
+          {
+            diff_lines: diff_info[:lines],
+            error_lines: error_info[:lines],
+            warning_lines: warning_info[:lines],
+            cleaned_content: warning_info[:cleaned_content]
+          }
+        end
+
+        def extract_diff_lines(code_content)
+          extract_marker_lines(code_content, DIFF_MARKER_PATTERN) do |match|
+            diff_type = match.captures.compact.first
+            diff_type == "++" ? :addition : :deletion
+          end
+        end
+
+        def extract_error_lines(code_content)
+          extract_marker_lines(code_content, ERROR_MARKER_PATTERN) { true }
+        end
+
+        def extract_warning_lines(code_content)
+          extract_marker_lines(code_content, WARNING_MARKER_PATTERN) { true }
+        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 (match = line.match(pattern))
+              marker_lines[line_num] = yield(match)
+              cleaned_lines << line.gsub(pattern, "")
+            else
+              cleaned_lines << line
+            end
+          end
+
+          { lines: marker_lines, cleaned_content: cleaned_lines.join }
+        end
+
+        def inside_tabs?(position)
+          @tabs_ranges.any? { |range| range.cover?(position) }
+        end
+
+        def find_tabs_ranges(content)
+          ranges = []
+          content.scan(TABS_BLOCK_REGEX) do
+            match = Regexp.last_match
+            ranges << (match.begin(0)...match.end(0))
+          end
+          ranges
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class CodeBlockFocusPreprocessor < BaseProcessor
+        self.priority = 7
+
+        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
+
+        CODE_BLOCK_REGEX = /^```(\w*).*?\n(.*?)^```/m
+        TABS_BLOCK_REGEX = /^:::[ \t]*tabs[ \t]*\n.*?^:::[ \t]*$/m
+
+        def preprocess(content)
+          context[:code_block_focus_lines] ||= []
+          @block_index = 0
+          @tabs_ranges = find_tabs_ranges(content)
+
+          content.gsub(CODE_BLOCK_REGEX) { |_| process_code_block(Regexp.last_match) }
+        end
+
+        private
+
+        def process_code_block(match)
+          return match[0] if inside_tabs?(match.begin(0))
+
+          focus_info = extract_focus_lines(match[2])
+          context[:code_block_focus_lines][@block_index] = focus_info[:lines]
+          @block_index += 1
+          match[0].sub(match[2], focus_info[:cleaned_content])
+        end
+
+        def extract_focus_lines(code_content)
+          lines = code_content.lines
+          focus_lines = {}
+          cleaned_lines = []
+
+          lines.each_with_index do |line, index|
+            line_num = index + 1
+
+            if line.match?(FOCUS_MARKER_PATTERN)
+              focus_lines[line_num] = true
+              cleaned_line = line.gsub(FOCUS_MARKER_PATTERN, "")
+              cleaned_lines << cleaned_line
+            else
+              cleaned_lines << line
+            end
+          end
+
+          { lines: focus_lines, cleaned_content: cleaned_lines.join }
+        end
+
+        def inside_tabs?(position)
+          @tabs_ranges.any? { |range| range.cover?(position) }
+        end
+
+        def find_tabs_ranges(content)
+          ranges = []
+          content.scan(TABS_BLOCK_REGEX) do
+            match = Regexp.last_match
+            ranges << (match.begin(0)...match.end(0))
+          end
+          ranges
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+
+module Docyard
+  module Components
+    module Processors
+      class CodeBlockOptionsPreprocessor < BaseProcessor
+        self.priority = 5
+
+        CODE_FENCE_REGEX = /^```(\w+)(?:\s*\[([^\]]+)\])?(:\S+)?(?:\s*\{([^}\n]+)\})?/
+        TABS_BLOCK_REGEX = /^:::[ \t]*tabs[ \t]*\n.*?^:::[ \t]*$/m
+
+        def preprocess(content)
+          context[:code_block_options] ||= []
+          @tabs_ranges = find_tabs_ranges(content)
+
+          process_code_fences(content)
+        end
+
+        private
+
+        def process_code_fences(content)
+          result = +""
+          last_end = 0
+
+          content.scan(CODE_FENCE_REGEX) do
+            match = Regexp.last_match
+            result << content[last_end...match.begin(0)]
+            result << process_fence_match(match)
+            last_end = match.end(0)
+          end
+
+          result << content[last_end..]
+        end
+
+        def process_fence_match(match)
+          store_code_block_options(match) unless inside_tabs?(match.begin(0))
+          "```#{match[1]}"
+        end
+
+        def store_code_block_options(match)
+          context[:code_block_options] << {
+            lang: match[1],
+            title: match[2],
+            option: match[3],
+            highlights: parse_highlights(match[4])
+          }
+        end
+
+        def inside_tabs?(position)
+          @tabs_ranges.any? { |range| range.cover?(position) }
+        end
+
+        def find_tabs_ranges(content)
+          ranges = []
+          content.scan(TABS_BLOCK_REGEX) do
+            match = Regexp.last_match
+            ranges << (match.begin(0)...match.end(0))
+          end
+          ranges
+        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
+      end
+    end
+  end
+end