docyard 0.6.0 → 0.8.0

data/lib/docyard/config/validator.rb

@@ -9,21 +9,22 @@ module Docyard
       end
 
       def validate!
-        validate_site_section
+        validate_top_level
         validate_branding_section
+        validate_socials_section
+        validate_tabs_section
         validate_build_section
-        validate_markdown_section
+        validate_search_section
+        validate_navigation_section
 
         raise ConfigError, format_errors if @errors.any?
       end
 
       private
 
-      def validate_site_section
-        site = @config["site"]
-
-        validate_string(site["title"], "site.title")
-        validate_string(site["description"], "site.description")
+      def validate_top_level
+        validate_string(@config["title"], "title")
+        validate_string(@config["description"], "description")
       end
 
       def validate_branding_section
@@ -31,127 +32,141 @@ module Docyard
         return unless branding
 
         validate_file_path_or_url(branding["logo"], "branding.logo")
-        validate_file_path_or_url(branding["logo_dark"], "branding.logo_dark")
         validate_file_path_or_url(branding["favicon"], "branding.favicon")
+        validate_boolean(branding["credits"], "branding.credits") if branding.key?("credits")
+      end
+
+      def validate_socials_section
+        socials = @config["socials"]
+        return unless socials
+        return add_hash_error("socials") unless socials.is_a?(Hash)
+
+        socials.each { |platform, url| validate_url(url, "socials.#{platform}") unless platform == "custom" }
+        validate_custom_socials(socials["custom"]) if socials.key?("custom")
+      end
+
+      def validate_custom_socials(custom)
+        return if custom.nil?
+        return add_array_error("socials.custom") unless custom.is_a?(Array)
 
-        appearance = branding["appearance"] || {}
-        validate_boolean(appearance["logo"], "branding.appearance.logo")
-        validate_boolean(appearance["title"], "branding.appearance.title")
+        custom.each_with_index do |item, index|
+          validate_string(item["icon"], "socials.custom[#{index}].icon")
+          validate_url(item["href"], "socials.custom[#{index}].href")
+        end
+      end
+
+      def validate_tabs_section
+        tabs = @config["tabs"]
+        return unless tabs
+        return add_array_error("tabs") unless tabs.is_a?(Array)
+
+        tabs.each_with_index do |tab, index|
+          validate_string(tab["text"], "tabs[#{index}].text")
+          validate_string(tab["href"], "tabs[#{index}].href")
+          validate_boolean(tab["external"], "tabs[#{index}].external") if tab.key?("external")
+        end
       end
 
       def validate_build_section
         build = @config["build"]
+        return unless build
 
-        validate_string(build["output_dir"], "build.output_dir")
-        validate_no_slashes(build["output_dir"], "build.output_dir")
-        validate_string(build["base_url"], "build.base_url")
-        validate_starts_with_slash(build["base_url"], "build.base_url")
-        validate_boolean(build["clean"], "build.clean")
+        validate_string(build["output"], "build.output")
+        validate_no_slashes(build["output"], "build.output")
+        validate_string(build["base"], "build.base")
+        validate_starts_with_slash(build["base"], "build.base")
       end
 
-      def validate_markdown_section
-        markdown = @config["markdown"]
-        return unless markdown
+      def validate_search_section
+        search = @config["search"]
+        return unless search
 
-        validate_boolean(markdown["lineNumbers"], "markdown.lineNumbers") if markdown.key?("lineNumbers")
+        validate_boolean(search["enabled"], "search.enabled") if search.key?("enabled")
+        validate_string(search["placeholder"], "search.placeholder") if search.key?("placeholder")
+        validate_array(search["exclude"], "search.exclude") if search.key?("exclude")
       end
 
-      def validate_string(value, field_name)
-        return if value.nil?
-        return if value.is_a?(String)
+      def validate_navigation_section
+        cta = @config.dig("navigation", "cta")
+        return if cta.nil?
+        return add_array_error("navigation.cta") unless cta.is_a?(Array)
 
-        add_error(
-          field: field_name,
-          error: "must be a string",
-          got: value.class.name,
-          fix: "Change to a string value"
-        )
+        validate_cta_max_count(cta)
+        validate_cta_items(cta)
       end
 
-      def validate_boolean(value, field_name)
-        return if [true, false].include?(value)
-
-        add_error(
-          field: field_name,
-          error: "must be true or false",
-          got: value.inspect,
-          fix: "Change to true or false"
-        )
+      def validate_cta_items(cta)
+        cta.each_with_index do |item, idx|
+          validate_string(item["text"], "navigation.cta[#{idx}].text")
+          validate_string(item["href"], "navigation.cta[#{idx}].href")
+          validate_cta_variant(item["variant"], idx) if item.key?("variant")
+          validate_boolean(item["external"], "navigation.cta[#{idx}].external") if item.key?("external")
+        end
       end
 
-      def validate_file_path(value, field_name)
-        return if value.nil?
-        return add_file_path_type_error(value, field_name) unless value.is_a?(String)
+      def validate_cta_max_count(cta)
+        return if cta.length <= 2
 
-        file_path = if File.absolute_path?(value)
-                      value
-                    else
-                      File.join("docs", value)
-                    end
+        add_error(field: "navigation.cta", error: "maximum 2 CTAs allowed",
+                  got: "#{cta.length} items", fix: "Remove extra CTA items to have at most 2")
+      end
 
-        return if File.exist?(file_path)
+      def validate_cta_variant(variant, idx)
+        return if variant.nil? || %w[primary secondary].include?(variant)
 
-        add_file_not_found_error(value, field_name)
+        add_error(field: "navigation.cta[#{idx}].variant", error: "must be 'primary' or 'secondary'",
+                  got: variant, fix: "Change to 'primary' or 'secondary'")
       end
 
-      def add_file_path_type_error(value, field_name)
-        add_error(
-          field: field_name,
-          error: "must be a file path (string)",
-          got: value.class.name,
-          fix: "Change to a string file path"
-        )
+      def validate_string(value, field_name)
+        return if value.nil? || value.is_a?(String)
+
+        add_error(field: field_name, error: "must be a string", got: value.class.name, fix: "Change to a string value")
       end
 
-      def add_file_not_found_error(value, field_name)
-        add_error(
-          field: field_name,
-          error: "file not found",
-          got: value,
-          fix: "Place the file in docs/ directory and use a relative path (e.g., 'assets/logo.svg')"
-        )
+      def validate_boolean(value, field_name)
+        return if [true, false].include?(value)
+
+        add_error(field: field_name, error: "must be true or false", got: value.inspect, fix: "Change to true or false")
       end
 
-      def validate_no_slashes(value, field_name)
-        return if value.nil?
-        return unless value.is_a?(String)
-        return unless value.include?("/") || value.include?("\\")
+      def validate_url(value, field_name)
+        return if value.nil? || value.is_a?(String)
 
-        add_error(
-          field: field_name,
-          error: "cannot contain slashes",
-          got: value,
-          fix: "Use a simple directory name like 'dist' or '_site'"
-        )
+        add_error(field: field_name, error: "must be a URL string",
+                  got: value.class.name, fix: "Change to a URL string")
       end
 
-      def validate_starts_with_slash(value, field_name)
-        return if value.nil?
-        return if value.start_with?("/")
+      def validate_array(value, field_name)
+        return if value.nil? || value.is_a?(Array)
 
-        add_error(
-          field: field_name,
-          error: "must start with /",
-          got: value,
-          fix: "Change to '/#{value}'"
-        )
+        add_array_error(field_name)
       end
 
       def validate_file_path_or_url(value, field_name)
         return if value.nil?
-        return add_file_path_type_error(value, field_name) unless value.is_a?(String)
-
+        return add_type_error(field_name, "file path or URL (string)", value.class.name) unless value.is_a?(String)
         return if url?(value)
 
-        file_path = if File.absolute_path?(value)
-                      value
-                    else
-                      File.join("docs", value)
-                    end
-
+        file_path = File.absolute_path?(value) ? value : File.join("docs/public", value)
         return if File.exist?(file_path)
 
-        add_file_not_found_error(value, field_name)
+        add_error(field: field_name, error: "file not found", got: value,
+                  fix: "Place the file in docs/public/ directory (e.g., 'logo.svg' for docs/public/logo.svg)")
+      end
+
+      def validate_no_slashes(value, field_name)
+        return if value.nil? || !value.is_a?(String)
+        return unless value.include?("/") || value.include?("\\")
+
+        add_error(field: field_name, error: "cannot contain slashes", got: value,
+                  fix: "Use a simple directory name like 'dist' or '_site'")
+      end
+
+      def validate_starts_with_slash(value, field_name)
+        return if value.nil? || value.start_with?("/")
+
+        add_error(field: field_name, error: "must start with /", got: value, fix: "Change to '/#{value}'")
       end
 
       def url?(value)
@@ -162,17 +177,25 @@ module Docyard
         @errors << error_data
       end
 
-      def format_errors
-        message = "Error in docyard.yml:\n\n"
+      def add_type_error(field, expected, got)
+        add_error(field: field, error: "must be a #{expected}", got: got, fix: "Change to a #{expected}")
+      end
 
-        @errors.each do |err|
-          message += "   Field: #{err[:field]}\n"
-          message += "   Error: #{err[:error]}\n"
-          message += "   Got: #{err[:got]}\n"
-          message += "   Fix: #{err[:fix]}\n\n"
-        end
+      def add_hash_error(field)
+        add_error(field: field, error: "must be a hash", got: @config[field].class.name,
+                  fix: "Change to a hash with platform names as keys and URLs as values")
+      end
 
-        message.chomp
+      def add_array_error(field)
+        value = field.split(".").reduce(@config) { |h, k| h&.[](k) }
+        add_error(field: field, error: "must be an array", got: value.class.name, fix: "Change to an array")
+      end
+
+      def format_errors
+        errors_text = @errors.map do |err|
+          "   Field: #{err[:field]}\n   Error: #{err[:error]}\n   Got: #{err[:got]}\n   Fix: #{err[:fix]}"
+        end.join("\n\n")
+        "Error in docyard.yml:\n\n#{errors_text}"
       end
     end
   end

data/lib/docyard/config.rb

@@ -2,41 +2,33 @@
 
 require "yaml"
 require_relative "config/validator"
-require_relative "constants"
+require_relative "config/constants"
 
 module Docyard
   class Config
     DEFAULT_CONFIG = {
-      "site" => {
-        "title" => Constants::DEFAULT_SITE_TITLE,
-        "description" => ""
-      },
+      "title" => Constants::DEFAULT_SITE_TITLE,
+      "description" => "",
       "branding" => {
         "logo" => nil,
-        "logo_dark" => nil,
         "favicon" => nil,
-        "appearance" => {
-          "logo" => true,
-          "title" => true
-        }
+        "credits" => true,
+        "copyright" => nil
       },
+      "socials" => {},
+      "tabs" => [],
       "build" => {
-        "output_dir" => "dist",
-        "base_url" => "/",
-        "clean" => true
+        "output" => "dist",
+        "base" => "/"
       },
-      "sidebar" => {
-        "items" => []
+      "search" => {
+        "enabled" => true,
+        "placeholder" => "Search...",
+        "exclude" => []
       },
       "navigation" => {
-        "footer" => {
-          "enabled" => true,
-          "prev_text" => "Previous",
-          "next_text" => "Next"
-        }
-      },
-      "markdown" => {
-        "lineNumbers" => false
+        "cta" => [],
+        "breadcrumbs" => true
       }
     }.freeze
 
@@ -57,30 +49,38 @@ module Docyard
       File.exist?(file_path)
     end
 
-    def site
-      @site ||= ConfigSection.new(data["site"])
+    def title
+      data["title"]
+    end
+
+    def description
+      data["description"]
     end
 
     def branding
       @branding ||= ConfigSection.new(data["branding"])
     end
 
+    def socials
+      data["socials"]
+    end
+
+    def tabs
+      data["tabs"]
+    end
+
     def build
       @build ||= ConfigSection.new(data["build"])
     end
 
-    def sidebar
-      @sidebar ||= ConfigSection.new(data["sidebar"])
+    def search
+      @search ||= ConfigSection.new(data["search"])
     end
 
     def navigation
       @navigation ||= ConfigSection.new(data["navigation"])
     end
 
-    def markdown
-      @markdown ||= ConfigSection.new(data["markdown"])
-    end
-
     private
 
     def load_config_data
@@ -113,7 +113,13 @@ module Docyard
     end
 
     def deep_dup(hash)
-      hash.transform_values { |value| value.is_a?(Hash) ? deep_dup(value) : value }
+      hash.transform_values do |value|
+        case value
+        when Hash then deep_dup(value)
+        when Array then value.map { |v| v.is_a?(Hash) ? deep_dup(v) : v }
+        else value
+        end
+      end
     end
 
     def build_yaml_error_message(error)
@@ -134,10 +140,6 @@ module Docyard
       @data = data || {}
     end
 
-    def appearance
-      @data["appearance"]
-    end
-
     def method_missing(method, *args)
       return @data[method.to_s] if args.empty?
 

data/lib/docyard/initializer.rb

@@ -5,16 +5,8 @@ require "fileutils"
 module Docyard
   class Initializer
     DOCS_DIR = "docs"
-    TEMPLATE_DIR = File.join(__dir__, "templates", "markdown")
     CONFIG_TEMPLATE_DIR = File.join(__dir__, "templates", "config")
 
-    TEMPLATES = {
-      "index.md" => "index.md.erb",
-      "getting-started/installation.md" => "getting-started/installation.md.erb",
-      "guides/markdown-features.md" => "guides/markdown-features.md.erb",
-      "guides/configuration.md" => "guides/configuration.md.erb"
-    }.freeze
-
     def initialize(path = ".")
       @path = path
       @docs_path = File.join(@path, DOCS_DIR)
@@ -39,23 +31,22 @@ module Docyard
 
     def create_structure
       FileUtils.mkdir_p(@docs_path)
-
-      TEMPLATES.each do |output_name, template_name|
-        copy_template(template_name, output_name)
-      end
-
+      create_index_file
       create_example_config
     end
 
-    def copy_template(template_name, output_name)
-      template_path = File.join(TEMPLATE_DIR, template_name)
-      output_path = File.join(@docs_path, output_name)
+    def create_index_file
+      index_path = File.join(@docs_path, "index.md")
+      content = <<~MARKDOWN
+        ---
+        title: Welcome
+        ---
 
-      output_dir = File.dirname(output_path)
-      FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
+        # Welcome to Your Documentation
 
-      content = File.read(template_path)
-      File.write(output_path, content)
+        Start writing your documentation here.
+      MARKDOWN
+      File.write(index_path, content)
     end
 
     def create_example_config
@@ -81,16 +72,16 @@ module Docyard
 
     def print_banner
       puts ""
-      puts "┌─────────────────────────────────────────────────────────────┐"
-      puts "│  ✓ Docyard initialized successfully                        │"
-      puts "└─────────────────────────────────────────────────────────────┘"
+      puts "Docyard initialized successfully"
       puts ""
     end
 
     def print_created_files
       puts "Created files:"
       puts ""
-      print_file_tree
+      puts "  docs/"
+      puts "    index.md"
+      puts "  docyard.yml"
       puts ""
     end
 
@@ -99,62 +90,10 @@ module Docyard
       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/navigation/breadcrumb_builder.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Docyard
+  class BreadcrumbBuilder
+    MAX_VISIBLE_ITEMS = 3
+
+    Item = Struct.new(:title, :href, :current, keyword_init: true)
+
+    attr_reader :sidebar_tree, :current_path
+
+    def initialize(sidebar_tree:, current_path:)
+      @sidebar_tree = sidebar_tree || []
+      @current_path = normalize_path(current_path)
+    end
+
+    def items
+      @items ||= build_items
+    end
+
+    def truncated?
+      full_path_items.length > MAX_VISIBLE_ITEMS
+    end
+
+    def should_show?
+      items.any? && !root_page?
+    end
+
+    private
+
+    def build_items
+      return [] if full_path_items.empty?
+
+      if truncated?
+        truncated_items
+      else
+        full_path_items
+      end
+    end
+
+    def truncated_items
+      path = full_path_items
+      [
+        Item.new(title: "...", href: nil, current: false),
+        path[-2],
+        path[-1]
+      ].compact
+    end
+
+    def full_path_items
+      @full_path_items ||= find_breadcrumb_path(sidebar_tree, [])
+    end
+
+    def find_breadcrumb_path(nodes, path)
+      nodes.each do |node|
+        result = process_node(node, path)
+        return result if result
+      end
+
+      []
+    end
+
+    def process_node(node, path)
+      node_path = normalize_path(node[:path])
+      node_title = truncate_title(node[:title] || "")
+
+      return build_current_item(path, node_title, node_path) if exact_match?(node_path)
+
+      search_in_ancestors(node, path, node_title, node_path) ||
+        search_in_children(node, path)
+    end
+
+    def build_current_item(path, title, href)
+      path + [Item.new(title: title, href: href, current: true)]
+    end
+
+    def search_in_ancestors(node, path, title, href)
+      return unless node[:children]&.any?
+
+      effective_href = href == "/" ? derive_section_path(node) : href
+      return unless path_is_ancestor?(effective_href)
+
+      result = find_breadcrumb_path(
+        node[:children],
+        path + [Item.new(title: title, href: effective_href, current: false)]
+      )
+      result.any? ? result : nil
+    end
+
+    def derive_section_path(node)
+      first_child = node[:children]&.first
+      return nil unless first_child
+
+      child_path = first_child[:path]
+      return nil if child_path.nil? || child_path.empty?
+
+      File.dirname(child_path)
+    end
+
+    def search_in_children(node, path)
+      return unless node[:children]&.any?
+
+      result = find_breadcrumb_path(node[:children], path)
+      result.any? ? result : nil
+    end
+
+    def exact_match?(node_path)
+      normalize_path(node_path) == current_path
+    end
+
+    def path_is_ancestor?(node_path)
+      return false if node_path.nil? || node_path.empty? || node_path == "/"
+
+      normalized = normalize_path(node_path)
+      current_path.start_with?("#{normalized}/") || current_path == normalized
+    end
+
+    def normalize_path(path)
+      return "/" if path.nil? || path.empty?
+
+      path.chomp("/")
+    end
+
+    def truncate_title(title)
+      return title if title.length <= 30
+
+      "#{title[0, 27]}..."
+    end
+
+    def root_page?
+      current_path == "/" || current_path.empty?
+    end
+  end
+end