docyard 0.6.0 → 0.8.0

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,183 @@
+# frozen_string_literal: true
+
+module Docyard
+  class BrandingResolver
+    def initialize(config)
+      @config = config
+    end
+
+    SOCIAL_ICON_MAP = {
+      "x" => "x-logo", "twitter" => "x-logo", "discord" => "discord-logo",
+      "linkedin" => "linkedin-logo", "youtube" => "youtube-logo", "instagram" => "instagram-logo",
+      "facebook" => "facebook-logo", "tiktok" => "tiktok-logo", "twitch" => "twitch-logo",
+      "reddit" => "reddit-logo", "mastodon" => "mastodon-logo", "threads" => "threads-logo",
+      "pinterest" => "pinterest-logo", "medium" => "medium-logo", "slack" => "slack-logo",
+      "gitlab" => "gitlab-logo"
+    }.freeze
+
+    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,
+        credits: true,
+        social: []
+      }
+    end
+
+    def config_branding_options
+      site_options
+        .merge(logo_options)
+        .merge(search_options)
+        .merge(credits_options)
+        .merge(social_options)
+        .merge(navigation_options)
+        .merge(tabs_options)
+    end
+
+    def site_options
+      {
+        site_title: config.title || Constants::DEFAULT_SITE_TITLE,
+        site_description: config.description || "",
+        favicon: config.branding.favicon || auto_detect_favicon
+      }
+    end
+
+    def logo_options
+      branding = config.branding
+      logo = branding.logo || auto_detect_logo
+      has_custom_logo = !logo.nil?
+      {
+        logo: logo || Constants::DEFAULT_LOGO_PATH,
+        logo_dark: detect_dark_logo(logo) || Constants::DEFAULT_LOGO_DARK_PATH,
+        has_custom_logo: has_custom_logo
+      }
+    end
+
+    def auto_detect_logo
+      detect_public_file("logo", %w[svg png])
+    end
+
+    def auto_detect_favicon
+      detect_public_file("favicon", %w[ico svg png])
+    end
+
+    def detect_public_file(name, extensions)
+      extensions.each do |ext|
+        path = File.join(Constants::PUBLIC_DIR, "#{name}.#{ext}")
+        return "#{name}.#{ext}" if File.exist?(path)
+      end
+      nil
+    end
+
+    def detect_dark_logo(logo)
+      return nil unless logo
+
+      ext = File.extname(logo)
+      base = File.basename(logo, ext)
+      dark_filename = "#{base}-dark#{ext}"
+
+      if File.absolute_path?(logo)
+        dark_path = File.join(File.dirname(logo), dark_filename)
+        File.exist?(dark_path) ? dark_path : logo
+      else
+        dark_path = File.join("docs/public", dark_filename)
+        File.exist?(dark_path) ? dark_filename : logo
+      end
+    end
+
+    def search_options
+      {
+        search_enabled: config.search.enabled != false,
+        search_placeholder: config.search.placeholder || "Search..."
+      }
+    end
+
+    def credits_options
+      {
+        credits: config.branding.credits != false,
+        copyright: config.branding.copyright
+      }
+    end
+
+    def social_options
+      socials = config.socials || {}
+      {
+        social: normalize_social_links(socials)
+      }
+    end
+
+    def normalize_social_links(socials)
+      return [] unless socials.is_a?(Hash) && socials.any?
+
+      socials.filter_map { |platform, url| build_social_link(platform.to_s, url) }
+    end
+
+    def build_social_link(platform, url)
+      return if platform == "custom" || !valid_url?(url)
+
+      { platform: platform, url: url, icon: SOCIAL_ICON_MAP[platform] || platform }
+    end
+
+    def valid_url?(url)
+      url.is_a?(String) && !url.strip.empty?
+    end
+
+    def navigation_options
+      cta_items = config.navigation.cta || []
+      {
+        header_ctas: normalize_cta_items(cta_items)
+      }
+    end
+
+    def normalize_cta_items(items)
+      return [] unless items.is_a?(Array)
+
+      items.first(2).filter_map do |item|
+        next unless item.is_a?(Hash) && item["text"] && item["href"]
+
+        {
+          text: item["text"],
+          href: item["href"],
+          variant: item["variant"] || "primary",
+          external: item["external"] == true
+        }
+      end
+    end
+
+    def tabs_options
+      tab_items = config.tabs || []
+      {
+        tabs: normalize_tab_items(tab_items),
+        has_tabs: tab_items.any?
+      }
+    end
+
+    def normalize_tab_items(items)
+      return [] unless items.is_a?(Array)
+
+      items.filter_map do |item|
+        next unless item.is_a?(Hash) && item["text"] && item["href"]
+
+        {
+          text: item["text"],
+          href: item["href"],
+          icon: item["icon"],
+          external: item["external"] == true
+        }
+      end
+    end
+  end
+end

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

@@ -8,7 +8,9 @@ module Docyard
     CONTENT_TYPE_JS = "application/javascript; charset=utf-8"
 
     RELOAD_ENDPOINT = "/_docyard/reload"
-    ASSETS_PREFIX = "/assets/"
+    DOCYARD_ASSETS_PREFIX = "/_docyard/"
+    PAGEFIND_PREFIX = "/pagefind/"
+    PUBLIC_DIR = "docs/public"
 
     INDEX_FILE = "index"
     INDEX_TITLE = "Home"
@@ -17,12 +19,13 @@ module Docyard
     HTML_EXTENSION = ".html"
 
     STATUS_OK = 200
+    STATUS_REDIRECT = 302
     STATUS_NOT_FOUND = 404
     STATUS_INTERNAL_ERROR = 500
 
     DEFAULT_SITE_TITLE = "Documentation"
-    DEFAULT_LOGO_PATH = "assets/logo.svg"
-    DEFAULT_LOGO_DARK_PATH = "assets/logo-dark.svg"
-    DEFAULT_FAVICON_PATH = "assets/favicon.svg"
+    DEFAULT_LOGO_PATH = "_docyard/logo.svg"
+    DEFAULT_LOGO_DARK_PATH = "_docyard/logo-dark.svg"
+    DEFAULT_FAVICON_PATH = "_docyard/favicon.svg"
   end
 end