docyard 0.1.0 → 0.3.0

data/lib/docyard/components/tabs_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "icon_detector"
+require "kramdown"
+require "kramdown-parser-gfm"
+
+module Docyard
+  module Components
+    class TabsParser
+      def self.parse(content)
+        new(content).parse
+      end
+
+      def initialize(content)
+        @content = content
+      end
+
+      def parse
+        sections.filter_map { |section| parse_section(section) }
+      end
+
+      private
+
+      attr_reader :content
+
+      def sections
+        content.split(/^==[ \t]+/)
+      end
+
+      def parse_section(section)
+        return nil if section.strip.empty?
+
+        parts = section.split("\n", 2)
+        tab_name = parts[0]&.strip
+        return nil if tab_name.nil? || tab_name.empty?
+
+        tab_content = parts[1]&.strip || ""
+        icon_data = IconDetector.detect(tab_name, tab_content)
+
+        {
+          name: icon_data[:name],
+          content: render_markdown(tab_content),
+          icon: icon_data[:icon],
+          icon_source: icon_data[:icon_source]
+        }
+      end
+
+      def render_markdown(markdown_content)
+        return "" if markdown_content.empty?
+
+        Kramdown::Document.new(
+          markdown_content,
+          input: "GFM",
+          hard_wrap: false,
+          syntax_highlighter: "rouge"
+        ).to_html
+      end
+    end
+  end
+end

data/lib/docyard/components/tabs_processor.rb

@@ -0,0 +1,44 @@
+# 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/config/validator.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Docyard
+  class Config
+    class Validator
+      def initialize(config_data)
+        @config = config_data
+        @errors = []
+      end
+
+      def validate!
+        validate_site_section
+        validate_branding_section
+        validate_build_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")
+      end
+
+      def validate_branding_section
+        branding = @config["branding"]
+        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")
+
+        appearance = branding["appearance"] || {}
+        validate_boolean(appearance["logo"], "branding.appearance.logo")
+        validate_boolean(appearance["title"], "branding.appearance.title")
+      end
+
+      def validate_build_section
+        build = @config["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")
+      end
+
+      def validate_string(value, field_name)
+        return if value.nil?
+        return if 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 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_file_path(value, field_name)
+        return if value.nil?
+        return add_file_path_type_error(value, field_name) unless value.is_a?(String)
+
+        file_path = if File.absolute_path?(value)
+                      value
+                    else
+                      File.join("docs", value)
+                    end
+
+        return if File.exist?(file_path)
+
+        add_file_not_found_error(value, field_name)
+      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"
+        )
+      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')"
+        )
+      end
+
+      def validate_no_slashes(value, field_name)
+        return if value.nil?
+        return unless 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?
+        return if value.start_with?("/")
+
+        add_error(
+          field: field_name,
+          error: "must start with /",
+          got: value,
+          fix: "Change to '/#{value}'"
+        )
+      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 if url?(value)
+
+        file_path = if File.absolute_path?(value)
+                      value
+                    else
+                      File.join("docs", value)
+                    end
+
+        return if File.exist?(file_path)
+
+        add_file_not_found_error(value, field_name)
+      end
+
+      def url?(value)
+        value.match?(%r{\Ahttps?://})
+      end
+
+      def add_error(error_data)
+        @errors << error_data
+      end
+
+      def format_errors
+        message = "Error in docyard.yml:\n\n"
+
+        @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
+
+        message.chomp
+      end
+    end
+  end
+end

data/lib/docyard/config.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "config/validator"
+require_relative "constants"
+
+module Docyard
+  class Config
+    DEFAULT_CONFIG = {
+      "site" => {
+        "title" => Constants::DEFAULT_SITE_TITLE,
+        "description" => ""
+      },
+      "branding" => {
+        "logo" => nil,
+        "logo_dark" => nil,
+        "favicon" => nil,
+        "appearance" => {
+          "logo" => true,
+          "title" => true
+        }
+      },
+      "build" => {
+        "output_dir" => "dist",
+        "base_url" => "/",
+        "clean" => true
+      },
+      "sidebar" => nil
+    }.freeze
+
+    attr_reader :data, :file_path
+
+    def self.load(project_root = Dir.pwd)
+      new(project_root)
+    end
+
+    def initialize(project_root = Dir.pwd)
+      @project_root = project_root
+      @file_path = File.join(project_root, "docyard.yml")
+      @data = load_config_data
+      validate!
+    end
+
+    def file_exists?
+      File.exist?(file_path)
+    end
+
+    def site
+      @site ||= ConfigSection.new(data["site"])
+    end
+
+    def branding
+      @branding ||= ConfigSection.new(data["branding"])
+    end
+
+    def build
+      @build ||= ConfigSection.new(data["build"])
+    end
+
+    def sidebar
+      data["sidebar"]
+    end
+
+    private
+
+    def load_config_data
+      if file_exists?
+        load_and_merge_config
+      else
+        deep_dup(DEFAULT_CONFIG)
+      end
+    end
+
+    def load_and_merge_config
+      yaml_content = YAML.load_file(file_path)
+      deep_merge(deep_dup(DEFAULT_CONFIG), yaml_content || {})
+    rescue Psych::SyntaxError => e
+      raise ConfigError, build_yaml_error_message(e)
+    rescue StandardError => e
+      raise ConfigError, "Error loading docyard.yml: #{e.message}"
+    end
+
+    def deep_merge(hash1, hash2)
+      hash1.merge(hash2) do |_key, v1, v2|
+        if v2.nil?
+          v1
+        elsif v1.is_a?(Hash) && v2.is_a?(Hash)
+          deep_merge(v1, v2)
+        else
+          v2
+        end
+      end
+    end
+
+    def deep_dup(hash)
+      hash.transform_values { |value| value.is_a?(Hash) ? deep_dup(value) : value }
+    end
+
+    def build_yaml_error_message(error)
+      message = "Invalid YAML in docyard.yml:\n\n"
+      message += "  #{error.message}\n\n"
+      message += "Fix: Check YAML syntax"
+      message += " at line #{error.line}" if error.respond_to?(:line)
+      message
+    end
+
+    def validate!
+      Validator.new(data).validate!
+    end
+  end
+
+  class ConfigSection
+    def initialize(data)
+      @data = data || {}
+    end
+
+    def appearance
+      @data["appearance"]
+    end
+
+    def method_missing(method, *args)
+      return @data[method.to_s] if args.empty?
+
+      super
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @data.key?(method.to_s) || super
+    end
+  end
+
+  class ConfigError < StandardError; end
+end

data/lib/docyard/constants.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Constants
+    CONTENT_TYPE_HTML = "text/html; charset=utf-8"
+    CONTENT_TYPE_JSON = "application/json; charset=utf-8"
+    CONTENT_TYPE_CSS = "text/css; charset=utf-8"
+    CONTENT_TYPE_JS = "application/javascript; charset=utf-8"
+
+    RELOAD_ENDPOINT = "/_docyard/reload"
+    ASSETS_PREFIX = "/assets/"
+
+    INDEX_FILE = "index"
+    INDEX_TITLE = "Home"
+
+    MARKDOWN_EXTENSION = ".md"
+    HTML_EXTENSION = ".html"
+
+    STATUS_OK = 200
+    STATUS_NOT_FOUND = 404
+    STATUS_INTERNAL_ERROR = 500
+
+    DEFAULT_SITE_TITLE = "Documentation"
+    DEFAULT_LOGO_PATH = "assets/logo.svg"
+    DEFAULT_LOGO_DARK_PATH = "assets/logo-dark.svg"
+    DEFAULT_FAVICON_PATH = "assets/favicon.svg"
+  end
+end

data/lib/docyard/errors.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Docyard
+  class Error < StandardError; end
+
+  class FileNotFoundError < Error
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+      super("File not found: #{path}")
+    end
+  end
+
+  class InvalidPathError < Error; end
+
+  class MarkdownParseError < Error
+    attr_reader :file_path, :original_error
+
+    def initialize(file_path, original_error)
+      @file_path = file_path
+      @original_error = original_error
+      super("Failed to parse markdown file #{file_path}: #{original_error.message}")
+    end
+  end
+
+  class TemplateRenderError < Error
+    attr_reader :template_path, :original_error
+
+    def initialize(template_path, original_error)
+      @template_path = template_path
+      @original_error = original_error
+      super("Failed to render template #{template_path}: #{original_error.message}")
+    end
+  end
+
+  class ReloadCheckError < Error
+    attr_reader :original_error
+
+    def initialize(original_error)
+      @original_error = original_error
+      super("Reload check failed: #{original_error.message}")
+    end
+  end
+
+  class AssetNotFoundError < Error
+    attr_reader :asset_path
+
+    def initialize(asset_path)
+      @asset_path = asset_path
+      super("Asset not found: #{asset_path}")
+    end
+  end
+end

data/lib/docyard/file_watcher.rb

@@ -23,7 +23,7 @@ module Docyard
     def stop
       @listener&.stop
     rescue StandardError => e
-      puts "[Docyard] Error stopping file watcher: #{e.class} - #{e.message}"
+      Docyard.logger.error "Error stopping file watcher: #{e.class} - #{e.message}"
     end
 
     def changed_since?(timestamp)
@@ -36,7 +36,7 @@ module Docyard
       return if modified.empty? && added.empty? && removed.empty?
 
       @last_modified_time = Time.now
-      puts "[Docyard] Files changed, triggering reload..."
+      Docyard.logger.info "Files changed, triggering reload..."
     end
   end
 end

data/lib/docyard/icons/LICENSE.phosphor

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Phosphor Icons
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.