docyard 0.6.0 → 0.8.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/code_line_parser.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Components
-    class CodeLineParser
-      def initialize(code_content)
-        @code_content = code_content
-        @lines = []
-        @current_line = ""
-        @open_tags = []
-        @in_tag = false
-        @tag_buffer = ""
-      end
-
-      def parse
-        @code_content.each_char { |char| process_char(char) }
-        finalize
-      end
-
-      private
-
-      def process_char(char)
-        case char
-        when "<" then start_tag(char)
-        when ">" then end_tag_if_applicable(char)
-        when "\n" then handle_newline
-        else handle_regular_char(char)
-        end
-      end
-
-      def start_tag(char)
-        @in_tag = true
-        @tag_buffer = char
-      end
-
-      def end_tag_if_applicable(char)
-        if @in_tag
-          @in_tag = false
-          @tag_buffer += char
-
-          if @tag_buffer.start_with?("</")
-            @open_tags.pop
-          elsif !@tag_buffer.end_with?("/>")
-            @open_tags << @tag_buffer
-          end
-
-          @current_line += @tag_buffer
-          @tag_buffer = ""
-        else
-          @current_line += char
-        end
-      end
-
-      def handle_newline
-        closing_tags = @open_tags.reverse.map { |tag| closing_tag_for(tag) }.join
-        @lines << "#{@current_line}#{closing_tags}\n"
-        @current_line = @open_tags.join
-      end
-
-      def handle_regular_char(char)
-        if @in_tag
-          @tag_buffer += char
-        else
-          @current_line += char
-        end
-      end
-
-      def finalize
-        @lines << @current_line unless @current_line.empty?
-        @lines << "" if @lines.empty?
-        @lines
-      end
-
-      def closing_tag_for(open_tag)
-        tag_name = open_tag.match(/<(\w+)/)[1]
-        "</#{tag_name}>"
-      end
-    end
-  end
-end

data/lib/docyard/components/code_snippet_import_preprocessor.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_processor"
-
-module Docyard
-  module Components
-    class CodeSnippetImportPreprocessor < BaseProcessor
-      EXTENSION_MAP = {
-        "rb" => "ruby",
-        "js" => "javascript",
-        "ts" => "typescript",
-        "py" => "python",
-        "yml" => "yaml",
-        "md" => "markdown",
-        "sh" => "bash",
-        "zsh" => "bash",
-        "jsx" => "jsx",
-        "tsx" => "tsx"
-      }.freeze
-
-      IMPORT_PATTERN = %r{^<<<\s+@/([^\s{#]+)(?:#([\w-]+))?(?:\{([^}]+)\})?\s*$}
-
-      self.priority = 1
-
-      def preprocess(content)
-        @docs_root = context[:docs_root] || "docs"
-        content.gsub(IMPORT_PATTERN) { |_| process_import(Regexp.last_match) }
-      end
-
-      private
-
-      def process_import(match)
-        filepath = match[1]
-        region = match[2]
-        options = match[3]
-
-        file_content = read_file(filepath)
-        return import_error(filepath, "File not found") unless file_content
-
-        file_content = extract_region(file_content, region) if region
-        return import_error(filepath, "Region '#{region}' not found") unless file_content
-
-        build_code_block(file_content, filepath, options)
-      end
-
-      def read_file(filepath)
-        full_path = File.join(@docs_root, filepath)
-        return nil unless File.exist?(full_path)
-
-        File.read(full_path)
-      end
-
-      def extract_region(content, region_name)
-        region_start = %r{^[ \t]*(?://|#|/\*)\s*#region\s+#{Regexp.escape(region_name)}\b.*$}
-        region_end = %r{^[ \t]*(?://|#|/\*|\*/)\s*#endregion\s*#{Regexp.escape(region_name)}?\b.*$}
-
-        lines = content.lines
-        start_index = lines.find_index { |line| line.match?(region_start) }
-        return nil unless start_index
-
-        end_index = lines[(start_index + 1)..].find_index { |line| line.match?(region_end) }
-        return nil unless end_index
-
-        end_index += start_index + 1
-        lines[(start_index + 1)...end_index].join
-      end
-
-      def build_code_block(content, filepath, options)
-        lang = detect_language(filepath)
-        highlights = nil
-
-        if options
-          parsed = parse_options(options)
-          lang = parsed[:lang] if parsed[:lang]
-          highlights = parsed[:highlights] if parsed[:highlights]
-        end
-
-        content = extract_line_range(content, highlights) if highlights&.include?("-") && !highlights.include?(",")
-
-        meta = build_meta_string(highlights, filepath)
-
-        "```#{lang}#{meta}\n#{content.chomp}\n```"
-      end
-
-      def parse_options(options)
-        parts = options.strip.split(/\s+/)
-        result = { highlights: nil, lang: nil }
-
-        parts.each do |part|
-          if part.match?(/^[\d,-]+$/)
-            result[:highlights] = part
-          else
-            result[:lang] = part
-          end
-        end
-
-        result
-      end
-
-      def extract_line_range(content, range_str)
-        return content unless range_str&.match?(/^\d+-\d+$/)
-
-        start_line, end_line = range_str.split("-").map(&:to_i)
-        lines = content.lines
-        lines[(start_line - 1)..(end_line - 1)]&.join || content
-      end
-
-      def build_meta_string(highlights, filepath)
-        parts = []
-        parts << " [#{File.basename(filepath)}]" if filepath
-        parts << " {#{highlights}}" if highlights && !highlights.match?(/^\d+-\d+$/)
-        parts.join
-      end
-
-      def detect_language(filepath)
-        ext = File.extname(filepath).delete_prefix(".")
-        EXTENSION_MAP[ext] || ext
-      end
-
-      def import_error(filepath, message)
-        "```\nError importing #{filepath}: #{message}\n```"
-      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)
-        context[: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,191 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "code_block_feature_extractor"
-require_relative "code_block_icon_detector"
-require_relative "code_block_line_wrapper"
-require_relative "icon_detector"
-require_relative "../icons"
-require_relative "../renderer"
-require "kramdown"
-require "kramdown-parser-gfm"
-require "cgi"
-
-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?
-
-        tab_name, tab_content = extract_tab_parts(section)
-        return nil if tab_name.nil? || tab_name.empty?
-
-        build_tab_data(tab_name, tab_content)
-      end
-
-      def extract_tab_parts(section)
-        parts = section.split("\n", 2)
-        [parts[0]&.strip, parts[1]&.strip || ""]
-      end
-
-      def build_tab_data(tab_name, tab_content)
-        icon_data = IconDetector.detect(tab_name, tab_content)
-
-        extracted = CodeBlockFeatureExtractor.process_markdown(tab_content)
-        rendered_content = render_markdown(extracted[:cleaned_markdown])
-        enhanced_content = enhance_code_blocks(rendered_content, extracted[:blocks])
-
-        {
-          name: icon_data[:name],
-          content: enhanced_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
-
-      def enhance_code_blocks(html, blocks)
-        return html unless html.include?('<div class="highlight">')
-
-        block_index = 0
-        html.gsub(%r{<div class="highlight">(.*?)</div>}m) do
-          block_data = blocks[block_index] || {}
-          block_index += 1
-          render_enhanced_code_block(Regexp.last_match, block_data)
-        end
-      end
-
-      def render_enhanced_code_block(match, block_data)
-        original_html = match[0]
-        inner_html = match[1]
-        code_text = extract_code_text(inner_html)
-
-        processed_html = if needs_line_wrapping?(block_data)
-                           wrap_code_block_lines(original_html, block_data)
-                         else
-                           original_html
-                         end
-
-        Renderer.new.render_partial("_code_block", build_full_locals(processed_html, code_text, block_data))
-      end
-
-      def needs_line_wrapping?(block_data)
-        %i[highlights diff_lines focus_lines error_lines warning_lines].any? do |key|
-          block_data[key]&.any?
-        end
-      end
-
-      def wrap_code_block_lines(html, block_data)
-        wrapper_data = {
-          highlights: block_data[:highlights] || [],
-          diff_lines: block_data[:diff_lines] || {},
-          focus_lines: block_data[:focus_lines] || {},
-          error_lines: block_data[:error_lines] || {},
-          warning_lines: block_data[:warning_lines] || {},
-          start_line: extract_start_line(block_data[:option])
-        }
-        CodeBlockLineWrapper.wrap_code_block(html, wrapper_data)
-      end
-
-      def build_full_locals(processed_html, code_text, block_data)
-        title_data = CodeBlockIconDetector.detect(block_data[:title], block_data[:lang])
-        show_line_numbers = line_numbers_enabled?(block_data[:option])
-        start_line = extract_start_line(block_data[:option])
-
-        base_locals(processed_html, code_text, show_line_numbers, start_line)
-          .merge(feature_locals(block_data))
-          .merge(title_locals(title_data))
-      end
-
-      def base_locals(processed_html, code_text, show_line_numbers, start_line)
-        {
-          code_block_html: processed_html,
-          code_text: escape_html_attribute(code_text),
-          copy_icon: Icons.render("copy", "regular") || "",
-          show_line_numbers: show_line_numbers,
-          line_numbers: show_line_numbers ? generate_line_numbers(code_text, start_line) : [],
-          start_line: start_line
-        }
-      end
-
-      def feature_locals(block_data)
-        {
-          highlights: block_data[:highlights] || [],
-          diff_lines: block_data[:diff_lines] || {},
-          focus_lines: block_data[:focus_lines] || {},
-          error_lines: block_data[:error_lines] || {},
-          warning_lines: block_data[:warning_lines] || {}
-        }
-      end
-
-      def title_locals(title_data)
-        {
-          title: title_data[:title],
-          icon: title_data[:icon],
-          icon_source: title_data[:icon_source]
-        }
-      end
-
-      def line_numbers_enabled?(block_option)
-        return false if block_option == ":no-line-numbers"
-        return true if block_option&.start_with?(":line-numbers")
-
-        false
-      end
-
-      def extract_start_line(block_option)
-        return 1 unless block_option&.include?("=")
-
-        block_option.split("=").last.to_i
-      end
-
-      def generate_line_numbers(code_text, start_line)
-        line_count = code_text.lines.count
-        line_count = 1 if line_count.zero?
-        (start_line...(start_line + line_count)).to_a
-      end
-
-      def extract_code_text(html)
-        text = html.gsub(/<[^>]+>/, "")
-        text = CGI.unescapeHTML(text)
-        text.strip
-      end
-
-      def escape_html_attribute(text)
-        text.gsub('"', "&quot;")
-          .gsub("'", "&#39;")
-          .gsub("<", "&lt;")
-          .gsub(">", "&gt;")
-      end
-    end
-  end
-end