docyard 0.6.0 → 0.8.0

data/lib/docyard/{asset_handler.rb → server/asset_handler.rb}

@@ -2,8 +2,7 @@
 
 module Docyard
   class AssetHandler
-    ASSETS_PATH = File.join(__dir__, "templates", "assets")
-    USER_ASSETS_PATH = "docs/assets"
+    TEMPLATES_ASSETS_PATH = File.join(__dir__, "../templates", "assets")
 
     CONTENT_TYPES = {
       ".css" => "text/css; charset=utf-8",
@@ -11,41 +10,47 @@ module Docyard
       ".png" => "image/png",
       ".jpg" => "image/jpeg",
       ".jpeg" => "image/jpeg",
+      ".gif" => "image/gif",
+      ".webp" => "image/webp",
       ".svg" => "image/svg+xml",
-      ".woff" => "font/woff2",
+      ".woff" => "font/woff",
       ".woff2" => "font/woff2",
-      ".ico" => "image/x-icon"
+      ".ttf" => "font/ttf",
+      ".ico" => "image/x-icon",
+      ".pdf" => "application/pdf",
+      ".mp4" => "video/mp4",
+      ".webm" => "video/webm"
     }.freeze
 
-    def serve(request_path)
-      asset_path = extract_asset_path(request_path)
+    def serve_docyard_assets(request_path)
+      asset_path = request_path.delete_prefix("/_docyard/")
 
       return forbidden_response if directory_traversal?(asset_path)
 
       return serve_components_css if asset_path == "css/components.css"
       return serve_components_js if asset_path == "js/components.js"
 
-      file_path = build_file_path(asset_path)
+      file_path = File.join(TEMPLATES_ASSETS_PATH, asset_path)
       return not_found_response unless File.file?(file_path)
 
       serve_file(file_path)
     end
 
-    private
+    def serve_public_file(request_path)
+      asset_path = request_path.delete_prefix("/")
 
-    def extract_asset_path(request_path)
-      request_path.delete_prefix("/assets/")
-    end
+      return nil if directory_traversal?(asset_path)
 
-    def directory_traversal?(path)
-      path.include?("..")
+      file_path = File.join(Constants::PUBLIC_DIR, asset_path)
+      return nil unless File.file?(file_path)
+
+      serve_file(file_path)
     end
 
-    def build_file_path(asset_path)
-      user_path = File.join(USER_ASSETS_PATH, asset_path)
-      return user_path if File.file?(user_path)
+    private
 
-      File.join(ASSETS_PATH, asset_path)
+    def directory_traversal?(path)
+      path.include?("..")
     end
 
     def serve_file(file_path)
@@ -61,7 +66,7 @@ module Docyard
     end
 
     def concatenate_component_css
-      components_dir = File.join(ASSETS_PATH, "css", "components")
+      components_dir = File.join(TEMPLATES_ASSETS_PATH, "css", "components")
       return "" unless Dir.exist?(components_dir)
 
       css_files = Dir.glob(File.join(components_dir, "*.css"))
@@ -74,7 +79,7 @@ module Docyard
     end
 
     def concatenate_component_js
-      components_dir = File.join(ASSETS_PATH, "js", "components")
+      components_dir = File.join(TEMPLATES_ASSETS_PATH, "js", "components")
       return "" unless Dir.exist?(components_dir)
 
       js_files = Dir.glob(File.join(components_dir, "*.js"))

data/lib/docyard/{server.rb → server/dev_server.rb}

@@ -4,30 +4,30 @@ require "webrick"
 require "stringio"
 require_relative "file_watcher"
 require_relative "rack_application"
-require_relative "config"
+require_relative "../config"
 
 module Docyard
   class Server
     DEFAULT_PORT = 4200
     DEFAULT_HOST = "localhost"
 
-    attr_reader :port, :host, :docs_path, :config
+    attr_reader :port, :host, :docs_path, :config, :search_enabled
 
-    def initialize(port: DEFAULT_PORT, host: DEFAULT_HOST, docs_path: "docs")
+    def initialize(port: DEFAULT_PORT, host: DEFAULT_HOST, docs_path: "docs", search: false)
       @port = port
       @host = host
       @docs_path = docs_path
+      @search_enabled = search
       @config = Config.load
       @file_watcher = FileWatcher.new(File.expand_path(docs_path))
-      @app = RackApplication.new(
-        docs_path: File.expand_path(docs_path),
-        file_watcher: @file_watcher,
-        config: @config
-      )
+      @search_indexer = nil
+      @app = nil
     end
 
     def start
       validate_docs_directory!
+      generate_search_index if @search_enabled
+      initialize_app
       print_server_info
       @file_watcher.start
 
@@ -35,11 +35,33 @@ module Docyard
       trap("INT") { shutdown_server }
 
       http_server.start
-      @file_watcher.stop
+      cleanup
     end
 
     private
 
+    def generate_search_index
+      @search_indexer = Search::DevIndexer.new(
+        docs_path: File.expand_path(docs_path),
+        config: @config
+      )
+      @search_indexer.generate
+    end
+
+    def initialize_app
+      @app = RackApplication.new(
+        docs_path: File.expand_path(docs_path),
+        file_watcher: @file_watcher,
+        config: @config,
+        pagefind_path: @search_indexer&.pagefind_path
+      )
+    end
+
+    def cleanup
+      @file_watcher.stop
+      @search_indexer&.cleanup
+    end
+
     def validate_docs_directory!
       return if File.directory?(docs_path)
 
@@ -51,6 +73,7 @@ module Docyard
       puts "Starting Docyard server..."
       puts "=> Serving docs from: #{docs_path}/"
       puts "=> Running at: http://#{host}:#{port}"
+      puts "=> Search: #{@search_enabled ? 'enabled' : 'disabled (use --search to enable)'}"
       puts "=> Press Ctrl+C to stop\n"
     end
 

data/lib/docyard/server/pagefind_handler.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Docyard
+  class PagefindHandler
+    CONTENT_TYPES = {
+      ".js" => "application/javascript; charset=utf-8",
+      ".css" => "text/css; charset=utf-8",
+      ".json" => "application/json; charset=utf-8"
+    }.freeze
+
+    def initialize(pagefind_path:, config:)
+      @pagefind_path = pagefind_path
+      @config = config
+    end
+
+    def serve(path)
+      relative_path = path.delete_prefix(Constants::PAGEFIND_PREFIX)
+      return not_found if relative_path.include?("..")
+
+      file_path = resolve_file(relative_path)
+      return not_found unless file_path && File.file?(file_path)
+
+      serve_file(file_path)
+    end
+
+    private
+
+    attr_reader :pagefind_path, :config
+
+    def resolve_file(relative_path)
+      return File.join(pagefind_path, relative_path) if pagefind_path && Dir.exist?(pagefind_path)
+
+      output_dir = config&.build&.output_dir || "dist"
+      File.join(output_dir, "pagefind", relative_path)
+    end
+
+    def serve_file(file_path)
+      content = File.binread(file_path)
+      content_type = content_type_for(file_path)
+
+      [Constants::STATUS_OK, build_headers(content_type), [content]]
+    end
+
+    def build_headers(content_type)
+      {
+        "Content-Type" => content_type,
+        "Cache-Control" => "no-cache, no-store, must-revalidate",
+        "Pragma" => "no-cache",
+        "Expires" => "0"
+      }
+    end
+
+    def content_type_for(file_path)
+      extension = File.extname(file_path)
+      CONTENT_TYPES.fetch(extension, "application/octet-stream")
+    end
+
+    def not_found
+      message = "Pagefind not found. Run 'docyard build' first."
+      [Constants::STATUS_NOT_FOUND, { "Content-Type" => "text/plain" }, [message]]
+    end
+  end
+end

data/lib/docyard/{preview_server.rb → server/preview_server.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "webrick"
-require_relative "config"
+require_relative "../config"
 
 module Docyard
   class PreviewServer
@@ -12,7 +12,7 @@ module Docyard
     def initialize(port: DEFAULT_PORT)
       @port = port
       @config = Config.load
-      @output_dir = File.expand_path(@config.build.output_dir)
+      @output_dir = File.expand_path(@config.build.output)
     end
 
     def start

data/lib/docyard/server/rack_application.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack"
+require_relative "../navigation/sidebar_builder"
+require_relative "../navigation/prev_next_builder"
+require_relative "../navigation/breadcrumb_builder"
+require_relative "../config/branding_resolver"
+require_relative "../config/constants"
+require_relative "../rendering/template_resolver"
+require_relative "../routing/fallback_resolver"
+require_relative "pagefind_handler"
+
+module Docyard
+  class RackApplication
+    def initialize(docs_path:, file_watcher:, config: nil, pagefind_path: 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 || "/", config: config)
+      @asset_handler = AssetHandler.new
+      @pagefind_handler = PagefindHandler.new(pagefind_path: pagefind_path, config: config)
+    end
+
+    def call(env)
+      handle_request(env)
+    end
+
+    private
+
+    attr_reader :docs_path, :file_watcher, :config, :router, :renderer, :asset_handler, :pagefind_handler
+
+    def handle_request(env)
+      path = env["PATH_INFO"]
+
+      return handle_reload_check(env) if path == Constants::RELOAD_ENDPOINT
+      return asset_handler.serve_docyard_assets(path) if path.start_with?(Constants::DOCYARD_ASSETS_PREFIX)
+      return pagefind_handler.serve(path) if path.start_with?(Constants::PAGEFIND_PREFIX)
+
+      public_response = asset_handler.serve_public_file(path)
+      return public_response if public_response
+
+      handle_documentation_request(path)
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    def handle_documentation_request(path)
+      if root_path?(path)
+        html_response = serve_custom_landing_page
+        return html_response if html_response
+      end
+
+      result = router.resolve(path)
+
+      if result.found?
+        render_documentation_page(result.file_path, path)
+      else
+        try_fallback_redirect(path)
+      end
+    end
+
+    def root_path?(path)
+      path == "/" || path.empty?
+    end
+
+    def serve_custom_landing_page
+      html_path = File.join(docs_path, "index.html")
+      return nil unless File.file?(html_path)
+
+      html = File.read(html_path)
+      [Constants::STATUS_OK, { "Content-Type" => Constants::CONTENT_TYPE_HTML }, [html]]
+    end
+
+    def try_fallback_redirect(path)
+      sidebar_builder = build_sidebar_instance(path)
+      fallback_resolver = Routing::FallbackResolver.new(
+        docs_path: docs_path,
+        sidebar_builder: sidebar_builder
+      )
+
+      fallback_path = fallback_resolver.resolve_fallback(path)
+      if fallback_path
+        redirect_to(fallback_path)
+      else
+        render_not_found_page
+      end
+    end
+
+    def redirect_to(path)
+      [Constants::STATUS_REDIRECT, { "Location" => path }, []]
+    end
+
+    def render_documentation_page(file_path, current_path)
+      markdown = Markdown.new(File.read(file_path))
+      template_resolver = TemplateResolver.new(markdown.frontmatter, @config&.data)
+      branding = branding_options
+
+      navigation = build_navigation_html(template_resolver, current_path, markdown, branding[:header_ctas])
+      html = renderer.render_file(file_path, **navigation, branding: branding,
+                                                           template_options: template_resolver.to_options,
+                                                           current_path: current_path)
+
+      [Constants::STATUS_OK, { "Content-Type" => Constants::CONTENT_TYPE_HTML }, [html]]
+    end
+
+    def build_navigation_html(template_resolver, current_path, markdown, header_ctas)
+      return { sidebar_html: "", prev_next_html: "", breadcrumbs: nil } unless template_resolver.show_sidebar?
+
+      sidebar_builder = build_sidebar_instance(current_path, header_ctas)
+      {
+        sidebar_html: sidebar_builder.to_html,
+        prev_next_html: build_prev_next(sidebar_builder, current_path, markdown),
+        breadcrumbs: build_breadcrumbs(sidebar_builder.tree, current_path)
+      }
+    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, header_ctas = [])
+      SidebarBuilder.new(
+        docs_path: docs_path,
+        current_path: current_path,
+        config: config,
+        header_ctas: header_ctas
+      )
+    end
+
+    def build_prev_next(sidebar_builder, current_path, markdown)
+      PrevNextBuilder.new(
+        sidebar_tree: sidebar_builder.tree,
+        current_path: current_path,
+        frontmatter: markdown.frontmatter,
+        config: navigation_config
+      ).to_html
+    end
+
+    def build_breadcrumbs(sidebar_tree, current_path)
+      return nil unless breadcrumbs_enabled?
+
+      BreadcrumbBuilder.new(sidebar_tree: sidebar_tree, current_path: current_path)
+    end
+
+    def breadcrumbs_enabled?
+      config&.navigation&.breadcrumbs != false
+    end
+
+    def navigation_config
+      {}
+    end
+
+    def branding_options
+      BrandingResolver.new(config).resolve
+    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/server/resolution_result.rb

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

data/lib/docyard/{router.rb → server/router.rb}

@@ -12,18 +12,18 @@ module Docyard
       clean_path = sanitize_path(request_path)
 
       file_path = File.join(docs_path, "#{clean_path}#{Constants::MARKDOWN_EXTENSION}")
-      return Routing::ResolutionResult.found(file_path) if File.file?(file_path)
+      return ResolutionResult.found(file_path) if File.file?(file_path)
 
       index_path = File.join(docs_path, clean_path, "#{Constants::INDEX_FILE}#{Constants::MARKDOWN_EXTENSION}")
-      return Routing::ResolutionResult.found(index_path) if File.file?(index_path)
+      return ResolutionResult.found(index_path) if File.file?(index_path)
 
-      Routing::ResolutionResult.not_found
+      ResolutionResult.not_found
     end
 
     private
 
     def sanitize_path(request_path)
-      clean = request_path.delete_prefix("/")
+      clean = request_path.delete_prefix("/").delete_suffix("/")
       clean = Constants::INDEX_FILE if clean.empty?
       clean.delete_suffix(Constants::MARKDOWN_EXTENSION)
     end