markdown-run 0.1.10 → 0.1.12

data/lib/pg_flamegraph_svg.rb

@@ -0,0 +1,221 @@
+require 'json'
+require 'securerandom'
+
+class PostgreSQLFlameGraphSVG
+  def initialize(explain_json, width = 1200, height = 600)
+    @explain_data = JSON.parse(explain_json)
+    @width = width
+    @height = height
+    @font_size = 20
+    @min_width = 1
+    @colors = [
+      '#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6',
+      '#1abc9c', '#e67e22', '#95a5a6', '#34495e', '#e91e63'
+    ]
+  end
+
+  def generate_svg
+    plan = @explain_data[0]['Plan']
+
+    # Calculate the layout
+    flamegraph_data = build_flamegraph_data(plan)
+
+    # Generate SVG
+    generate_svg_content(flamegraph_data)
+  end
+
+  private
+
+  def build_flamegraph_data(plan, depth = 0, start_time = 0)
+    node_name = format_node_name(plan)
+    actual_time = plan['Actual Total Time'] || 0
+
+    # Create the current node
+    current_node = {
+      name: node_name,
+      time: actual_time,
+      depth: depth,
+      start: start_time,
+      children: []
+    }
+
+    # Process children
+    if plan['Plans']
+      child_start = start_time
+      plan['Plans'].each do |child_plan|
+        child_node = build_flamegraph_data(child_plan, depth + 1, child_start)
+        current_node[:children] << child_node
+        child_start += child_node[:time]
+      end
+    end
+
+    current_node
+  end
+
+  def format_node_name(node)
+    node_type = node['Node Type']
+
+    # Add relevant details
+    details = []
+
+    if node['Relation Name']
+      details << node['Relation Name']
+    end
+
+    if node['Index Name']
+      details << "idx:#{node['Index Name']}"
+    end
+
+    if node['Join Type']
+      details << node['Join Type']
+    end
+
+    # Build the final name
+    name = node_type
+    unless details.empty?
+      name += " (#{details.join(', ')})"
+    end
+
+    # Add timing info
+    if node['Actual Total Time']
+      name += " [#{node['Actual Total Time'].round(2)}ms]"
+    end
+
+    name
+  end
+
+  def generate_svg_content(flamegraph_data)
+    max_depth = calculate_max_depth(flamegraph_data)
+    total_time = flamegraph_data[:time]
+
+    svg_height = (max_depth + 1) * (@font_size + 4) + 80
+
+    svg = <<~SVG
+      <?xml version="1.0" encoding="UTF-8"?>
+      <svg width="#{@width}" height="#{svg_height}" xmlns="http://www.w3.org/2000/svg">
+        <style>
+          .frame { stroke: white; stroke-width: 1; cursor: pointer; }
+          .frame:hover { stroke: black; stroke-width: 2; }
+          .frame-text { font-family: monospace; font-size: #{@font_size}px; fill: white; pointer-events: none; }
+          .title { font-family: Arial; font-size: 16px; font-weight: bold; fill: #333; }
+          .subtitle { font-family: Arial; font-size: 12px; fill: #666; }
+        </style>
+
+        <!-- Title -->
+        <text x="#{@width/2}" y="20" class="title" text-anchor="middle">PostgreSQL Query Execution Plan Flamegraph</text>
+        <text x="#{@width/2}" y="35" class="subtitle" text-anchor="middle">Total Execution Time: #{total_time.round(2)}ms</text>
+
+        <!-- Flamegraph -->
+        <g transform="translate(0, 45)">
+    SVG
+
+    # Generate rectangles recursively
+    svg += generate_rectangles(flamegraph_data, total_time, 0)
+
+    svg += <<~SVG
+        </g>
+      </svg>
+    SVG
+
+    svg
+  end
+
+  def generate_rectangles(node, total_time, y_offset)
+    return "" if node[:time] <= 0
+
+    # Calculate dimensions
+    width_ratio = node[:time] / total_time
+    rect_width = [@width * width_ratio, @min_width].max
+    rect_height = @font_size + 4
+
+    x_position = (node[:start] / total_time) * @width
+    y_position = y_offset
+
+    # Choose color based on node type
+    color = get_node_color(node[:name])
+
+    # Generate rectangle and text
+    svg = <<~SVG
+      <rect class="frame"
+            x="#{x_position}"
+            y="#{y_position}"
+            width="#{rect_width}"
+            height="#{rect_height}"
+            fill="#{color}">
+        <title>#{escape_xml(node[:name])}
+Time: #{node[:time].round(2)}ms
+Percentage: #{((node[:time] / total_time) * 100).round(1)}%</title>
+      </rect>
+    SVG
+
+    # Add text if rectangle is wide enough
+    if rect_width > 50
+      text_x = x_position + 4
+      text_y = y_position + @font_size + 1
+
+      # Truncate text if necessary
+      display_text = truncate_text(node[:name], rect_width - 8)
+
+      svg += <<~SVG
+        <text class="frame-text" x="#{text_x}" y="#{text_y}">#{escape_xml(display_text)}</text>
+      SVG
+    end
+
+    # Generate children
+    child_y = y_position + rect_height + 2
+    node[:children].each do |child|
+      svg += generate_rectangles(child, total_time, child_y)
+    end
+
+    svg
+  end
+
+  def calculate_max_depth(node, current_depth = 0)
+    max_child_depth = current_depth
+
+    node[:children].each do |child|
+      child_depth = calculate_max_depth(child, current_depth + 1)
+      max_child_depth = [max_child_depth, child_depth].max
+    end
+
+    max_child_depth
+  end
+
+  def get_node_color(node_name)
+    # Color code by operation type
+    case node_name
+    when /Seq Scan/
+      '#e74c3c'  # Red - potentially slow
+    when /Index.*Scan/
+      '#2ecc71'  # Green - good
+    when /Hash Join|Nested Loop|Merge Join/
+      '#3498db'  # Blue - joins
+    when /Sort|Aggregate/
+      '#f39c12'  # Orange - processing
+    when /Result/
+      '#95a5a6'  # Gray - simple
+    else
+      # Cycle through colors based on hash
+      @colors[node_name.hash.abs % @colors.length]
+    end
+  end
+
+  def truncate_text(text, max_width)
+    # Rough estimate: 1 character ≈ 7 pixels in monospace
+    max_chars = (max_width / 7).to_i
+
+    if text.length <= max_chars
+      text
+    else
+      text[0, max_chars - 3] + "..."
+    end
+  end
+
+  def escape_xml(text)
+    text.gsub('&', '&amp;')
+        .gsub('<', '&lt;')
+        .gsub('>', '&gt;')
+        .gsub('"', '&quot;')
+        .gsub("'", '&#39;')
+  end
+end

data/lib/result_helper.rb

@@ -0,0 +1,167 @@
+require_relative "flamegraph_helper"
+
+module ResultHelper
+  include FlamegraphHelper
+
+  private
+
+  def ruby_style_result?(lang)
+    lang_config = SUPPORTED_LANGUAGES[lang]
+    lang_config && lang_config[:result_block_type] == "ruby"
+  end
+
+  def mermaid_style_result?(lang)
+    lang_config = SUPPORTED_LANGUAGES[lang]
+    lang_config && lang_config[:result_handling] == :mermaid_svg
+  end
+
+  def result_block_header(lang)
+    ruby_style_result?(lang) ? "```ruby RESULT\n" : "```RESULT\n"
+  end
+
+  def result_block_regex(lang)
+    if mermaid_style_result?(lang)
+      # For mermaid, look for existing image tags with .svg extension
+      /^!\[.*\]\(.*\.svg\)$/i
+    elsif ruby_style_result?(lang)
+      /^```ruby\s+RESULT$/i
+    else
+      /^```RESULT$/i
+    end
+  end
+
+  def add_result_block(result_output, blank_line_before_new_result)
+    if mermaid_style_result?(@current_block_lang)
+      # For mermaid, add the image tag directly without a result block
+      @output_lines << "\n" if blank_line_before_new_result.nil?
+      @output_lines << result_output
+      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
+      @output_lines << "\n"
+    else
+      @output_lines << "\n" if blank_line_before_new_result.nil?
+      @output_lines << result_block_header(@current_block_lang)
+      @output_lines << result_output
+      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
+      @output_lines << "```\n\n"
+    end
+  end
+
+
+  def handle_inside_result_block(current_line, file_enum)
+    @output_lines << current_line
+    if is_block_end?(current_line)
+      @state = :outside_code_block
+    end
+  end
+
+  def handle_existing_ruby_result_block(current_line, file_enum)
+    warn "Found existing '```ruby RESULT' block, passing through."
+    @output_lines << current_line
+    @state = :inside_result_block
+  end
+
+
+  def execute_and_add_result(blank_line_before_new_result)
+      warn "Skipping empty code block for language '#{@current_block_lang}'." && return unless has_content?(@current_code_content)
+
+    @output_lines << blank_line_before_new_result if blank_line_before_new_result
+
+    result_output = CodeExecutor.execute(@current_code_content, @current_block_lang, @temp_dir, @input_file_path, @current_block_explain, @current_block_flamegraph)
+
+    # Check if result contains a Dalibo link for psql explain queries
+    dalibo_link, result_after_dalibo = extract_dalibo_link(result_output)
+
+    # Check if result contains a flamegraph link for psql flamegraph queries
+    flamegraph_link, clean_result = extract_flamegraph_link(result_after_dalibo)
+
+    # Add the result block only if result=true (default)
+    if @current_block_result
+      add_result_block(clean_result || result_after_dalibo, blank_line_before_new_result)
+    end
+
+    # Always add Dalibo link if it exists, even when result=false
+    if dalibo_link
+      # Add appropriate spacing based on whether result block was shown
+      if @current_block_result
+        @output_lines << "#{dalibo_link}\n\n"
+      else
+        @output_lines << "\n#{dalibo_link}\n\n"
+      end
+    end
+
+    # Always add flamegraph link if it exists, even when result=false
+    if flamegraph_link
+      # Add appropriate spacing based on whether result block was shown
+      if @current_block_result || dalibo_link
+        @output_lines << "#{flamegraph_link}\n\n"
+      else
+        @output_lines << "\n#{flamegraph_link}\n\n"
+      end
+    end
+  end
+
+  def skip_and_pass_through_result(lines_to_pass_through, file_enum, decision = nil)
+    # Handle run=false case where there are no lines to pass through
+    if lines_to_pass_through.empty?
+      warn "Skipping execution due to run=false option."
+      return
+    end
+
+    # Check if this is Dalibo content
+    if decision && decision[:dalibo_content]
+      warn "Found existing Dalibo link for current #{@current_block_lang} block, skipping execution."
+      @output_lines.concat(lines_to_pass_through)
+      # No additional consumption needed for Dalibo links
+      return
+    end
+
+    # Check if this is flamegraph content
+    if decision && decision[:flamegraph_content]
+      warn "Found existing flamegraph for current #{@current_block_lang} block, skipping execution."
+      @output_lines.concat(lines_to_pass_through)
+      # No additional consumption needed for flamegraph links
+      return
+    end
+
+    if mermaid_style_result?(@current_block_lang)
+      warn "Found existing mermaid SVG image for current #{@current_block_lang} block, skipping execution."
+      @output_lines.concat(lines_to_pass_through)
+      # For mermaid, no additional consumption needed since it's just an image line
+    else
+      lang_specific_result_type = ruby_style_result?(@current_block_lang) ? "```ruby RESULT" : "```RESULT"
+      warn "Found existing '#{lang_specific_result_type}' block for current #{@current_block_lang} block, skipping execution."
+      @output_lines.concat(lines_to_pass_through)
+      consume_result_block_content(file_enum)
+    end
+  end
+
+  def consume_result_block_content(file_enum)
+    consume_block_lines(file_enum) do |line|
+      @output_lines << line
+    end
+  end
+
+  def consume_existing_result_block(file_enum, consumed_lines)
+    return if mermaid_style_result?(@current_block_lang)
+
+    consume_block_lines(file_enum) do |line|
+      consumed_lines << line
+    end
+
+    consume_dalibo_link_if_present(file_enum, consumed_lines)
+    consume_flamegraph_link_if_present(file_enum, consumed_lines)
+  end
+
+
+  def consume_block_lines(file_enum)
+    begin
+      loop do
+        result_block_line = file_enum.next
+        yield result_block_line
+        break if is_block_end?(result_block_line)
+      end
+    rescue StopIteration
+      warn "Warning: End of file reached while consuming result block."
+    end
+  end
+end

data/markdown-run-sample.md

@@ -76,3 +76,12 @@ Page cache spills:                   0
 Schema Heap Usage:                   0 bytes
 Statement Heap/Lookaside Usage:      0 bytes
 ```
+
+```psql rerun flamegraph
+select 42 as answer;
+```
+
+```RESULT
+![PostgreSQL Query Flamegraph](pg-flamegraph-20250604-222931.svg)
+```
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - Aurélien Bottazini
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-03 00:00:00.000000000 Z
+date: 2025-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcodetools
@@ -24,6 +24,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.8.5
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -84,16 +98,21 @@ files:
 - README.md
 - Rakefile
 - exe/markdown-run
+- lib/code_block_helper.rb
 - lib/code_block_parser.rb
 - lib/code_executor.rb
+- lib/dalibo_helper.rb
 - lib/enum_helper.rb
 - lib/execution_decider.rb
+- lib/flamegraph_helper.rb
 - lib/frontmatter_parser.rb
 - lib/language_configs.rb
 - lib/markdown/run/version.rb
 - lib/markdown_file_writer.rb
 - lib/markdown_processor.rb
 - lib/markdown_run.rb
+- lib/pg_flamegraph_svg.rb
+- lib/result_helper.rb
 - markdown-run-sample.md
 homepage: https://github.com/aurelienbottazini/markdown-run
 licenses: