docyard 0.6.0 → 0.8.0

data/lib/docyard/components/tabs_processor.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../renderer"
-require_relative "base_processor"
-require_relative "tabs_parser"
-require "securerandom"
-
-module Docyard
-  module Components
-    class TabsProcessor < BaseProcessor
-      self.priority = 15
-
-      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

data/lib/docyard/components/tabs_range_finder.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Components
-    module TabsRangeFinder
-      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

data/lib/docyard/rack_application.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "rack"
-require_relative "sidebar_builder"
-require_relative "prev_next_builder"
-require_relative "constants"
-
-module Docyard
-  class RackApplication
-    def initialize(docs_path:, file_watcher:, config: nil)
-      @docs_path = docs_path
-      @file_watcher = file_watcher
-      @config = config
-      @router = Router.new(docs_path: docs_path)
-      @renderer = Renderer.new(base_url: config&.build&.base_url || "/", config: config)
-      @asset_handler = AssetHandler.new
-    end
-
-    def call(env)
-      handle_request(env)
-    end
-
-    private
-
-    attr_reader :docs_path, :file_watcher, :config, :router, :renderer, :asset_handler
-
-    def handle_request(env)
-      path = env["PATH_INFO"]
-
-      return handle_reload_check(env) if path == Constants::RELOAD_ENDPOINT
-      return asset_handler.serve(path) if path.start_with?(Constants::ASSETS_PREFIX)
-
-      handle_documentation_request(path)
-    rescue StandardError => e
-      handle_error(e)
-    end
-
-    def handle_documentation_request(path)
-      result = router.resolve(path)
-
-      if result.found?
-        render_documentation_page(result.file_path, path)
-      else
-        render_not_found_page
-      end
-    end
-
-    def render_documentation_page(file_path, current_path)
-      sidebar_builder = build_sidebar_instance(current_path)
-
-      html = renderer.render_file(
-        file_path,
-        sidebar_html: sidebar_builder.to_html,
-        prev_next_html: build_prev_next(sidebar_builder, current_path, file_path),
-        branding: branding_options
-      )
-
-      [Constants::STATUS_OK, { "Content-Type" => Constants::CONTENT_TYPE_HTML }, [html]]
-    end
-
-    def render_not_found_page
-      html = renderer.render_not_found
-      [Constants::STATUS_NOT_FOUND, { "Content-Type" => Constants::CONTENT_TYPE_HTML }, [html]]
-    end
-
-    def build_sidebar_instance(current_path)
-      SidebarBuilder.new(
-        docs_path: docs_path,
-        current_path: current_path,
-        config: config
-      )
-    end
-
-    def build_prev_next(sidebar_builder, current_path, file_path)
-      markdown_content = File.read(file_path)
-      markdown = Markdown.new(markdown_content)
-
-      PrevNextBuilder.new(
-        sidebar_tree: sidebar_builder.tree,
-        current_path: current_path,
-        frontmatter: markdown.frontmatter,
-        config: navigation_config
-      ).to_html
-    end
-
-    def navigation_config
-      return {} unless config
-
-      config.navigation&.footer || {}
-    end
-
-    def branding_options
-      return default_branding unless config
-
-      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
-    end
-
-    def handle_reload_check(env)
-      since = parse_since_timestamp(env)
-      reload_needed = file_watcher.changed_since?(since)
-
-      build_reload_response(reload_needed)
-    rescue StandardError => e
-      log_reload_error(e)
-      build_reload_response(false)
-    end
-
-    def parse_since_timestamp(env)
-      query = Rack::Utils.parse_query(env["QUERY_STRING"])
-      query["since"] ? Time.at(query["since"].to_f) : Time.now
-    end
-
-    def log_reload_error(error)
-      Docyard.logger.error "Reload check error: #{error.message}"
-      Docyard.logger.debug error.backtrace.join("\n")
-    end
-
-    def build_reload_response(reload_needed)
-      response_body = { reload: reload_needed, timestamp: Time.now.to_f }.to_json
-      [Constants::STATUS_OK, { "Content-Type" => Constants::CONTENT_TYPE_JSON }, [response_body]]
-    end
-
-    def handle_error(error)
-      Docyard.logger.error "Request error: #{error.message}"
-      Docyard.logger.debug error.backtrace.join("\n")
-      [Constants::STATUS_INTERNAL_ERROR, { "Content-Type" => Constants::CONTENT_TYPE_HTML },
-       [renderer.render_server_error(error)]]
-    end
-  end
-end

data/lib/docyard/renderer.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-require_relative "constants"
-
-module Docyard
-  class Renderer
-    LAYOUTS_PATH = File.join(__dir__, "templates", "layouts")
-    ERRORS_PATH = File.join(__dir__, "templates", "errors")
-    PARTIALS_PATH = File.join(__dir__, "templates", "partials")
-
-    attr_reader :layout_path, :base_url, :config
-
-    def initialize(layout: "default", base_url: "/", config: nil)
-      @layout_path = File.join(LAYOUTS_PATH, "#{layout}.html.erb")
-      @base_url = normalize_base_url(base_url)
-      @config = config
-    end
-
-    def render_file(file_path, sidebar_html: "", prev_next_html: "", branding: {})
-      markdown_content = File.read(file_path)
-      markdown = Markdown.new(markdown_content, config: config)
-
-      html_content = strip_md_from_links(markdown.html)
-      toc = markdown.toc
-
-      render(
-        content: html_content,
-        page_title: markdown.title || Constants::DEFAULT_SITE_TITLE,
-        navigation: {
-          sidebar_html: sidebar_html,
-          prev_next_html: prev_next_html,
-          toc: toc
-        },
-        branding: branding
-      )
-    end
-
-    def render(content:, page_title: Constants::DEFAULT_SITE_TITLE, navigation: {}, branding: {})
-      template = File.read(layout_path)
-
-      sidebar_html = navigation[:sidebar_html] || ""
-      prev_next_html = navigation[:prev_next_html] || ""
-      toc = navigation[:toc] || []
-
-      assign_content_variables(content, page_title, sidebar_html, prev_next_html, toc)
-      assign_branding_variables(branding)
-
-      ERB.new(template).result(binding)
-    end
-
-    def render_not_found
-      render_error_template(404)
-    end
-
-    def render_server_error(error)
-      @error_message = error.message
-      @backtrace = error.backtrace.join("\n")
-      render_error_template(500)
-    end
-
-    def render_error_template(status)
-      error_template_path = File.join(ERRORS_PATH, "#{status}.html.erb")
-      template = File.read(error_template_path)
-      ERB.new(template).result(binding)
-    end
-
-    def render_partial(name, locals = {})
-      partial_path = File.join(PARTIALS_PATH, "#{name}.html.erb")
-      template = File.read(partial_path)
-
-      locals.each { |key, value| instance_variable_set("@#{key}", value) }
-
-      ERB.new(template).result(binding)
-    end
-
-    def asset_path(path)
-      return path if path.nil? || path.start_with?("http://", "https://")
-
-      "#{base_url}#{path}"
-    end
-
-    def link_path(path)
-      return path if path.nil? || path.start_with?("http://", "https://")
-
-      "#{base_url.chomp('/')}#{path}"
-    end
-
-    private
-
-    def normalize_base_url(url)
-      return "/" if url.nil? || url.empty?
-
-      url = "/#{url}" unless url.start_with?("/")
-      url.end_with?("/") ? url : "#{url}/"
-    end
-
-    def assign_content_variables(content, page_title, sidebar_html, prev_next_html, toc)
-      @content = content
-      @page_title = page_title
-      @sidebar_html = sidebar_html
-      @prev_next_html = prev_next_html
-      @toc = toc
-    end
-
-    def assign_branding_variables(branding)
-      @site_title = branding[:site_title] || Constants::DEFAULT_SITE_TITLE
-      @site_description = branding[:site_description] || ""
-      @logo = branding[:logo] || Constants::DEFAULT_LOGO_PATH
-      @logo_dark = branding[:logo_dark]
-      @favicon = branding[:favicon] || Constants::DEFAULT_FAVICON_PATH
-      @display_logo = branding[:display_logo].nil? || branding[:display_logo]
-      @display_title = branding[:display_title].nil? || branding[:display_title]
-    end
-
-    def strip_md_from_links(html)
-      html.gsub(/href="([^"]+)\.md"/, 'href="\1"')
-    end
-  end
-end

data/lib/docyard/routing/resolution_result.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Routing
-    class ResolutionResult
-      attr_reader :file_path, :status
-
-      def self.found(file_path)
-        new(file_path: file_path, status: :found)
-      end
-
-      def self.not_found
-        new(file_path: nil, status: :not_found)
-      end
-
-      def initialize(file_path:, status:)
-        @file_path = file_path
-        @status = status
-        freeze
-      end
-
-      def found?
-        status == :found
-      end
-
-      def not_found?
-        status == :not_found
-      end
-    end
-  end
-end

data/lib/docyard/sidebar/config_parser.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "item"
-require_relative "title_extractor"
-
-module Docyard
-  module Sidebar
-    class ConfigParser
-      attr_reader :config_items, :docs_path, :current_path, :title_extractor
-
-      def initialize(config_items, docs_path:, current_path: "/", title_extractor: TitleExtractor.new)
-        @config_items = config_items || []
-        @docs_path = docs_path
-        @current_path = Utils::PathResolver.normalize(current_path)
-        @title_extractor = title_extractor
-      end
-
-      def parse
-        parse_items(config_items)
-      end
-
-      private
-
-      def parse_items(items, base_path = "")
-        items.map do |item_config|
-          parse_item(item_config, base_path)
-        end.compact
-      end
-
-      def parse_item(item_config, base_path)
-        case item_config
-        when String
-          resolve_file_item(item_config, base_path)
-        when Hash
-          parse_hash_item(item_config, base_path)
-        end
-      end
-
-      def parse_hash_item(item_config, base_path)
-        return parse_link_item(item_config) if link_item?(item_config)
-        return parse_nested_item(item_config, base_path) if nested_item?(item_config)
-        return resolve_file_item(item_config.keys.first, base_path, {}) if nil_value_item?(item_config)
-
-        slug = item_config.keys.first
-        options = item_config.values.first || {}
-        resolve_file_item(slug, base_path, options)
-      end
-
-      def link_item?(config)
-        config.key?("link") || config.key?(:link)
-      end
-
-      def nested_item?(config)
-        config.size == 1 && config.values.first.is_a?(Hash)
-      end
-
-      def nil_value_item?(config)
-        config.size == 1 && config.values.first.nil?
-      end
-
-      def parse_link_item(config)
-        link = config["link"] || config[:link]
-        text = config["text"] || config[:text]
-        icon = config["icon"] || config[:icon]
-        target = config["target"] || config[:target] || "_blank"
-
-        Item.new(
-          text: text,
-          link: link,
-          path: link,
-          icon: icon,
-          target: target,
-          type: :external
-        )
-      end
-
-      def parse_nested_item(item_config, base_path)
-        slug = item_config.keys.first.to_s
-        options = item_config.values.first || {}
-        nested_items = extract_nested_items(options)
-
-        dir_path = File.join(docs_path, base_path, slug)
-
-        if File.directory?(dir_path)
-          build_directory_item(slug, options, nested_items, base_path)
-        elsif nested_items.any?
-          build_file_with_children_item(slug, options, nested_items, base_path)
-        else
-          resolve_file_item(slug, base_path, options)
-        end
-      end
-
-      def extract_nested_items(options)
-        options["items"] || options[:items] || []
-      end
-
-      def extract_common_options(options)
-        {
-          text: options["text"] || options[:text],
-          icon: options["icon"] || options[:icon],
-          collapsed: options["collapsed"] || options[:collapsed] || false
-        }
-      end
-
-      def build_directory_item(slug, options, nested_items, base_path)
-        common_opts = extract_common_options(options)
-        new_base_path = File.join(base_path, slug)
-        parsed_items = parse_items(nested_items, new_base_path)
-
-        Item.new(
-          slug: slug,
-          text: common_opts[:text] || Utils::TextFormatter.titleize(slug),
-          icon: common_opts[:icon],
-          collapsed: common_opts[:collapsed],
-          items: parsed_items,
-          type: :directory
-        )
-      end
-
-      def build_file_with_children_item(slug, options, nested_items, base_path)
-        common_opts = extract_common_options(options)
-        file_path = File.join(docs_path, base_path, "#{slug}.md")
-        url_path = Utils::PathResolver.to_url(File.join(base_path, slug))
-        resolved_text = common_opts[:text] || extract_file_title(file_path, slug)
-
-        Item.new(
-          slug: slug,
-          text: resolved_text,
-          path: url_path,
-          icon: common_opts[:icon],
-          collapsed: common_opts[:collapsed],
-          items: parse_items(nested_items, base_path),
-          active: current_path == url_path,
-          type: :file
-        )
-      end
-
-      def extract_file_title(file_path, slug)
-        File.exist?(file_path) ? title_extractor.extract(file_path) : Utils::TextFormatter.titleize(slug)
-      end
-
-      def resolve_file_item(slug, base_path, options = {})
-        slug_str = slug.to_s
-        options ||= {}
-
-        file_path = File.join(docs_path, base_path, "#{slug_str}.md")
-        url_path = Utils::PathResolver.to_url(File.join(base_path, slug_str))
-
-        frontmatter = extract_frontmatter_metadata(file_path)
-        text = resolve_item_text(slug_str, file_path, options, frontmatter[:text])
-        icon = resolve_item_icon(options, frontmatter[:icon])
-        final_path = options["link"] || options[:link] || url_path
-
-        Item.new(
-          slug: slug_str, text: text, path: final_path, icon: icon,
-          active: current_path == final_path, type: :file
-        )
-      end
-
-      def extract_frontmatter_metadata(file_path)
-        return { text: nil, icon: nil } unless File.exist?(file_path)
-
-        markdown = Markdown.new(File.read(file_path))
-        {
-          text: markdown.sidebar_text || markdown.title,
-          icon: markdown.sidebar_icon
-        }
-      end
-
-      def resolve_item_text(slug, file_path, options, frontmatter_text)
-        text = options["text"] || options[:text] || frontmatter_text
-        text || extract_file_title(file_path, slug)
-      end
-
-      def resolve_item_icon(options, frontmatter_icon)
-        options["icon"] || options[:icon] || frontmatter_icon
-      end
-    end
-  end
-end

data/lib/docyard/sidebar/item.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    class Item
-      attr_reader :slug, :text, :icon, :link, :target, :collapsed, :items, :path, :active, :type
-
-      def initialize(**options)
-        @slug = options[:slug]
-        @text = options[:text]
-        @icon = options[:icon]
-        @link = options[:link]
-        @target = options[:target] || "_self"
-        @collapsed = options[:collapsed] || false
-        @items = options[:items] || []
-        @path = options[:path] || options[:link]
-        @active = options[:active] || false
-        @type = options[:type] || :file
-      end
-
-      def external?
-        return false if path.nil?
-
-        path.start_with?("http://", "https://")
-      end
-
-      def children?
-        items.any?
-      end
-
-      def title
-        text
-      end
-
-      def children
-        items
-      end
-
-      def collapsible?
-        children?
-      end
-
-      def to_h
-        {
-          title: title,
-          path: path,
-          icon: icon,
-          active: active,
-          type: type,
-          collapsed: collapsed,
-          collapsible: collapsible?,
-          target: target,
-          children: children.map(&:to_h)
-        }
-      end
-    end
-  end
-end