docyard 0.6.0 → 0.7.0

data/lib/docyard/components/code_block_feature_extractor.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "code_block_patterns"
-
-module Docyard
-  module Components
-    module CodeBlockFeatureExtractor
-      include CodeBlockPatterns
-
-      CODE_FENCE_REGEX = /^```(\w+)(?:\s*\[([^\]]+)\])?(:\S+)?(?:\s*\{([^}\n]+)\})?[ \t]*\n(.*?)^```/m
-
-      module_function
-
-      def process_markdown(markdown)
-        blocks = []
-        cleaned = markdown.gsub(CODE_FENCE_REGEX) do
-          block_data = extract_block_data(Regexp.last_match)
-          blocks << block_data
-          "```#{block_data[:lang]}\n#{block_data[:cleaned_content]}```"
-        end
-        { cleaned_markdown: cleaned, blocks: blocks }
-      end
-
-      def extract_block_data(match)
-        code_content = match[5]
-        diff_info = extract_diff_lines(code_content)
-        focus_info = extract_focus_lines(diff_info[:cleaned_content])
-        error_info = extract_error_lines(focus_info[:cleaned_content])
-        warning_info = extract_warning_lines(error_info[:cleaned_content])
-
-        build_block_result(match, diff_info, focus_info, error_info, warning_info)
-      end
-
-      def build_block_result(match, diff_info, focus_info, error_info, warning_info)
-        {
-          lang: match[1],
-          title: match[2],
-          option: match[3],
-          highlights: parse_highlights(match[4]),
-          diff_lines: diff_info[:lines],
-          focus_lines: focus_info[:lines],
-          error_lines: error_info[:lines],
-          warning_lines: warning_info[:lines],
-          cleaned_content: warning_info[:cleaned_content]
-        }
-      end
-
-      def parse_highlights(highlights_str)
-        return [] if highlights_str.nil? || highlights_str.strip.empty?
-
-        highlights_str.split(",").flat_map { |part| parse_highlight_part(part.strip) }.uniq.sort
-      end
-
-      def parse_highlight_part(part)
-        return (part.split("-")[0].to_i..part.split("-")[1].to_i).to_a if part.include?("-")
-
-        [part.to_i]
-      end
-
-      def extract_diff_lines(code_content)
-        lines = code_content.lines
-        diff_lines = {}
-        cleaned_lines = []
-
-        lines.each_with_index do |line, index|
-          line_num = index + 1
-
-          if (match = line.match(DIFF_MARKER_PATTERN))
-            diff_type = match.captures.compact.first
-            diff_lines[line_num] = diff_type == "++" ? :addition : :deletion
-            cleaned_line = line.gsub(DIFF_MARKER_PATTERN, "")
-            cleaned_lines << cleaned_line
-          else
-            cleaned_lines << line
-          end
-        end
-
-        { lines: diff_lines, cleaned_content: cleaned_lines.join }
-      end
-
-      def extract_focus_lines(code_content)
-        extract_marker_lines(code_content, FOCUS_MARKER_PATTERN)
-      end
-
-      def extract_error_lines(code_content)
-        extract_marker_lines(code_content, ERROR_MARKER_PATTERN)
-      end
-
-      def extract_warning_lines(code_content)
-        extract_marker_lines(code_content, WARNING_MARKER_PATTERN)
-      end
-
-      def extract_marker_lines(code_content, pattern)
-        lines = code_content.lines
-        marker_lines = {}
-        cleaned_lines = []
-
-        lines.each_with_index do |line, index|
-          line_num = index + 1
-
-          if line.match?(pattern)
-            marker_lines[line_num] = true
-            cleaned_lines << line.gsub(pattern, "")
-          else
-            cleaned_lines << line
-          end
-        end
-
-        { lines: marker_lines, cleaned_content: cleaned_lines.join }
-      end
-    end
-  end
-end

data/lib/docyard/components/code_block_focus_preprocessor.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_processor"
-
-module Docyard
-  module Components
-    class CodeBlockFocusPreprocessor < BaseProcessor
-      self.priority = 7
-
-      FOCUS_MARKER_PATTERN = %r{
-        (?:
-          //\s*\[!code\s+focus\]              |
-          \#\s*\[!code\s+focus\]              |
-          /\*\s*\[!code\s+focus\]\s*\*/       |
-          --\s*\[!code\s+focus\]              |
-          <!--\s*\[!code\s+focus\]\s*-->      |
-          ;\s*\[!code\s+focus\]
-        )[^\S\n]*
-      }x
-
-      CODE_BLOCK_REGEX = /^```(\w*).*?\n(.*?)^```/m
-      TABS_BLOCK_REGEX = /^:::[ \t]*tabs[ \t]*\n.*?^:::[ \t]*$/m
-
-      def preprocess(content)
-        context[:code_block_focus_lines] ||= []
-        @block_index = 0
-        @tabs_ranges = find_tabs_ranges(content)
-
-        content.gsub(CODE_BLOCK_REGEX) { |_| process_code_block(Regexp.last_match) }
-      end
-
-      private
-
-      def process_code_block(match)
-        return match[0] if inside_tabs?(match.begin(0))
-
-        focus_info = extract_focus_lines(match[2])
-        context[:code_block_focus_lines][@block_index] = focus_info[:lines]
-        @block_index += 1
-        match[0].sub(match[2], focus_info[:cleaned_content])
-      end
-
-      def extract_focus_lines(code_content)
-        lines = code_content.lines
-        focus_lines = {}
-        cleaned_lines = []
-
-        lines.each_with_index do |line, index|
-          line_num = index + 1
-
-          if line.match?(FOCUS_MARKER_PATTERN)
-            focus_lines[line_num] = true
-            cleaned_line = line.gsub(FOCUS_MARKER_PATTERN, "")
-            cleaned_lines << cleaned_line
-          else
-            cleaned_lines << line
-          end
-        end
-
-        { lines: focus_lines, cleaned_content: cleaned_lines.join }
-      end
-
-      def inside_tabs?(position)
-        @tabs_ranges.any? { |range| range.cover?(position) }
-      end
-
-      def find_tabs_ranges(content)
-        ranges = []
-        content.scan(TABS_BLOCK_REGEX) do
-          match = Regexp.last_match
-          ranges << (match.begin(0)...match.end(0))
-        end
-        ranges
-      end
-    end
-  end
-end

data/lib/docyard/components/code_block_icon_detector.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../language_mapping"
-
-module Docyard
-  module Components
-    module CodeBlockIconDetector
-      MANUAL_ICON_PATTERN = /^:([a-z0-9-]+):\s*(.+)$/i
-
-      module_function
-
-      def detect(title, language)
-        return { title: nil, icon: nil, icon_source: nil } if title.nil?
-
-        if (match = title.match(MANUAL_ICON_PATTERN))
-          return {
-            title: match[2].strip,
-            icon: match[1],
-            icon_source: "phosphor"
-          }
-        end
-
-        icon, icon_source = auto_detect_icon(language)
-        { title: title, icon: icon, icon_source: icon_source }
-      end
-
-      def auto_detect_icon(language)
-        return [nil, nil] if language.nil?
-
-        if LanguageMapping.terminal_language?(language)
-          %w[terminal-window phosphor]
-        elsif (ext = LanguageMapping.extension_for(language))
-          [ext, "file-extension"]
-        else
-          %w[file phosphor]
-        end
-      end
-    end
-  end
-end

data/lib/docyard/components/code_block_line_wrapper.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "code_line_parser"
-
-module Docyard
-  module Components
-    module CodeBlockLineWrapper
-      module_function
-
-      def wrap_code_block(html, block_data)
-        html.gsub(%r{<pre[^>]*><code[^>]*>(.*?)</code></pre>}m) do
-          pre_match = Regexp.last_match(0)
-          code_content = Regexp.last_match(1)
-          lines = CodeLineParser.new(code_content).parse
-          wrapped_lines = wrap_lines_with_classes(lines, block_data)
-          pre_match.sub(code_content, wrapped_lines.join)
-        end
-      end
-
-      def wrap_lines_with_classes(lines, block_data)
-        lines.each_with_index.map do |line, index|
-          source_line = index + 1
-          display_line = block_data[:start_line] + index
-          classes = build_line_classes(source_line, display_line, block_data)
-          %(<span class="#{classes}">#{line}</span>)
-        end
-      end
-
-      DIFF_CLASSES = { addition: "docyard-code-line--diff-add", deletion: "docyard-code-line--diff-remove" }.freeze
-
-      def build_line_classes(source_line, display_line, block_data)
-        (["docyard-code-line"] + feature_classes(source_line, display_line, block_data)).join(" ")
-      end
-
-      def feature_classes(source_line, display_line, block_data)
-        [
-          ("docyard-code-line--highlighted" if block_data[:highlights].include?(display_line)),
-          DIFF_CLASSES[block_data[:diff_lines][source_line]],
-          ("docyard-code-line--focus" if block_data[:focus_lines][source_line]),
-          ("docyard-code-line--error" if block_data[:error_lines][source_line]),
-          ("docyard-code-line--warning" if block_data[:warning_lines][source_line])
-        ].compact
-      end
-    end
-  end
-end

data/lib/docyard/components/code_block_options_preprocessor.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_processor"
-
-module Docyard
-  module Components
-    class CodeBlockOptionsPreprocessor < BaseProcessor
-      self.priority = 5
-
-      CODE_FENCE_REGEX = /^```(\w+)(?:\s*\[([^\]]+)\])?(:\S+)?(?:\s*\{([^}\n]+)\})?/
-      TABS_BLOCK_REGEX = /^:::[ \t]*tabs[ \t]*\n.*?^:::[ \t]*$/m
-
-      def preprocess(content)
-        context[:code_block_options] ||= []
-        @tabs_ranges = find_tabs_ranges(content)
-
-        process_code_fences(content)
-      end
-
-      private
-
-      def process_code_fences(content)
-        result = +""
-        last_end = 0
-
-        content.scan(CODE_FENCE_REGEX) do
-          match = Regexp.last_match
-          result << content[last_end...match.begin(0)]
-          result << process_fence_match(match)
-          last_end = match.end(0)
-        end
-
-        result << content[last_end..]
-      end
-
-      def process_fence_match(match)
-        store_code_block_options(match) unless inside_tabs?(match.begin(0))
-        "```#{match[1]}"
-      end
-
-      def store_code_block_options(match)
-        context[:code_block_options] << {
-          lang: match[1],
-          title: match[2],
-          option: match[3],
-          highlights: parse_highlights(match[4])
-        }
-      end
-
-      def inside_tabs?(position)
-        @tabs_ranges.any? { |range| range.cover?(position) }
-      end
-
-      def find_tabs_ranges(content)
-        ranges = []
-        content.scan(TABS_BLOCK_REGEX) do
-          match = Regexp.last_match
-          ranges << (match.begin(0)...match.end(0))
-        end
-        ranges
-      end
-
-      def parse_highlights(highlights_str)
-        return [] if highlights_str.nil? || highlights_str.strip.empty?
-
-        highlights_str.split(",").flat_map { |part| parse_highlight_part(part.strip) }.uniq.sort
-      end
-
-      def parse_highlight_part(part)
-        return (part.split("-")[0].to_i..part.split("-")[1].to_i).to_a if part.include?("-")
-
-        [part.to_i]
-      end
-    end
-  end
-end

data/lib/docyard/components/code_block_patterns.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Docyard
-  module Components
-    module CodeBlockPatterns
-      DIFF_MARKER_PATTERN = %r{
-        (?:
-          //\s*\[!code\s*([+-]{2})\]              |
-          \#\s*\[!code\s*([+-]{2})\]              |
-          /\*\s*\[!code\s*([+-]{2})\]\s*\*/       |
-          --\s*\[!code\s*([+-]{2})\]              |
-          <!--\s*\[!code\s*([+-]{2})\]\s*-->      |
-          ;\s*\[!code\s*([+-]{2})\]
-        )[^\S\n]*
-      }x
-
-      FOCUS_MARKER_PATTERN = %r{
-        (?:
-          //\s*\[!code\s+focus\]              |
-          \#\s*\[!code\s+focus\]              |
-          /\*\s*\[!code\s+focus\]\s*\*/       |
-          --\s*\[!code\s+focus\]              |
-          <!--\s*\[!code\s+focus\]\s*-->      |
-          ;\s*\[!code\s+focus\]
-        )[^\S\n]*
-      }x
-
-      ERROR_MARKER_PATTERN = %r{
-        (?:
-          //\s*\[!code\s+error\]              |
-          \#\s*\[!code\s+error\]              |
-          /\*\s*\[!code\s+error\]\s*\*/       |
-          --\s*\[!code\s+error\]              |
-          <!--\s*\[!code\s+error\]\s*-->      |
-          ;\s*\[!code\s+error\]
-        )[^\S\n]*
-      }x
-
-      WARNING_MARKER_PATTERN = %r{
-        (?:
-          //\s*\[!code\s+warning\]              |
-          \#\s*\[!code\s+warning\]              |
-          /\*\s*\[!code\s+warning\]\s*\*/       |
-          --\s*\[!code\s+warning\]              |
-          <!--\s*\[!code\s+warning\]\s*-->      |
-          ;\s*\[!code\s+warning\]
-        )[^\S\n]*
-      }x
-    end
-  end
-end

data/lib/docyard/components/code_block_processor.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../icons"
-require_relative "../language_mapping"
-require_relative "../renderer"
-require_relative "base_processor"
-require_relative "code_block_icon_detector"
-require_relative "code_block_line_wrapper"
-require_relative "tabs_range_finder"
-
-module Docyard
-  module Components
-    class CodeBlockProcessor < BaseProcessor
-      include CodeBlockLineWrapper
-
-      self.priority = 20
-
-      def postprocess(html)
-        return html unless html.include?('<div class="highlight">')
-
-        initialize_postprocess_state(html)
-        process_all_highlight_blocks(html)
-      end
-
-      private
-
-      def initialize_postprocess_state(html)
-        @block_index = 0
-        @options = context[:code_block_options] || []
-        @diff_lines = context[:code_block_diff_lines] || []
-        @focus_lines = context[:code_block_focus_lines] || []
-        @error_lines = context[:code_block_error_lines] || []
-        @warning_lines = context[:code_block_warning_lines] || []
-        @global_line_numbers = context.dig(:config, "markdown", "lineNumbers") || false
-        @tabs_ranges = TabsRangeFinder.find_ranges(html)
-      end
-
-      def process_all_highlight_blocks(html)
-        result = +""
-        last_end = 0
-
-        html.scan(%r{<div class="highlight">(.*?)</div>}m) do
-          match = Regexp.last_match
-          result << html[last_end...match.begin(0)]
-          result << process_highlight_match(match)
-          last_end = match.end(0)
-        end
-
-        result << html[last_end..]
-      end
-
-      def process_highlight_match(match)
-        if inside_tabs?(match.begin(0))
-          match[0]
-        else
-          processed = process_code_block(match[0], match[1])
-          @block_index += 1
-          processed
-        end
-      end
-
-      def process_code_block(original_html, inner_html)
-        block_data = extract_block_data(inner_html)
-        processed_html = process_html_for_highlighting(original_html, block_data)
-
-        render_code_block_with_copy(block_data.merge(html: processed_html))
-      end
-
-      def extract_block_data(inner_html)
-        opts = current_block_options
-        code_text = extract_code_text(inner_html)
-        start_line = extract_start_line(opts[:option])
-        show_line_numbers = determine_line_numbers(opts[:option])
-        title_data = CodeBlockIconDetector.detect(opts[:title], opts[:lang])
-
-        build_block_data(code_text, opts, show_line_numbers, start_line, title_data)
-      end
-
-      def current_block_options
-        block_opts = @options[@block_index] || {}
-        {
-          option: block_opts[:option],
-          title: block_opts[:title],
-          lang: block_opts[:lang],
-          highlights: block_opts[:highlights] || []
-        }
-      end
-
-      def build_block_data(code_text, opts, show_line_numbers, start_line, title_data)
-        {
-          text: code_text,
-          highlights: opts[:highlights],
-          diff_lines: @diff_lines[@block_index] || {},
-          focus_lines: @focus_lines[@block_index] || {},
-          error_lines: @error_lines[@block_index] || {},
-          warning_lines: @warning_lines[@block_index] || {},
-          show_line_numbers: show_line_numbers,
-          line_numbers: show_line_numbers ? generate_line_numbers(code_text, start_line) : [],
-          start_line: start_line,
-          title: title_data[:title],
-          icon: title_data[:icon],
-          icon_source: title_data[:icon_source]
-        }
-      end
-
-      def process_html_for_highlighting(original_html, block_data)
-        needs_wrapping = block_data[:highlights].any? || block_data[:diff_lines].any? ||
-                         block_data[:focus_lines].any? || block_data[:error_lines].any? ||
-                         block_data[:warning_lines].any?
-        return original_html unless needs_wrapping
-
-        wrap_code_block(original_html, block_data)
-      end
-
-      def determine_line_numbers(block_option)
-        return false if block_option == ":no-line-numbers"
-        return true if block_option&.start_with?(":line-numbers")
-
-        @global_line_numbers
-      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 inside_tabs?(position)
-        @tabs_ranges.any? { |range| range.cover?(position) }
-      end
-
-      def extract_code_text(html)
-        text = html.gsub(/<[^>]+>/, "")
-        text = CGI.unescapeHTML(text)
-        text.strip
-      end
-
-      def render_code_block_with_copy(block_data)
-        Renderer.new.render_partial("_code_block", template_locals(block_data))
-      end
-
-      def template_locals(block_data)
-        base_locals(block_data).merge(line_feature_locals(block_data)).merge(title_locals(block_data))
-      end
-
-      def base_locals(block_data)
-        { code_block_html: block_data[:html], code_text: escape_html_attribute(block_data[:text]),
-          copy_icon: Icons.render("copy", "regular") || "", show_line_numbers: block_data[:show_line_numbers],
-          line_numbers: block_data[:line_numbers], start_line: block_data[:start_line] }
-      end
-
-      def line_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(block_data)
-        { title: block_data[:title], icon: block_data[:icon], icon_source: block_data[:icon_source] }
-      end
-
-      def escape_html_attribute(text)
-        text.gsub('"', "&quot;")
-          .gsub("'", "&#39;")
-          .gsub("<", "&lt;")
-          .gsub(">", "&gt;")
-      end
-    end
-  end
-end

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