docyard 0.3.0 → 0.4.0

data/lib/docyard/builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tty-progressbar"
+
+module Docyard
+  class Builder
+    attr_reader :config, :clean, :verbose, :start_time
+
+    def initialize(clean: true, verbose: false)
+      @config = Config.new
+      @clean = clean
+      @verbose = verbose
+      @start_time = Time.now
+    end
+
+    def build
+      prepare_output_directory
+      log "Building static site..."
+
+      pages_built = generate_static_pages
+      bundles_created = bundle_assets
+      assets_copied = copy_static_files
+      generate_seo_files
+
+      display_summary(pages_built, bundles_created, assets_copied)
+      true
+    rescue StandardError => e
+      error "Build failed: #{e.message}"
+      error e.backtrace.first if verbose
+      false
+    end
+
+    private
+
+    def prepare_output_directory
+      output_dir = config.build.output_dir
+
+      if clean && Dir.exist?(output_dir)
+        log "[✓] Cleaning #{output_dir}/ directory"
+        FileUtils.rm_rf(output_dir)
+      end
+
+      FileUtils.mkdir_p(output_dir)
+    end
+
+    def generate_static_pages
+      require_relative "build/static_generator"
+      generator = Build::StaticGenerator.new(config, verbose: verbose)
+      generator.generate
+    end
+
+    def bundle_assets
+      require_relative "build/asset_bundler"
+      bundler = Build::AssetBundler.new(config, verbose: verbose)
+      bundler.bundle
+    end
+
+    def copy_static_files
+      require_relative "build/file_copier"
+      copier = Build::FileCopier.new(config, verbose: verbose)
+      copier.copy
+    end
+
+    def generate_seo_files
+      require_relative "build/sitemap_generator"
+      sitemap_gen = Build::SitemapGenerator.new(config)
+      sitemap_gen.generate
+
+      File.write(File.join(config.build.output_dir, "robots.txt"), robots_txt_content)
+      log "[✓] Generated robots.txt"
+    end
+
+    def robots_txt_content
+      base_url = config.build.base_url
+      base_url = "#{base_url}/" unless base_url.end_with?("/")
+
+      <<~ROBOTS
+        User-agent: *
+        Allow: /
+
+        Sitemap: #{base_url}sitemap.xml
+      ROBOTS
+    end
+
+    def display_summary(pages, bundles, assets)
+      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"
+      puts "=" * 50
+    end
+
+    def log(message)
+      puts message
+    end
+
+    def error(message)
+      warn "[ERROR] #{message}"
+    end
+  end
+end

data/lib/docyard/cli.rb

@@ -19,6 +19,25 @@ module Docyard
       exit(1) unless initializer.run
     end
 
+    desc "build", "Build static site for production"
+    method_option :clean, type: :boolean, default: true, desc: "Clean output directory before building"
+    method_option :verbose, type: :boolean, default: false, aliases: "-v", desc: "Show verbose output"
+    def build
+      require_relative "builder"
+      builder = Docyard::Builder.new(
+        clean: options[:clean],
+        verbose: options[:verbose]
+      )
+      exit(1) unless builder.build
+    end
+
+    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"
+      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"

data/lib/docyard/components/table_wrapper_processor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    class TableWrapperProcessor < BaseProcessor
+      self.priority = 100
+
+      def postprocess(html)
+        wrapped = html.gsub(/<table([^>]*)>/) do
+          attributes = Regexp.last_match(1)
+          "<div class=\"table-wrapper\"><table#{attributes}>"
+        end
+
+        wrapped.gsub("</table>", "</table></div>")
+      end
+    end
+  end
+end

data/lib/docyard/config.rb

@@ -25,7 +25,9 @@ module Docyard
         "base_url" => "/",
         "clean" => true
       },
-      "sidebar" => nil
+      "sidebar" => {
+        "items" => []
+      }
     }.freeze
 
     attr_reader :data, :file_path
@@ -58,7 +60,7 @@ module Docyard
     end
 
     def sidebar
-      data["sidebar"]
+      @sidebar ||= ConfigSection.new(data["sidebar"])
     end
 
     private

data/lib/docyard/icons/phosphor.rb

@@ -27,6 +27,7 @@ module Docyard
         "sun" => '<path d="M120,40V16a8,8,0,0,1,16,0V40a8,8,0,0,1-16,0Zm72,88a64,64,0,1,1-64-64A64.07,64.07,0,0,1,192,128Zm-16,0a48,48,0,1,0-48,48A48.05,48.05,0,0,0,176,128ZM58.34,69.66A8,8,0,0,0,69.66,58.34l-16-16A8,8,0,0,0,42.34,53.66Zm0,116.68-16,16a8,8,0,0,0,11.32,11.32l16-16a8,8,0,0,0-11.32-11.32ZM192,72a8,8,0,0,0,5.66-2.34l16-16a8,8,0,0,0-11.32-11.32l-16,16A8,8,0,0,0,192,72Zm5.66,114.34a8,8,0,0,0-11.32,11.32l16,16a8,8,0,0,0,11.32-11.32ZM48,128a8,8,0,0,0-8-8H16a8,8,0,0,0,0,16H40A8,8,0,0,0,48,128Zm80,80a8,8,0,0,0-8,8v24a8,8,0,0,0,16,0V216A8,8,0,0,0,128,208Zm112-88H216a8,8,0,0,0,0,16h24a8,8,0,0,0,0-16Z"/>',
         "link-external" => '<path d="M224,104a8,8,0,0,1-16,0V59.32l-66.33,66.34a8,8,0,0,1-11.32-11.32L196.68,48H152a8,8,0,0,1,0-16h64a8,8,0,0,1,8,8Zm-40,24a8,8,0,0,0-8,8v72H48V80h72a8,8,0,0,0,0-16H48A16,16,0,0,0,32,80V208a16,16,0,0,0,16,16H176a16,16,0,0,0,16-16V136A8,8,0,0,0,184,128Z"/>',
         "copy" => '<path d="M216,32H88a8,8,0,0,0-8,8V80H40a8,8,0,0,0-8,8V216a8,8,0,0,0,8,8H168a8,8,0,0,0,8-8V176h40a8,8,0,0,0,8-8V40A8,8,0,0,0,216,32ZM160,208H48V96H160Zm48-48H176V88a8,8,0,0,0-8-8H96V48H208Z"/>',
+        "caret-right" => '<path d="M181.66,133.66l-80,80a8,8,0,0,1-11.32-11.32L164.69,128,90.34,53.66a8,8,0,0,1,11.32-11.32l80,80A8,8,0,0,1,181.66,133.66Z"/>',
         "github" => '<path d="M208.31,75.68A59.78,59.78,0,0,0,202.93,28,8,8,0,0,0,196,24a59.75,59.75,0,0,0-48,24H124A59.75,59.75,0,0,0,76,24a8,8,0,0,0-6.93,4,59.78,59.78,0,0,0-5.38,47.68A58.14,58.14,0,0,0,56,104v8a56.06,56.06,0,0,0,48.44,55.47A39.8,39.8,0,0,0,96,192v8H72a24,24,0,0,1-24-24A40,40,0,0,0,8,136a8,8,0,0,0,0,16,24,24,0,0,1,24,24,40,40,0,0,0,40,40H96v16a8,8,0,0,0,16,0V192a24,24,0,0,1,48,0v40a8,8,0,0,0,16,0V192a39.8,39.8,0,0,0-8.44-24.53A56.06,56.06,0,0,0,216,112v-8A58.14,58.14,0,0,0,208.31,75.68ZM200,112a40,40,0,0,1-40,40H112a40,40,0,0,1-40-40v-8a41.74,41.74,0,0,1,6.9-22.48,8,8,0,0,0,1.1-7.69,43.81,43.81,0,0,1,.79-33.58,43.88,43.88,0,0,1,32.32,20.06,8,8,0,0,0,6.71,3.69h32.35a8,8,0,0,0,6.74-3.69,43.87,43.87,0,0,1,32.32-20.06,43.81,43.81,0,0,1,.77,33.58,8.09,8.09,0,0,0,1,7.65,41.76,41.76,0,0,1,7,22.52Z"/>',
         "question" => '<path d="M140,180a12,12,0,1,1-12-12A12,12,0,0,1,140,180ZM128,72c-22.06,0-40,16.15-40,36v4a8,8,0,0,0,16,0v-4c0-11,10.77-20,24-20s24,9,24,20-10.77,20-24,20a8,8,0,0,0-8,8v8a8,8,0,0,0,16,0v-.72c18.24-3.35,32-17.9,32-35.28C168,88.15,150.06,72,128,72Zm104,56A104,104,0,1,1,128,24,104.11,104.11,0,0,1,232,128Zm-16,0a88,88,0,1,0-88,88A88.1,88.1,0,0,0,216,128Z"/>',
         "lightbulb" => '<path d="M176,232a8,8,0,0,1-8,8H88a8,8,0,0,1,0-16h80A8,8,0,0,1,176,232Zm40-128a87.55,87.55,0,0,1-33.64,69.21A16.24,16.24,0,0,0,176,186v6a16,16,0,0,1-16,16H96a16,16,0,0,1-16-16v-6a16,16,0,0,0-6.23-12.66A87.59,87.59,0,0,1,40,104.49C39.74,56.83,78.26,17.14,125.88,16A88,88,0,0,1,216,104Zm-16,0a72,72,0,0,0-73.74-72c-39,.92-70.47,33.39-70.26,72.39a71.65,71.65,0,0,0,27.64,56.3A32,32,0,0,1,96,186v6h64v-6a32.15,32.15,0,0,1,12.47-25.35A71.65,71.65,0,0,0,200,104Zm-16.11-9.34a57.6,57.6,0,0,0-46.56-46.55,8,8,0,0,0-2.66,15.78c16.57,2.79,30.63,16.85,33.44,33.45A8,8,0,0,0,176,104a9,9,0,0,0,1.35-.11A8,8,0,0,0,183.89,94.66Z"/>',

data/lib/docyard/initializer.rb

@@ -10,14 +10,9 @@ module Docyard
 
     TEMPLATES = {
       "index.md" => "index.md.erb",
-      "getting-started/introduction.md" => "getting-started/introduction.md.erb",
       "getting-started/installation.md" => "getting-started/installation.md.erb",
-      "getting-started/quick-start.md" => "getting-started/quick-start.md.erb",
-      "core-concepts/file-structure.md" => "core-concepts/file-structure.md.erb",
-      "core-concepts/markdown.md" => "core-concepts/markdown.md.erb",
-      "components/callouts.md" => "components/callouts.md.erb",
-      "components/icons.md" => "components/icons.md.erb",
-      "components/tabs.md" => "components/tabs.md.erb"
+      "guides/markdown-features.md" => "guides/markdown-features.md.erb",
+      "guides/configuration.md" => "guides/configuration.md.erb"
     }.freeze
 
     def initialize(path = ".")
@@ -79,16 +74,87 @@ module Docyard
     end
 
     def print_success
-      puts "Docyard initialized successfully!"
+      print_banner
+      print_created_files
+      print_next_steps
+    end
+
+    def print_banner
+      puts ""
+      puts "┌─────────────────────────────────────────────────────────────┐"
+      puts "│  ✓ Docyard initialized successfully                        │"
+      puts "└─────────────────────────────────────────────────────────────┘"
+      puts ""
+    end
+
+    def print_created_files
+      puts "Created files:"
       puts ""
-      puts "Created:"
-      TEMPLATES.each_key { |file| puts "  #{DOCS_DIR}/#{file}" }
-      puts "  docyard.yml (configuration - optional)"
+      print_file_tree
       puts ""
+    end
+
+    def print_next_steps
       puts "Next steps:"
-      puts "  1. Edit your markdown files in #{DOCS_DIR}/"
-      puts "  2. Customize docyard.yml (optional)"
-      puts "  3. Run 'docyard serve' to preview your documentation locally"
+      puts ""
+      puts "  Start development server:"
+      puts "    docyard serve"
+      puts "    → http://localhost:4200"
+      puts ""
+      puts "  Build for production:"
+      puts "    docyard build"
+      puts ""
+      puts "  Preview production build:"
+      puts "    docyard preview"
+      puts ""
+    end
+
+    def print_file_tree
+      puts "  ├── docs/"
+
+      grouped_files = TEMPLATES.keys.group_by { |file| File.dirname(file) }
+      sorted_dirs = grouped_files.keys.sort
+
+      sorted_dirs.each_with_index do |dir, dir_idx|
+        print_directory_group(dir, grouped_files[dir], dir_idx == sorted_dirs.length - 1)
+      end
+
+      puts "  └── docyard.yml"
+    end
+
+    def print_directory_group(dir, files, is_last_dir)
+      sorted_files = files.sort
+
+      if dir == "."
+        print_root_files(sorted_files, is_last_dir)
+      else
+        print_subdirectory(dir, sorted_files, is_last_dir)
+      end
+    end
+
+    def print_root_files(files, is_last_dir)
+      files.each_with_index do |file, idx|
+        is_last = idx == files.length - 1 && is_last_dir
+        prefix = is_last ? "  │   └──" : "  │   ├──"
+        puts "#{prefix} #{file}"
+      end
+    end
+
+    def print_subdirectory(dir, files, is_last_dir)
+      dir_prefix = is_last_dir ? "  │   └──" : "  │   ├──"
+      puts "#{dir_prefix} #{dir}/"
+
+      files.each_with_index do |file, idx|
+        print_subdirectory_file(file, idx, files.length, is_last_dir)
+      end
+    end
+
+    def print_subdirectory_file(file, idx, total, is_last_dir)
+      is_last_file = idx == total - 1
+      file_prefix = is_last_dir ? "  │       " : "  │   │   "
+      file_prefix += is_last_file ? "└──" : "├──"
+      basename = File.basename(file)
+      puts "#{file_prefix} #{basename}"
     end
   end
 end

data/lib/docyard/markdown.rb

@@ -9,6 +9,7 @@ require_relative "components/callout_processor"
 require_relative "components/tabs_processor"
 require_relative "components/icon_processor"
 require_relative "components/code_block_processor"
+require_relative "components/table_wrapper_processor"
 
 module Docyard
   class Markdown
@@ -40,6 +41,18 @@ module Docyard
       frontmatter["description"]
     end
 
+    def sidebar_icon
+      frontmatter.dig("sidebar", "icon")
+    end
+
+    def sidebar_text
+      frontmatter.dig("sidebar", "text")
+    end
+
+    def sidebar_collapsed
+      frontmatter.dig("sidebar", "collapsed")
+    end
+
     private
 
     def parse_frontmatter

data/lib/docyard/preview_server.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "webrick"
+require_relative "config"
+
+module Docyard
+  class PreviewServer
+    DEFAULT_PORT = 4000
+
+    attr_reader :port, :output_dir
+
+    def initialize(port: DEFAULT_PORT)
+      @port = port
+      @config = Config.load
+      @output_dir = File.expand_path(@config.build.output_dir)
+    end
+
+    def start
+      validate_output_directory!
+      print_server_info
+
+      server = create_server
+      trap("INT") { shutdown_server(server) }
+
+      server.start
+    end
+
+    private
+
+    def validate_output_directory!
+      return if File.directory?(output_dir)
+
+      abort "Error: #{output_dir}/ directory not found.\n" \
+            "Run `docyard build` first to build the site."
+    end
+
+    def print_server_info
+      puts "Preview server starting..."
+      puts "=> Serving from: #{output_dir}/"
+      puts "=> Running at: http://localhost:#{port}"
+      puts "=> Press Ctrl+C to stop\n"
+    end
+
+    def create_server
+      WEBrick::HTTPServer.new(
+        Port: port,
+        DocumentRoot: output_dir,
+        AccessLog: [],
+        Logger: WEBrick::Log.new(File::NULL),
+        MimeTypes: mime_types
+      )
+    end
+
+    def mime_types
+      WEBrick::HTTPUtils::DefaultMimeTypes.merge(
+        {
+          "css" => "text/css",
+          "js" => "application/javascript",
+          "json" => "application/json",
+          "svg" => "image/svg+xml",
+          "woff" => "font/woff",
+          "woff2" => "font/woff2"
+        }
+      )
+    end
+
+    def shutdown_server(server)
+      puts "\nShutting down preview server..."
+      server.shutdown
+    end
+  end
+end

data/lib/docyard/rack_application.rb

@@ -12,7 +12,7 @@ module Docyard
       @file_watcher = file_watcher
       @config = config
       @router = Router.new(docs_path: docs_path)
-      @renderer = Renderer.new
+      @renderer = Renderer.new(base_url: config&.build&.base_url || "/")
       @asset_handler = AssetHandler.new
     end
 

data/lib/docyard/renderer.rb

@@ -9,10 +9,11 @@ module Docyard
     ERRORS_PATH = File.join(__dir__, "templates", "errors")
     PARTIALS_PATH = File.join(__dir__, "templates", "partials")
 
-    attr_reader :layout_path
+    attr_reader :layout_path, :base_url
 
-    def initialize(layout: "default")
+    def initialize(layout: "default", base_url: "/")
       @layout_path = File.join(LAYOUTS_PATH, "#{layout}.html.erb")
+      @base_url = normalize_base_url(base_url)
     end
 
     def render_file(file_path, sidebar_html: "", branding: {})
@@ -66,11 +67,24 @@ module Docyard
     def asset_path(path)
       return path if path.nil? || path.start_with?("http://", "https://")
 
-      "/#{path}"
+      "#{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)
       @content = content
       @page_title = page_title

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