docyard 0.5.0 → 0.7.0

data/lib/docyard/components/code_detector.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../language_mapping"
-
-module Docyard
-  module Components
-    class CodeDetector
-      def self.detect(content)
-        new(content).detect
-      end
-
-      def initialize(content)
-        @content = content
-      end
-
-      def detect
-        return nil unless code_only?
-
-        language = extract_language
-        return nil unless language
-
-        icon_for_language(language)
-      end
-
-      private
-
-      attr_reader :content
-
-      def code_only?
-        stripped = content.strip
-        return false unless stripped.start_with?("```") && stripped.end_with?("```")
-
-        parts = stripped.split("```")
-        parts.length == 2 && parts[0].empty?
-      end
-
-      def extract_language
-        parts = content.strip.split("```")
-        return nil unless parts[1]
-
-        lines = parts[1].split("\n", 2)
-        lang_line = lines[0].strip
-        return nil if lang_line.empty? || lang_line.include?(" ")
-
-        lang_line.downcase
-      end
-
-      def icon_for_language(language)
-        if LanguageMapping.terminal_language?(language)
-          { icon: "terminal-window", source: "phosphor" }
-        elsif (extension = LanguageMapping.extension_for(language))
-          { icon: extension, source: "file-extension" }
-        else
-          { icon: "file", source: "phosphor" }
-        end
-      end
-    end
-  end
-end

data/lib/docyard/components/heading_anchor_processor.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Components
-    class HeadingAnchorProcessor < BaseProcessor
-      self.priority = 30
-
-      def postprocess(html)
-        add_anchor_links(html)
-      end
-
-      private
-
-      def add_anchor_links(html)
-        html.gsub(%r{<(h[2-6])\s+id="([^"]+)">(.*?)</\1>}m) do |_match|
-          tag = Regexp.last_match(1)
-          id = Regexp.last_match(2)
-          content = Regexp.last_match(3)
-
-          anchor_html = render_anchor_link(id)
-
-          "<#{tag} id=\"#{id}\">#{content}#{anchor_html}</#{tag}>"
-        end
-      end
-
-      def render_anchor_link(id)
-        renderer = Renderer.new
-        renderer.render_partial("_heading_anchor", {
-                                  id: id
-                                })
-      end
-    end
-  end
-end

data/lib/docyard/components/icon_detector.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "code_detector"
-
-module Docyard
-  module Components
-    class IconDetector
-      MANUAL_ICON_PATTERN = /^:([a-z0-9-]+):\s*(.+)$/i
-
-      def self.detect(tab_name, tab_content)
-        new(tab_name, tab_content).detect
-      end
-
-      def initialize(tab_name, tab_content)
-        @tab_name = tab_name
-        @tab_content = tab_content
-      end
-
-      def detect
-        manual_icon || auto_detected_icon || no_icon
-      end
-
-      private
-
-      attr_reader :tab_name, :tab_content
-
-      def manual_icon
-        return nil unless tab_name.match(MANUAL_ICON_PATTERN)
-
-        {
-          name: Regexp.last_match(2).strip,
-          icon: Regexp.last_match(1),
-          icon_source: "phosphor"
-        }
-      end
-
-      def auto_detected_icon
-        detected = CodeDetector.detect(tab_content)
-        return nil unless detected
-
-        {
-          name: tab_name,
-          icon: detected[:icon],
-          icon_source: detected[:source]
-        }
-      end
-
-      def no_icon
-        {
-          name: tab_name,
-          icon: nil,
-          icon_source: nil
-        }
-      end
-    end
-  end
-end

data/lib/docyard/components/icon_processor.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../icons"
-require_relative "base_processor"
-
-module Docyard
-  module Components
-    class IconProcessor < BaseProcessor
-      self.priority = 20
-
-      ICON_PATTERN = /:([a-z][a-z0-9-]*):(?:([a-z]+):)?/i
-
-      def postprocess(html)
-        segments = split_preserving_code_blocks(html)
-
-        segments.map do |segment|
-          segment[:type] == :code ? segment[:content] : process_segment(segment[:content])
-        end.join
-      end
-
-      private
-
-      def split_preserving_code_blocks(html)
-        segments = []
-        current_pos = 0
-
-        html.scan(%r{<(code|pre)[^>]*>.*?</\1>}m) do
-          match_start = Regexp.last_match.begin(0)
-          match_end = Regexp.last_match.end(0)
-
-          segments << { type: :text, content: html[current_pos...match_start] } if match_start > current_pos
-          segments << { type: :code, content: html[match_start...match_end] }
-
-          current_pos = match_end
-        end
-
-        segments << { type: :text, content: html[current_pos..] } if current_pos < html.length
-
-        segments.empty? ? [{ type: :text, content: html }] : segments
-      end
-
-      def process_segment(content)
-        content.gsub(ICON_PATTERN) do
-          icon_name = Regexp.last_match(1)
-          weight = Regexp.last_match(2) || "regular"
-          Icons.render(icon_name, weight) || Regexp.last_match(0)
-        end
-      end
-    end
-  end
-end

data/lib/docyard/components/table_of_contents_processor.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Components
-    class TableOfContentsProcessor < BaseProcessor
-      self.priority = 35
-
-      def postprocess(html)
-        headings = extract_headings(html)
-        Thread.current[:docyard_toc] = headings
-        html
-      end
-
-      private
-
-      def extract_headings(html)
-        headings = []
-
-        html.scan(%r{<(h[2-4])\s+id="([^"]+)">(.*?)</\1>}m) do
-          level = Regexp.last_match(1)[1].to_i
-          id = Regexp.last_match(2)
-          text = strip_html(Regexp.last_match(3))
-
-          headings << {
-            level: level,
-            id: id,
-            text: text
-          }
-        end
-
-        build_hierarchy(headings)
-      end
-
-      def build_hierarchy(headings)
-        return [] if headings.empty?
-
-        root = []
-        stack = []
-
-        headings.each do |heading|
-          heading[:children] = []
-
-          stack.pop while stack.any? && stack.last[:level] >= heading[:level]
-
-          if stack.empty?
-            root << heading
-          else
-            stack.last[:children] << heading
-          end
-
-          stack << heading
-        end
-
-        root
-      end
-
-      def strip_html(text)
-        text.gsub(%r{<a[^>]*class="heading-anchor"[^>]*>.*?</a>}, "")
-          .gsub(/<[^>]+>/, "")
-          .strip
-      end
-    end
-  end
-end

data/lib/docyard/components/table_wrapper_processor.rb

@@ -1,18 +0,0 @@
-# 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/components/tabs_parser.rb

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

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Routing
-    class ResolutionResult
-      attr_reader :file_path, :status
-
-      def self.found(file_path)
-        new(file_path: file_path, status: :found)
-      end
-
-      def self.not_found
-        new(file_path: nil, status: :not_found)
-      end
-
-      def initialize(file_path:, status:)
-        @file_path = file_path
-        @status = status
-        freeze
-      end
-
-      def found?
-        status == :found
-      end
-
-      def not_found?
-        status == :not_found
-      end
-    end
-  end
-end