docyard 0.9.0 → 1.0.0

data/lib/docyard/navigation/sidebar/file_resolver.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "item"
-
-module Docyard
-  module Sidebar
-    class FileResolver
-      attr_reader :docs_path, :current_path, :metadata_extractor
-
-      def initialize(docs_path:, current_path:, metadata_extractor:)
-        @docs_path = docs_path
-        @current_path = current_path
-        @metadata_extractor = metadata_extractor
-      end
-
-      def resolve(slug, base_path, options = {})
-        context = build_context(slug.to_s, base_path, options || {})
-        Item.new(**context)
-      end
-
-      def build_link_item(config)
-        Item.new(
-          text: config["text"] || config[:text],
-          link: config["link"] || config[:link],
-          path: config["link"] || config[:link],
-          icon: config["icon"] || config[:icon],
-          target: config["target"] || config[:target] || "_blank",
-          type: :external,
-          section: false
-        )
-      end
-
-      def build_file_with_children(slug:, options:, base_path:, parsed_items:, depth: 1)
-        common_opts = metadata_extractor.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))
-        is_section = section_for_depth?(common_opts[:section], depth)
-
-        Item.new(
-          slug: slug,
-          text: common_opts[:text] || metadata_extractor.extract_file_title(file_path, slug),
-          path: is_section ? nil : url_path,
-          icon: common_opts[:icon],
-          collapsed: is_section ? false : common_opts[:collapsed],
-          items: parsed_items,
-          active: is_section ? false : current_path == url_path,
-          type: is_section ? :section : :file,
-          section: is_section
-        )
-      end
-
-      private
-
-      def section_for_depth?(explicit_section, depth)
-        return explicit_section unless explicit_section.nil?
-
-        depth == 1
-      end
-
-      def build_context(slug, base_path, options)
-        paths = resolve_paths(slug, base_path, options)
-        frontmatter = metadata_extractor.extract_frontmatter_metadata(paths[:file])
-
-        build_context_hash(slug, paths, options, frontmatter)
-      end
-
-      def resolve_paths(slug, base_path, options)
-        file_path = File.join(docs_path, base_path, "#{slug}.md")
-        url_path = Utils::PathResolver.to_url(File.join(base_path, slug))
-        final_path = options["link"] || options[:link] || url_path
-
-        { file: file_path, final: final_path }
-      end
-
-      def build_context_hash(slug, paths, options, frontmatter)
-        {
-          slug: slug,
-          text: metadata_extractor.resolve_item_text(slug, paths[:file], options, frontmatter[:text]),
-          path: paths[:final],
-          icon: metadata_extractor.resolve_item_icon(options, frontmatter[:icon]),
-          badge: frontmatter[:badge],
-          badge_type: frontmatter[:badge_type],
-          active: current_path == paths[:final],
-          type: :file,
-          section: false
-        }
-      end
-    end
-  end
-end

data/lib/docyard/navigation/sidebar/file_system_scanner.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    class FileSystemScanner
-      attr_reader :docs_path
-
-      def initialize(docs_path)
-        @docs_path = docs_path
-      end
-
-      def scan
-        return [] unless File.directory?(docs_path)
-
-        scan_directory(docs_path, "")
-      end
-
-      private
-
-      def scan_directory(base_path, relative_path)
-        full_path = File.join(base_path, relative_path)
-        return [] unless File.directory?(full_path)
-
-        entries = sorted_entries(full_path, relative_path)
-        entries.map { |entry| build_item(entry, base_path, relative_path, full_path) }.compact
-      end
-
-      def sorted_entries(full_path, relative_path)
-        Dir.children(full_path)
-          .reject { |entry| hidden_or_ignored?(entry, relative_path) }
-          .sort_by { |entry| sort_key(entry) }
-      end
-
-      def build_item(entry, base_path, relative_path, full_path)
-        entry_full_path = File.join(full_path, entry)
-        entry_relative_path = build_relative_path(relative_path, entry)
-
-        if File.directory?(entry_full_path)
-          build_directory_item(entry, entry_relative_path, base_path)
-        elsif entry.end_with?(".md")
-          build_file_item(entry, entry_relative_path)
-        end
-      end
-
-      def build_relative_path(relative_path, entry)
-        relative_path.empty? ? entry : File.join(relative_path, entry)
-      end
-
-      def build_directory_item(entry, entry_relative_path, base_path)
-        {
-          type: :directory,
-          name: entry,
-          path: entry_relative_path,
-          children: scan_directory(base_path, entry_relative_path)
-        }
-      end
-
-      def build_file_item(entry, entry_relative_path)
-        {
-          type: :file,
-          name: entry.delete_suffix(".md"),
-          path: entry_relative_path
-        }
-      end
-
-      def hidden_or_ignored?(entry, relative_path)
-        entry.start_with?(".") ||
-          entry.start_with?("_") ||
-          (entry == "index.md" && relative_path.empty?) ||
-          (entry == "public" && relative_path.empty?)
-      end
-
-      def sort_key(entry)
-        entry.downcase
-      end
-    end
-  end
-end

data/lib/docyard/navigation/sidebar/metadata_extractor.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    class MetadataExtractor
-      attr_reader :docs_path, :title_extractor
-
-      def initialize(docs_path:, title_extractor:)
-        @docs_path = docs_path
-        @title_extractor = title_extractor
-      end
-
-      def extract_index_metadata(file_path)
-        return { sidebar_text: nil, icon: nil } unless File.file?(file_path)
-
-        markdown = Markdown.new(File.read(file_path))
-        {
-          sidebar_text: markdown.sidebar_text,
-          icon: markdown.sidebar_icon
-        }
-      rescue StandardError
-        { sidebar_text: nil, icon: nil }
-      end
-
-      def extract_frontmatter_metadata(file_path)
-        return { text: nil, icon: nil, badge: nil, badge_type: nil } unless File.exist?(file_path)
-
-        markdown = Markdown.new(File.read(file_path))
-        {
-          text: markdown.sidebar_text || markdown.title,
-          icon: markdown.sidebar_icon,
-          badge: markdown.sidebar_badge,
-          badge_type: markdown.sidebar_badge_type
-        }
-      end
-
-      def extract_file_title(file_path, slug)
-        File.exist?(file_path) ? title_extractor.extract(file_path) : Utils::TextFormatter.titleize(slug)
-      end
-
-      def extract_common_options(options)
-        collapsed_value = options["collapsed"]
-        collapsed_value = options[:collapsed] if collapsed_value.nil?
-        collapsible_value = options["collapsible"]
-        collapsible_value = options[:collapsible] if collapsible_value.nil?
-        collapsible_value = true if !collapsed_value.nil? && collapsible_value.nil?
-        {
-          text: options["text"] || options[:text],
-          icon: options["icon"] || options[:icon],
-          collapsed: collapsed_value,
-          section: section_from_collapsible(collapsible_value)
-        }
-      end
-
-      def section_from_collapsible(collapsible_value)
-        return nil if collapsible_value.nil?
-
-        collapsible_value != true
-      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/navigation/sidebar/metadata_reader.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    class MetadataReader
-      def extract_file_metadata(file_path)
-        return empty_file_metadata unless File.file?(file_path)
-
-        content = File.read(file_path)
-        markdown = Markdown.new(content)
-        {
-          title: markdown.sidebar_text || markdown.title,
-          icon: markdown.sidebar_icon,
-          collapsed: markdown.sidebar_collapsed,
-          order: markdown.sidebar_order,
-          badge: markdown.sidebar_badge,
-          badge_type: markdown.sidebar_badge_type
-        }
-      rescue StandardError
-        empty_file_metadata
-      end
-
-      def extract_index_metadata(file_path)
-        return empty_index_metadata unless File.file?(file_path)
-
-        content = File.read(file_path)
-        markdown = Markdown.new(content)
-        {
-          sidebar_text: markdown.sidebar_text,
-          icon: markdown.sidebar_icon,
-          collapsed: markdown.sidebar_collapsed,
-          order: markdown.sidebar_order,
-          badge: markdown.sidebar_badge,
-          badge_type: markdown.sidebar_badge_type
-        }
-      rescue StandardError
-        empty_index_metadata
-      end
-
-      private
-
-      def empty_file_metadata
-        { title: nil, icon: nil, collapsed: nil, order: nil, badge: nil, badge_type: nil }
-      end
-
-      def empty_index_metadata
-        { sidebar_text: nil, icon: nil, collapsed: nil, order: nil, badge: nil, badge_type: nil }
-      end
-    end
-  end
-end

data/lib/docyard/navigation/sidebar/path_prefixer.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    class PathPrefixer
-      def initialize(tree, prefix)
-        @tree = tree
-        @prefix = prefix
-      end
-
-      def prefix
-        return @tree if @prefix.empty?
-
-        @tree.map { |item| prefix_item(item) }
-      end
-
-      private
-
-      def prefix_item(item)
-        prefixed = item.dup
-        prefixed[:path] = prefixed_path(prefixed[:path])
-        prefixed[:children] = self.class.new(prefixed[:children], @prefix).prefix if prefixed[:children]&.any?
-        prefixed
-      end
-
-      def prefixed_path(path)
-        return path if path.nil? || path.start_with?("http")
-
-        path_without_slash = path.sub(%r{^/}, "")
-        path_without_slash.empty? ? @prefix : "#{@prefix}/#{path_without_slash}"
-      end
-    end
-  end
-end

data/lib/docyard/navigation/sidebar/sorter.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    module Sorter
-      module_function
-
-      def sort_by_order(items)
-        items.sort_by do |item|
-          order = item[:order]
-          title = item[:title]&.downcase || ""
-          if order.nil?
-            [1, title]
-          else
-            [0, order, title]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/docyard/navigation/sidebar/title_extractor.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Sidebar
-    class TitleExtractor
-      def extract(file_path)
-        return titleize_filename(file_path) unless File.file?(file_path)
-
-        content = File.read(file_path)
-        markdown = Markdown.new(content)
-        markdown.title || titleize_filename(file_path)
-      rescue StandardError => e
-        Docyard.logger.warn "Failed to extract title from #{file_path}: #{e.message}"
-        titleize_filename(file_path)
-      end
-
-      private
-
-      def titleize_filename(file_path)
-        filename = File.basename(file_path, Constants::MARKDOWN_EXTENSION)
-        Utils::TextFormatter.titleize(filename)
-      end
-    end
-  end
-end

data/lib/docyard/navigation/sidebar/tree_builder.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "sorter"
-require_relative "local_config_loader"
-require_relative "config_parser"
-require_relative "metadata_reader"
-
-module Docyard
-  module Sidebar
-    class TreeBuilder
-      attr_reader :docs_path, :current_path, :title_extractor, :metadata_reader
-
-      def initialize(docs_path:, current_path:, title_extractor: TitleExtractor.new)
-        @docs_path = docs_path
-        @current_path = Utils::PathResolver.normalize(current_path)
-        @title_extractor = title_extractor
-        @metadata_reader = MetadataReader.new
-      end
-
-      def build(file_items)
-        transform_items(file_items, "", depth: 1)
-      end
-
-      private
-
-      def transform_items(items, relative_base, depth:)
-        transformed = items.map do |item|
-          if item[:type] == :directory
-            transform_directory(item, relative_base, depth: depth)
-          else
-            transform_file(item, relative_base)
-          end
-        end
-        Sorter.sort_by_order(transformed)
-      end
-
-      def transform_directory(item, relative_base, depth:)
-        dir_path = File.join(relative_base, item[:name])
-        dir_context = build_directory_context(dir_path)
-        children = build_directory_children(item, dir_path, depth)
-
-        if depth == 1
-          build_section(item, children, dir_context)
-        else
-          build_collapsible_group(item, children, dir_context)
-        end
-      end
-
-      def build_directory_children(item, dir_path, depth)
-        full_dir_path = File.join(docs_path, dir_path)
-        local_config = LocalConfigLoader.new(full_dir_path).load
-
-        if local_config
-          build_children_from_config(local_config, dir_path)
-        else
-          transform_items(item[:children], dir_path, depth: depth + 1)
-        end
-      end
-
-      def build_children_from_config(config_items, base_path)
-        full_base_path = File.join(docs_path, base_path)
-        parser = ConfigParser.new(config_items, docs_path: full_base_path, current_path: current_path)
-        parser.parse.map(&:to_h)
-      end
-
-      def build_directory_context(dir_path)
-        index_file_path = File.join(docs_path, dir_path, "index.md")
-        has_index = File.file?(index_file_path)
-        { index_file_path: index_file_path, has_index: has_index,
-          url_path: has_index ? Utils::PathResolver.to_url(dir_path) : nil }
-      end
-
-      def build_section(item, children, context)
-        filtered_children = filter_index_from_children(children, context[:url_path])
-        metadata = context[:has_index] ? metadata_reader.extract_index_metadata(context[:index_file_path]) : {}
-
-        if context[:has_index]
-          overview = build_overview_item(metadata, context[:url_path])
-          filtered_children = [overview] + filtered_children
-        end
-
-        build_section_hash(item, filtered_children, metadata)
-      end
-
-      def build_section_hash(item, children, metadata)
-        { title: Utils::TextFormatter.titleize(item[:name]), path: nil, icon: metadata[:icon],
-          active: false, type: :directory, section: true,
-          collapsed: false, has_index: false, order: metadata[:order], children: children }
-      end
-
-      def build_collapsible_group(item, children, context)
-        filtered_children = filter_index_from_children(children, context[:url_path])
-        metadata = context[:has_index] ? metadata_reader.extract_index_metadata(context[:index_file_path]) : {}
-        is_active = context[:has_index] && current_path == context[:url_path]
-
-        build_collapsible_hash(item, filtered_children, context, metadata, is_active)
-      end
-
-      def build_collapsible_hash(item, children, context, metadata, is_active)
-        { title: Utils::TextFormatter.titleize(item[:name]), path: context[:url_path],
-          icon: metadata[:icon], active: is_active, type: :directory, section: false,
-          collapsed: collapsible_collapsed?(children, is_active), has_index: context[:has_index],
-          order: metadata[:order], children: children }
-      end
-
-      def collapsible_collapsed?(children, is_active)
-        return false if is_active || active_child?(children)
-
-        true
-      end
-
-      def build_overview_item(metadata, url_path)
-        { title: metadata[:sidebar_text] || "Overview", path: url_path,
-          icon: metadata[:icon], active: current_path == url_path, type: :file, children: [] }
-      end
-
-      def filter_index_from_children(children, index_url_path)
-        return children unless index_url_path
-
-        children.reject { |child| child[:path] == index_url_path }
-      end
-
-      def active_child?(children)
-        children.any? { |child| child[:active] || active_child?(child[:children] || []) }
-      end
-
-      def transform_file(item, relative_base)
-        file_path = File.join(relative_base, "#{item[:name]}#{Constants::MARKDOWN_EXTENSION}")
-        full_file_path = File.join(docs_path, file_path)
-        url_path = Utils::PathResolver.to_url(file_path.delete_suffix(Constants::MARKDOWN_EXTENSION))
-        metadata = metadata_reader.extract_file_metadata(full_file_path)
-
-        { title: metadata[:title] || title_extractor.extract(full_file_path),
-          path: url_path, icon: metadata[:icon], active: current_path == url_path,
-          type: :file, order: metadata[:order], badge: metadata[:badge],
-          badge_type: metadata[:badge_type], children: [] }
-      end
-    end
-  end
-end

data/lib/docyard/rendering/icons/LICENSE.phosphor

@@ -1,21 +0,0 @@
-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.