docyard 0.2.0 → 0.4.0

data/lib/docyard/server.rb

@@ -4,22 +4,25 @@ require "webrick"
 require "stringio"
 require_relative "file_watcher"
 require_relative "rack_application"
+require_relative "config"
 
 module Docyard
   class Server
     DEFAULT_PORT = 4200
     DEFAULT_HOST = "localhost"
 
-    attr_reader :port, :host, :docs_path
+    attr_reader :port, :host, :docs_path, :config
 
     def initialize(port: DEFAULT_PORT, host: DEFAULT_HOST, docs_path: "docs")
       @port = port
       @host = host
       @docs_path = docs_path
+      @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
+        file_watcher: @file_watcher,
+        config: @config
       )
     end
 

data/lib/docyard/sidebar/config_parser.rb

@@ -0,0 +1,180 @@
+# 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

@@ -0,0 +1,58 @@
+# 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

data/lib/docyard/sidebar/renderer.rb

@@ -7,10 +7,11 @@ module Docyard
     class Renderer
       PARTIALS_PATH = File.join(__dir__, "../templates/partials")
 
-      attr_reader :site_title
+      attr_reader :site_title, :base_url
 
-      def initialize(site_title: "Documentation")
+      def initialize(site_title: "Documentation", base_url: "/")
         @site_title = site_title
+        @base_url = normalize_base_url(base_url)
       end
 
       def render(tree)
@@ -34,8 +35,21 @@ module Docyard
         ERB.new(template).result(erb_binding)
       end
 
-      def icon(name)
-        render_partial(:icons, icon_name: name)
+      def icon(name, weight = "regular")
+        Icons.render(name.to_s.tr("_", "-"), weight) || ""
+      end
+
+      def link_path(path)
+        return path if path.nil? || path.start_with?("http://", "https://")
+
+        "#{base_url.chomp('/')}#{path}"
+      end
+
+      def normalize_base_url(url)
+        return "/" if url.nil? || url.empty?
+
+        url = "/#{url}" unless url.start_with?("/")
+        url.end_with?("/") ? url : "#{url}/"
       end
 
       def render_tree_with_sections(items)
@@ -98,12 +112,25 @@ module Docyard
       end
 
       def render_leaf_item(item)
-        render_partial(:nav_leaf, path: item[:path], title: item[:title], active: item[:active])
+        render_partial(
+          :nav_leaf,
+          path: item[:path],
+          title: item[:title],
+          active: item[:active],
+          icon: item[:icon],
+          target: item[:target]
+        )
       end
 
       def render_group_item(item)
         children_html = render_tree(item[:children])
-        render_partial(:nav_group, title: item[:title], children_html: children_html)
+        render_partial(
+          :nav_group,
+          title: item[:title],
+          children_html: children_html,
+          icon: item[:icon],
+          collapsed: item[:collapsed]
+        )
       end
     end
   end

data/lib/docyard/sidebar_builder.rb

@@ -4,12 +4,13 @@ require_relative "sidebar/file_system_scanner"
 require_relative "sidebar/title_extractor"
 require_relative "sidebar/tree_builder"
 require_relative "sidebar/renderer"
+require_relative "sidebar/config_parser"
 
 module Docyard
   class SidebarBuilder
     attr_reader :docs_path, :current_path, :config
 
-    def initialize(docs_path:, current_path: "/", config: {})
+    def initialize(docs_path:, current_path: "/", config: nil)
       @docs_path = docs_path
       @current_path = current_path
       @config = config
@@ -26,10 +27,44 @@ module Docyard
     private
 
     def build_tree
+      if config_sidebar_items?
+        build_tree_from_config
+      else
+        build_tree_from_filesystem
+      end
+    end
+
+    def build_tree_from_config
+      config_parser.parse.map(&:to_h)
+    end
+
+    def build_tree_from_filesystem
       file_items = scanner.scan
       tree_builder.build(file_items)
     end
 
+    def config_sidebar_items?
+      config_sidebar_items&.any?
+    end
+
+    def config_sidebar_items
+      return [] unless config
+
+      if config.is_a?(Hash)
+        config.dig("sidebar", "items") || config.dig(:sidebar, :items) || []
+      else
+        config.sidebar&.items || []
+      end
+    end
+
+    def config_parser
+      @config_parser ||= Sidebar::ConfigParser.new(
+        config_sidebar_items,
+        docs_path: docs_path,
+        current_path: current_path
+      )
+    end
+
     def scanner
       @scanner ||= Sidebar::FileSystemScanner.new(docs_path)
     end
@@ -43,8 +78,25 @@ module Docyard
 
     def renderer
       @renderer ||= Sidebar::Renderer.new(
-        site_title: config[:site_title] || "Documentation"
+        site_title: extract_site_title,
+        base_url: extract_base_url
       )
     end
+
+    def extract_base_url
+      if config.is_a?(Hash)
+        config.dig(:build, :base_url) || "/"
+      else
+        config&.build&.base_url || "/"
+      end
+    end
+
+    def extract_site_title
+      if config.is_a?(Hash)
+        config[:site_title] || "Documentation"
+      else
+        config&.site&.title || "Documentation"
+      end
+    end
   end
 end

data/lib/docyard/templates/assets/css/code.css

@@ -35,7 +35,7 @@
 }
 
 .highlight table td {
-  padding: 5px;
+  padding: 0.3125rem;
 }
 
 .highlight table pre {
@@ -196,7 +196,7 @@
 
 /* Code block scrollbar */
 .content pre::-webkit-scrollbar {
-  height: 8px;
+  height: 0.5rem;
 }
 
 .content pre::-webkit-scrollbar-track {
@@ -212,3 +212,151 @@
 .content pre::-webkit-scrollbar-thumb:hover {
   background: var(--color-text-tertiary);
 }
+
+/* Dark Mode Syntax Highlighting - GitHub Dark */
+.dark .highlight,
+.dark .highlight .w {
+  color: #e6edf3;
+  background-color: #161b22;
+}
+
+/* Keywords */
+.dark .highlight .k,
+.dark .highlight .kd,
+.dark .highlight .kn,
+.dark .highlight .kp,
+.dark .highlight .kr,
+.dark .highlight .kt,
+.dark .highlight .kv {
+  color: #ff7b72;
+}
+
+.dark .highlight .gr {
+  color: #161b22;
+}
+
+.dark .highlight .gd {
+  color: #ffa198;
+  background-color: #490202;
+}
+
+/* Built-in names */
+.dark .highlight .nb,
+.dark .highlight .nc,
+.dark .highlight .no,
+.dark .highlight .nn {
+  color: #ffa657;
+}
+
+/* Strings and regex */
+.dark .highlight .sr,
+.dark .highlight .na,
+.dark .highlight .nt {
+  color: #7ee787;
+}
+
+.dark .highlight .gi {
+  color: #7ee787;
+  background-color: #0f3b17;
+}
+
+/* Constants and literals */
+.dark .highlight .kc,
+.dark .highlight .l,
+.dark .highlight .ld,
+.dark .highlight .m,
+.dark .highlight .mb,
+.dark .highlight .mf,
+.dark .highlight .mh,
+.dark .highlight .mi,
+.dark .highlight .il,
+.dark .highlight .mo,
+.dark .highlight .mx,
+.dark .highlight .sb,
+.dark .highlight .bp,
+.dark .highlight .ne,
+.dark .highlight .nl,
+.dark .highlight .py {
+  color: #79c0ff;
+}
+
+/* Variables */
+.dark .highlight .nv,
+.dark .highlight .vc,
+.dark .highlight .vg,
+.dark .highlight .vi,
+.dark .highlight .vm {
+  color: #79c0ff;
+}
+
+/* Operators */
+.dark .highlight .o,
+.dark .highlight .ow {
+  color: #79c0ff;
+}
+
+/* Headers and subheaders in diffs */
+.dark .highlight .gh,
+.dark .highlight .gu {
+  color: #79c0ff;
+  font-weight: bold;
+}
+
+/* Strings */
+.dark .highlight .s,
+.dark .highlight .sa,
+.dark .highlight .sc,
+.dark .highlight .dl,
+.dark .highlight .sd,
+.dark .highlight .s2,
+.dark .highlight .se,
+.dark .highlight .sh,
+.dark .highlight .sx,
+.dark .highlight .s1,
+.dark .highlight .ss {
+  color: #a5d6ff;
+}
+
+/* Decorators and functions */
+.dark .highlight .nd,
+.dark .highlight .nf,
+.dark .highlight .fm {
+  color: #d2a8ff;
+}
+
+/* Errors */
+.dark .highlight .err {
+  color: #161b22;
+  background-color: #ffa198;
+}
+
+/* Comments */
+.dark .highlight .c,
+.dark .highlight .ch,
+.dark .highlight .cd,
+.dark .highlight .cm,
+.dark .highlight .cp,
+.dark .highlight .cpf,
+.dark .highlight .c1,
+.dark .highlight .cs,
+.dark .highlight .gl,
+.dark .highlight .gt {
+  color: #8b949e;
+}
+
+/* Name indicators */
+.dark .highlight .ni,
+.dark .highlight .si {
+  color: #e6edf3;
+}
+
+/* Generic emphasis */
+.dark .highlight .ge {
+  color: #e6edf3;
+  font-style: italic;
+}
+
+.dark .highlight .gs {
+  color: #e6edf3;
+  font-weight: bold;
+}