docyard 0.5.0 → 0.6.0

data/lib/docyard/components/code_block_processor.rb

@@ -1,28 +1,138 @@
 # 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">')
 
-        html.gsub(%r{<div class="highlight">(.*?)</div>}m) do
-          process_code_block(Regexp.last_match(0), Regexp.last_match(1))
-        end
+        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])
 
-        render_code_block_with_copy(original_html, code_text)
+        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)
@@ -31,17 +141,28 @@ module Docyard
         text.strip
       end
 
-      def render_code_block_with_copy(code_block_html, code_text)
-        copy_icon = Icons.render("copy", "regular") || ""
-        renderer = Renderer.new
+      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
 
-        renderer.render_partial(
-          "_code_block", {
-            code_block_html: code_block_html,
-            code_text: escape_html_attribute(code_text),
-            copy_icon: copy_icon
-          }
-        )
+      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)

data/lib/docyard/components/code_line_parser.rb

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

@@ -0,0 +1,125 @@
+# 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/registry.rb

@@ -11,15 +11,15 @@ module Docyard
           @processors.sort_by! { |p| p.priority || 100 }
         end
 
-        def run_preprocessors(content)
+        def run_preprocessors(content, context = {})
           @processors.reduce(content) do |processed_content, processor_class|
-            processor_class.new.preprocess(processed_content)
+            processor_class.new(context).preprocess(processed_content)
           end
         end
 
-        def run_postprocessors(html)
+        def run_postprocessors(html, context = {})
           @processors.reduce(html) do |processed_html, processor_class|
-            processor_class.new.postprocess(processed_html)
+            processor_class.new(context).postprocess(processed_html)
           end
         end
 

data/lib/docyard/components/table_of_contents_processor.rb

@@ -7,7 +7,7 @@ module Docyard
 
       def postprocess(html)
         headings = extract_headings(html)
-        Thread.current[:docyard_toc] = headings
+        context[:toc] = headings
         html
       end
 

data/lib/docyard/components/tabs_parser.rb

@@ -1,8 +1,14 @@
 # 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
@@ -30,16 +36,27 @@ module Docyard
       def parse_section(section)
         return nil if section.strip.empty?
 
-        parts = section.split("\n", 2)
-        tab_name = parts[0]&.strip
+        tab_name, tab_content = extract_tab_parts(section)
         return nil if tab_name.nil? || tab_name.empty?
 
-        tab_content = parts[1]&.strip || ""
+        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: render_markdown(tab_content),
+          content: enhanced_content,
           icon: icon_data[:icon],
           icon_source: icon_data[:icon_source]
         }
@@ -55,6 +72,120 @@ module Docyard
           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

data/lib/docyard/components/tabs_range_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    module TabsRangeFinder
+      module_function
+
+      def find_ranges(html)
+        ranges = []
+        start_pattern = '<div class="docyard-tabs"'
+
+        pos = 0
+        while (start_pos = html.index(start_pattern, pos))
+          end_pos = find_matching_close_div(html, start_pos)
+          ranges << (start_pos...end_pos) if end_pos
+          pos = end_pos || (start_pos + 1)
+        end
+        ranges
+      end
+
+      def find_matching_close_div(html, start_pos)
+        depth = 0
+        pos = start_pos
+
+        while pos < html.length
+          if html[pos, 4] == "<div"
+            depth += 1
+            pos += 4
+          elsif html[pos, 6] == "</div>"
+            depth -= 1
+            return pos + 6 if depth.zero?
+
+            pos += 6
+          else
+            pos += 1
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/docyard/config/validator.rb

@@ -12,6 +12,7 @@ module Docyard
         validate_site_section
         validate_branding_section
         validate_build_section
+        validate_markdown_section
 
         raise ConfigError, format_errors if @errors.any?
       end
@@ -48,6 +49,13 @@ module Docyard
         validate_boolean(build["clean"], "build.clean")
       end
 
+      def validate_markdown_section
+        markdown = @config["markdown"]
+        return unless markdown
+
+        validate_boolean(markdown["lineNumbers"], "markdown.lineNumbers") if markdown.key?("lineNumbers")
+      end
+
       def validate_string(value, field_name)
         return if value.nil?
         return if value.is_a?(String)

data/lib/docyard/config.rb

@@ -34,6 +34,9 @@ module Docyard
           "prev_text" => "Previous",
           "next_text" => "Next"
         }
+      },
+      "markdown" => {
+        "lineNumbers" => false
       }
     }.freeze
 
@@ -74,6 +77,10 @@ module Docyard
       @navigation ||= ConfigSection.new(data["navigation"])
     end
 
+    def markdown
+      @markdown ||= ConfigSection.new(data["markdown"])
+    end
+
     private
 
     def load_config_data