markdown-run 0.1.11 → 0.2.0

data/lib/execution_decider.rb

@@ -3,17 +3,23 @@ require_relative "enum_helper"
 class ExecutionDecider
   include EnumHelper
 
-  def initialize(current_block_run, current_block_rerun, current_block_lang, current_block_explain = false, current_block_result = true)
+  def initialize(current_block_run, current_block_rerun, current_block_lang, current_block_explain = false, current_block_flamegraph = false, current_block_result = true)
     @current_block_run = current_block_run
     @current_block_rerun = current_block_rerun
     @current_block_lang = current_block_lang
     @current_block_explain = current_block_explain
+    @current_block_flamegraph = current_block_flamegraph
     @current_block_result = current_block_result
   end
 
-  def decide(file_enum, result_block_regex_method)
+  def decide(file_enum, result_block_regex_method, code_content = nil)
     return skip_execution_run_false if run_disabled?
 
+    # For ruby blocks, check if code content contains xmpfilter results (# >>)
+    if is_ruby_block? && code_content && has_xmpfilter_results?(code_content)
+      return handle_inline_ruby_results
+    end
+
     expected_header_regex = result_block_regex_method.call(@current_block_lang)
     peek1 = peek_next_line(file_enum)
 
@@ -21,8 +27,10 @@ class ExecutionDecider
       handle_immediate_result_block(file_enum)
     elsif is_blank_line?(peek1)
       handle_blank_line_scenario(file_enum, expected_header_regex)
-    elsif @current_block_explain && is_dalibo_link?(peek1)
+    elsif (@current_block_explain || @current_block_flamegraph) && is_dalibo_link?(peek1)
       handle_immediate_dalibo_link(file_enum)
+    elsif @current_block_flamegraph && is_flamegraph_link?(peek1)
+      handle_immediate_flamegraph_link(file_enum)
     else
       execute_without_existing_result
     end
@@ -48,11 +56,11 @@ class ExecutionDecider
 
   def handle_blank_line_scenario(file_enum, expected_header_regex)
     consumed_blank_line = file_enum.next
-    
+
     # Look ahead past multiple blank lines to find actual content
     peek2 = peek_next_line(file_enum)
     additional_blanks = []
-    
+
     # Consume consecutive blank lines
     while is_blank_line?(peek2)
       additional_blanks << file_enum.next
@@ -61,8 +69,10 @@ class ExecutionDecider
 
     if line_matches_pattern?(peek2, expected_header_regex)
       handle_result_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
-    elsif @current_block_explain && is_dalibo_link?(peek2)
+    elsif (@current_block_explain || @current_block_flamegraph) && is_dalibo_link?(peek2)
       handle_dalibo_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    elsif @current_block_flamegraph && is_flamegraph_link?(peek2)
+      handle_flamegraph_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
     else
       execute_with_blank_lines(consumed_blank_line, additional_blanks)
     end
@@ -194,7 +204,7 @@ class ExecutionDecider
     # Consume all consecutive Dalibo links and blank lines
     loop do
       next_line = peek_next_line(file_enum)
-      
+
       if is_blank_line?(next_line) || is_dalibo_link?(next_line)
         consumed_line = file_enum.next
         consumed_lines << consumed_line
@@ -205,7 +215,7 @@ class ExecutionDecider
   end
 
   def is_dalibo_link?(line)
-    line&.start_with?("**Dalibo Visualization:**")
+    line&.start_with?("[Dalibo]")
   end
 
   def line_matches_pattern?(line, pattern)
@@ -217,9 +227,97 @@ class ExecutionDecider
   end
 
   def should_auto_replace_dalibo_link?
-    # Auto-replace Dalibo links when using explain with result=false
+    # Auto-replace Dalibo links when using explain or flamegraph with result=false
     # This makes sense because with result=false, there's only a Dalibo link,
     # so it should be updated on each run
-    @current_block_explain && !@current_block_result
+    (@current_block_explain || @current_block_flamegraph) && !@current_block_result
+  end
+
+  def is_flamegraph_link?(line)
+    line&.start_with?("![PostgreSQL Query Flamegraph]")
+  end
+
+  def handle_flamegraph_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    # For flamegraph result=false, always replace existing flamegraph links
+    # For flamegraph result=true, follow normal rerun logic
+    if should_auto_replace_flamegraph_link? || @current_block_rerun
+      execute_with_consumed_flamegraph_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    else
+      skip_with_blanks_and_flamegraph(file_enum, consumed_blank_line, additional_blanks)
+    end
+  end
+
+  def handle_immediate_flamegraph_link(file_enum)
+    # For flamegraph result=false, always replace existing flamegraph links
+    # For flamegraph result=true, follow normal rerun logic
+    if should_auto_replace_flamegraph_link? || @current_block_rerun
+      execute_with_consumed_flamegraph(file_enum)
+    else
+      skip_with_existing_flamegraph(file_enum)
+    end
+  end
+
+  def execute_with_consumed_flamegraph(file_enum)
+    consumed_lines = []
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, consume_existing_flamegraph: true }
+  end
+
+  def skip_with_existing_flamegraph(file_enum)
+    consumed_lines = []
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, flamegraph_content: true }
+  end
+
+  def execute_with_consumed_flamegraph_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line, consume_existing_flamegraph: true }
+  end
+
+  def skip_with_blanks_and_flamegraph(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, flamegraph_content: true }
+  end
+
+  def consume_flamegraph_links(file_enum, consumed_lines)
+    # Consume all consecutive flamegraph links and blank lines
+    loop do
+      next_line = peek_next_line(file_enum)
+
+      if is_blank_line?(next_line) || is_flamegraph_link?(next_line)
+        consumed_line = file_enum.next
+        consumed_lines << consumed_line
+      else
+        break
+      end
+    end
+  end
+
+  def should_auto_replace_flamegraph_link?
+    # Auto-replace flamegraph links when using flamegraph with result=false
+    # This makes sense because with result=false, there's only a flamegraph link,
+    # so it should be updated on each run
+    @current_block_flamegraph && !@current_block_result
+  end
+
+  def is_ruby_block?
+    @current_block_lang == "ruby"
+  end
+
+  def has_xmpfilter_results?(code_content)
+    # Check if code contains xmpfilter comment markers (# >>)
+    code_content.include?("# >>")
+  end
+
+  def handle_inline_ruby_results
+    if @current_block_rerun
+      # Rerun requested, so execute and replace inline results
+      { execute: true }
+    else
+      # Has inline results and rerun not requested, skip execution
+      { execute: false, lines_to_pass_through: [] }
+    end
   end
 end

data/lib/flamegraph_helper.rb

@@ -0,0 +1,39 @@
+module FlamegraphHelper
+  private
+
+  FLAMEGRAPH_LINK_PREFIX = "FLAMEGRAPH_LINK:"
+
+  def extract_flamegraph_link(result_output)
+    # Check if the result contains a flamegraph link marker
+    if result_output.start_with?(FLAMEGRAPH_LINK_PREFIX)
+      lines = result_output.split("\n", 2)
+      flamegraph_path = lines[0].sub(FLAMEGRAPH_LINK_PREFIX, "")
+      clean_result = lines[1] || ""
+      flamegraph_link = "![PostgreSQL Query Flamegraph](#{flamegraph_path})"
+      [flamegraph_link, clean_result]
+    else
+      [nil, result_output]
+    end
+  end
+
+  def consume_flamegraph_link_if_present(file_enum, consumed_lines)
+    # Look ahead to see if there are flamegraph links after the result block
+    begin
+      # Keep consuming blank lines and flamegraph links until we hit something else
+      loop do
+        next_line = peek_next_line(file_enum)
+
+        if is_blank_line?(next_line)
+          consumed_lines << file_enum.next
+        elsif next_line&.start_with?("![PostgreSQL Query Flamegraph]")
+          consumed_lines << file_enum.next
+        else
+          # Hit something that's not a blank line or flamegraph link, stop consuming
+          break
+        end
+      end
+    rescue StopIteration
+      # End of file reached, nothing more to consume
+    end
+  end
+end

data/lib/frontmatter_parser.rb

@@ -1,16 +1,22 @@
 require "yaml"
 require_relative "enum_helper"
+require_relative "language_resolver"
+require_relative "test_silencer"
 
 class FrontmatterParser
   include EnumHelper
 
-  def initialize
-    @aliases = {}
+  def initialize(language_resolver = nil)
+    @language_resolver = language_resolver || LanguageResolver.new
     @defaults = {}
     @language_defaults = {}
   end
 
-  attr_reader :aliases, :defaults, :language_defaults
+  attr_reader :defaults, :language_defaults
+
+  def language_resolver
+    @language_resolver
+  end
 
   def parse_frontmatter(file_enum, output_lines)
     first_line = peek_next_line(file_enum)
@@ -21,7 +27,7 @@ class FrontmatterParser
   end
 
   def resolve_language(lang)
-    @aliases[lang] || lang
+    @language_resolver.resolve_language(lang)
   end
 
   def get_default_value(option_name, language, fallback_default)
@@ -72,7 +78,7 @@ class FrontmatterParser
       frontmatter = YAML.safe_load(frontmatter_lines.join)
       extract_aliases(frontmatter) if frontmatter.is_a?(Hash)
     rescue YAML::SyntaxError => e
-      warn "Warning: Invalid YAML frontmatter: #{e.message}"
+      TestSilencer.warn_unless_testing "Warning: Invalid YAML frontmatter: #{e.message}"
     end
   end
 
@@ -83,13 +89,15 @@ class FrontmatterParser
     # Extract aliases
     aliases = markdown_run_config["alias"]
     if aliases.is_a?(Array)
+      new_aliases = {}
       aliases.each do |alias_config|
         next unless alias_config.is_a?(Hash)
 
         alias_config.each do |alias_name, target_lang|
-          @aliases[alias_name.to_s] = target_lang.to_s
+          new_aliases[alias_name.to_s] = target_lang.to_s
         end
       end
+      @language_resolver.update_aliases(new_aliases)
     end
 
     # Extract defaults

data/lib/language_configs.rb

@@ -1,7 +1,9 @@
-require 'securerandom'
+require "securerandom"
+require_relative "test_silencer"
+require_relative "postgres_helper"
 
 JS_CONFIG = {
-  command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+  command: proc { |temp_file_path: nil, **|
     # Check if bun is available
     bun_exists = system("command -v bun > /dev/null 2>&1")
     if bun_exists
@@ -16,35 +18,41 @@ JS_CONFIG = {
 }.freeze
 
 SQLITE_CONFIG = {
-  command: ->(code_content, temp_file_path, input_file_path = nil, explain = false) { [ "sqlite3 #{temp_file_path}", { stdin_data: code_content } ] },
+  command: proc { |code_content: nil, temp_file_path: nil, **| [ "sqlite3 #{temp_file_path}", { stdin_data: code_content } ] },
   temp_file_suffix: ".db" # Temp file is the database
 }.freeze
 
 SUPPORTED_LANGUAGES = {
   "psql" => {
-    command: ->(code_content, _temp_file_path, input_file_path = nil, explain = false) {
-      psql_exists = system("command -v psql > /dev/null 2>&1")
-      unless psql_exists
-        abort "Error: psql command not found. Please install PostgreSQL or ensure psql is in your PATH."
+    command: proc { |code_content: nil, explain: false, flamegraph: false, **|
+      unless PostgresHelper.available?
+        if PostgresHelper.psql_command && PostgresHelper.using_docker?
+          TestSilencer.abort_unless_testing "Error: PostgreSQL is running in Docker but required environment variables (PGUSER, PGDATABASE) are not set. Please set these variables before running psql commands."
+        else
+          TestSilencer.abort_unless_testing "Error: psql command not found. Please install PostgreSQL locally, ensure psql is in your PATH, or run PostgreSQL in a Docker container."
+        end
       end
 
-      # Modify the SQL query if explain option is enabled
-      if explain
+      PostgresHelper.validate_env_vars!
+      psql_cmd = PostgresHelper.psql_command
+
+      # Modify the SQL query if explain or flamegraph option is enabled
+      if explain || flamegraph
         # Wrap the query with EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
         # Remove any trailing semicolons and whitespace, then add our EXPLAIN wrapper
-        clean_query = code_content.strip.gsub(/;\s*$/, '')
+        clean_query = code_content.strip.gsub(/;\s*$/, "")
         explained_query = "EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) #{clean_query};"
-        [ "psql -A -t -X", { stdin_data: explained_query } ]
+        [ "#{psql_cmd} -A -t -X", { stdin_data: explained_query } ]
       else
-        [ "psql -A -t -X", { stdin_data: code_content } ]
+        [ "#{psql_cmd} -A -t -X", { stdin_data: code_content } ]
       end
     }
   },
   "ruby" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: proc { |temp_file_path: nil, **|
       xmpfilter_exists = system("command -v xmpfilter > /dev/null 2>&1")
       unless xmpfilter_exists
-        abort "Error: xmpfilter command not found. Please install xmpfilter or ensure it is in your PATH."
+        TestSilencer.abort_unless_testing "Error: xmpfilter command not found. Please install xmpfilter or ensure it is in your PATH."
       end
       [ "xmpfilter #{temp_file_path}", {} ]
     },
@@ -57,40 +65,40 @@ SUPPORTED_LANGUAGES = {
   "sqlite" => SQLITE_CONFIG,
   "sqlite3" => SQLITE_CONFIG, # Alias for sqlite
   "bash" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: proc { |temp_file_path: nil, **|
       bash_exists = system("command -v bash > /dev/null 2>&1")
       unless bash_exists
-        abort "Error: bash command not found. Please ensure bash is in your PATH."
+        TestSilencer.abort_unless_testing "Error: bash command not found. Please ensure bash is in your PATH."
       end
       [ "bash #{temp_file_path}", {} ]
     },
     temp_file_suffix: ".sh"
   },
   "zsh" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: proc { |temp_file_path: nil, **|
       zsh_exists = system("command -v zsh > /dev/null 2>&1")
       unless zsh_exists
-        abort "Error: zsh command not found. Please ensure zsh is in your PATH."
+        TestSilencer.abort_unless_testing "Error: zsh command not found. Please ensure zsh is in your PATH."
       end
       [ "zsh #{temp_file_path}", {} ]
     },
     temp_file_suffix: ".zsh"
   },
   "sh" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: proc { |temp_file_path: nil, **|
       sh_exists = system("command -v sh > /dev/null 2>&1")
       unless sh_exists
-        abort "Error: sh command not found. Please ensure sh is in your PATH."
+        TestSilencer.abort_unless_testing "Error: sh command not found. Please ensure sh is in your PATH."
       end
       [ "sh #{temp_file_path}", {} ]
     },
     temp_file_suffix: ".sh"
   },
   "mermaid" => {
-    command: ->(code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: proc { |temp_file_path: nil, input_file_path: nil, **|
       mmdc_exists = system("command -v mmdc > /dev/null 2>&1")
       unless mmdc_exists
-        abort "Error: mmdc command not found. Please install @mermaid-js/mermaid-cli: npm install -g @mermaid-js/mermaid-cli"
+        TestSilencer.abort_unless_testing "Error: mmdc command not found. Please install @mermaid-js/mermaid-cli: npm install -g @mermaid-js/mermaid-cli"
       end
 
       # Generate SVG output file path with directory structure based on markdown file

data/lib/language_resolver.rb

@@ -0,0 +1,17 @@
+class LanguageResolver
+  def initialize(aliases = {})
+    @aliases = aliases
+  end
+
+  def resolve_language(lang)
+    @aliases[lang] || lang
+  end
+
+  def update_aliases(new_aliases)
+    @aliases.merge!(new_aliases)
+  end
+
+  def get_aliases
+    @aliases.dup
+  end
+end

data/lib/markdown/run/version.rb

@@ -2,6 +2,6 @@
 
 module Markdown
   module Run
-    VERSION = "0.1.11"
+    VERSION = "0.2.0"
   end
 end

data/lib/markdown_file_writer.rb

@@ -1,7 +1,9 @@
 require "tempfile"
 require "fileutils"
+require_relative "test_silencer"
 
 class MarkdownFileWriter
+
   def self.write_output_to_file(output_lines, input_file_path)
     temp_dir = File.dirname(File.expand_path(input_file_path))
 
@@ -13,13 +15,14 @@ class MarkdownFileWriter
       begin
         FileUtils.mv(temp_output_file.path, input_file_path)
       rescue Errno::EACCES, Errno::EXDEV
-        warn "Atomic move failed. Falling back to copy and delete."
+        TestSilencer.warn_unless_testing "Atomic move failed. Falling back to copy and delete."
         FileUtils.cp(temp_output_file.path, input_file_path)
         FileUtils.rm_f(temp_output_file.path)
       end
     end
 
-    warn "Markdown processing complete. Output written to #{input_file_path}"
+    # Only show the warning message if we're not running tests
+    TestSilencer.warn_unless_testing("Markdown processing complete. Output written to #{input_file_path}")
     true # Indicate success
   end
 end

data/lib/markdown_processor.rb

@@ -1,4 +1,5 @@
 require_relative "language_configs"
+require_relative "language_resolver"
 require_relative "frontmatter_parser"
 require_relative "code_block_parser"
 require_relative "code_executor"
@@ -20,8 +21,9 @@ class MarkdownProcessor
     @output_lines = []
     reset_code_block_state
 
-    @frontmatter_parser = FrontmatterParser.new
-    @code_block_parser = CodeBlockParser.new(@frontmatter_parser)
+    @language_resolver = LanguageResolver.new
+    @frontmatter_parser = FrontmatterParser.new(@language_resolver)
+    @code_block_parser = CodeBlockParser.new(@frontmatter_parser, @language_resolver)
   end
 
   def process_file(file_enum)
@@ -38,9 +40,7 @@ class MarkdownProcessor
 
   private
 
-  def resolve_language(lang)
-    @frontmatter_parser.resolve_language(lang)
-  end
+
 
   def is_block_end?(line)
     @code_block_parser.is_block_end?(line)