markdown-run 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2764390f72c90c38bd4862f78db857bd5585d13e59f1a2c87a3a9c67c2f66529
-  data.tar.gz: 95caace78ee0db7d12ac3a6a7a5a9abcddf32c1e946ff3d9cf71beed12c89a91
+  metadata.gz: 72c9c060b9169413ee686c9a4958b36b11d5271a4222d598bfe0c847364488e0
+  data.tar.gz: 56bfea5eb072bfbf7db692a6df64c08e901f7a77551f2b17491a4a84201220fb
 SHA512:
-  metadata.gz: 90aea8dd4f03bc75969643bedd914ed2a8a8a1b45adf777d51fdfabb60deefd5e36cd1b73ac37225848b4663e12872a69c2ba4c3624029ac4c81c333a8eb6a8c
-  data.tar.gz: 7dfc12cda3abca94774e013904e2d9853713dce9c8b4059d6ca6bd90319ddff4f9f0d826c230d508f2438fdce57626f7868c1b94c9756ec3a122e0645be2121c
+  metadata.gz: f4b2c6aa7b3fec529749f56e4a64c186060097b94f64678c96742759d51f4b7dbb1d2014c98abb4ff047f8ba62ef15d1f32612e2b19cbdafa480664f3556a420
+  data.tar.gz: a7bb6b114beaea5f0857534cee766f9dcb157ab39949f433a5965acb558996f30a3fcbd6a13a3df3a264ddf64b1115dab089af7b674b68195467b7a2e482ef5f

data/.tool-versions

@@ -1 +1 @@
-ruby 3.3.5
+ruby 3.4.6

data/README.md

@@ -55,6 +55,16 @@ example vscode keybinding
 
 ### Code block options
 
+Options are specified using Pandoc-style curly braces after the language identifier:
+
+```markdown
+```ruby {rerun=true}
+puts "Hello World"
+```
+```
+
+**Available options:**
+
 - `run=true` or `run=false` to control whether a code block should be executed at all. `run=true` is the default if not specified
 - `rerun=true` or `rerun=false` to control whether a code block should be re-executed if a result block already exists. `rerun=false` is the default if not specified
 - `result=true` or `result=false` to control whether the result block should be displayed after execution. `result=true` is the default if not specified. When `result=false`, the code still executes but the result block is hidden
@@ -77,31 +87,31 @@ Explicit assignments (e.g., `run=false`) take precedence over standalone options
 
 Examples:
 
-```js run=false
+```js {run=false}
 console.log("This will not execute at all");
 ```
 
-```js rerun
+```js {rerun}
 console.log("This will re-execute even if result exists");
 ```
 
-```js run=true rerun=false
+```js {run=true rerun=false}
 console.log("This will execute only if no result exists");
 ```
 
-```ruby result=false run
+```ruby {result=false run}
 puts "This executes but the result block is hidden"
 ```
 
-```psql explain
+```psql {explain}
 SELECT * FROM users WHERE id = 1;
 ```
 
-```psql explain=true
+```psql {explain=true}
 EXPLAIN (ANALYZE) SELECT * FROM large_table;
 ```
 
-```psql flamegraph
+```psql {flamegraph}
 SELECT u.name, COUNT(o.id) as order_count
 FROM users u
 LEFT JOIN orders o ON u.id = o.user_id
@@ -111,12 +121,12 @@ ORDER BY order_count DESC
 LIMIT 10;
 ```
 
-```psql flamegraph=true result=false
+```psql {flamegraph=true result=false}
 -- This will generate a flamegraph but hide the JSON result block
 SELECT * FROM complex_query_with_joins;
 ```
 
-```psql result=false explain
+```psql {result=false explain}
 SELECT * FROM large_table;
 -- This will execute the explain query and show the Dalibo link but hide the result block
 ```
@@ -125,7 +135,7 @@ SELECT * FROM large_table;
 
 PostgreSQL flamegraph blocks generate interactive SVG flamegraphs from query execution plans:
 
-```psql flamegraph
+```psql {flamegraph}
 SELECT users.*, orders.total
 FROM users
 JOIN orders ON users.id = orders.user_id

data/Rakefile

@@ -1,3 +1,4 @@
+require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
@@ -19,6 +20,44 @@ task :flog_detailed do
   system("flog -d lib/ exe/ test/")
 end
 
+desc "Run tests with detailed timing information"
+task :test_profile do
+  require 'benchmark'
+  
+  puts "Running tests with detailed profiling..."
+  
+  # Run tests with verbose output and capture timing
+  output = `bundle exec rake test TESTOPTS="-v" 2>&1`
+  
+  # Extract test timings
+  timings = []
+  output.scan(/^(.+) = ([0-9]+\.[0-9]+) s = \.$/) do |test_name, time|
+    timings << [test_name, time.to_f]
+  end
+  
+  # Sort by time (descending)
+  timings.sort_by! { |_, time| -time }
+  
+  puts "\n" + "="*80
+  puts "TOP 15 SLOWEST TESTS"
+  puts "="*80
+  
+  timings.first(15).each_with_index do |(test_name, time), index|
+    test_display = test_name.length > 60 ? test_name[0...60] + "..." : test_name
+    printf "%2d. %-63s %6.2f s\n", index + 1, test_display, time
+  end
+  
+  puts "\n" + "="*80
+  puts "SUMMARY"
+  puts "="*80
+  total_time = timings.sum { |_, time| time }
+  slow_tests = timings.select { |_, time| time > 0.1 }
+  
+  puts "Total test time: #{total_time.round(2)} seconds"
+  puts "Tests slower than 0.1s: #{slow_tests.count}"
+  puts "Time spent in slow tests: #{slow_tests.sum { |_, time| time }.round(2)} seconds (#{((slow_tests.sum { |_, time| time } / total_time) * 100).round(1)}%)"
+end
+
 desc "Release"
 task :release do
   `gem bump`
@@ -29,4 +68,19 @@ task :release do
   `gem release`
 end
 
+# Coverage task
+desc "Run tests with SimpleCov coverage report"
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task[:test].invoke
+
+  puts "\n🎯 Coverage Report Generated!"
+  puts "📊 Open coverage/index.html to view detailed coverage report"
+
+  # Try to open coverage report automatically (works on macOS)
+  if RUBY_PLATFORM.include?('darwin')
+    system('open coverage/index.html')
+  end
+end
+
 task default: :test

data/lib/code_block_helper.rb

@@ -17,7 +17,7 @@ module CodeBlockHelper
 
   def start_code_block(current_line, lang, options_string = nil)
     @output_lines << current_line
-    @current_block_lang = resolve_language(lang)
+    @current_block_lang = @language_resolver.resolve_language(lang)
     @current_block_rerun = @code_block_parser.parse_rerun_option(options_string, @current_block_lang)
     @current_block_run = @code_block_parser.parse_run_option(options_string, @current_block_lang)
     @current_block_explain = @code_block_parser.parse_explain_option(options_string, @current_block_lang)
@@ -29,19 +29,25 @@ module CodeBlockHelper
 
   def accumulate_code_content(current_line)
     @current_code_content += current_line
-    @output_lines << current_line
+    # For ruby blocks, don't output code content yet - we'll replace it with xmpfilter output
+    unless ruby_style_result?(@current_block_lang)
+      @output_lines << current_line
+    end
   end
 
   def end_code_block(current_line, file_enum)
-    @output_lines << current_line
+    # For ruby blocks, don't output closing ``` yet - we'll add it after the xmpfilter output
+    unless ruby_style_result?(@current_block_lang)
+      @output_lines << current_line
+    end
 
     decision = decide_execution(file_enum)
 
     if decision[:execute]
       # If we consumed lines for rerun, don't add them to output (they'll be replaced)
-      execute_and_add_result(decision[:blank_line])
+      execute_and_add_result(decision[:blank_line], current_line)
     else
-      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum, decision)
+      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum, decision, current_line)
     end
 
     reset_code_block_state
@@ -49,7 +55,7 @@ module CodeBlockHelper
 
   def decide_execution(file_enum)
     decider = ExecutionDecider.new(@current_block_run, @current_block_rerun, @current_block_lang, @current_block_explain, @current_block_flamegraph, @current_block_result)
-    decision = decider.decide(file_enum, method(:result_block_regex))
+    decision = decider.decide(file_enum, method(:result_block_regex), @current_code_content)
 
     # Handle the consume_existing flag for rerun scenarios
     if decision[:consume_existing]

data/lib/code_block_parser.rb

@@ -1,13 +1,15 @@
 require_relative "language_configs"
 
 class CodeBlockParser
-  # Code block header pattern: ```language options
-  CODE_BLOCK_START_PATTERN = /^```(\w+)(?:\s+(.*))?$/i
+  # Code block header pattern: ```language {options}
+  # Supports both ```language and ```language {options} formats
+  CODE_BLOCK_START_PATTERN = /^```(\w+)(?:\s*\{(.*)\})?$/i
   RUBY_RESULT_BLOCK_PATTERN = /^```ruby\s+RESULT$/i
   BLOCK_END_PATTERN = "```"
 
-  def initialize(frontmatter_parser)
+  def initialize(frontmatter_parser, language_resolver)
     @frontmatter_parser = frontmatter_parser
+    @language_resolver = language_resolver
   end
 
   def parse_code_block_header(line)
@@ -62,7 +64,7 @@ class CodeBlockParser
   private
 
   def resolve_language(lang)
-    @frontmatter_parser.resolve_language(lang)
+    @language_resolver.resolve_language(lang)
   end
 
   def parse_boolean_option(options_string, option_name, default_value)

data/lib/code_executor.rb

@@ -1,6 +1,7 @@
 require "tempfile"
 require "open3"
 require_relative "language_configs"
+require_relative "test_silencer"
 
 class CodeExecutor
   def self.execute(code_content, lang, temp_dir, input_file_path = nil, explain = false, flamegraph = false)
@@ -13,7 +14,7 @@ class CodeExecutor
 
     return handle_unsupported_language(lang) unless lang_config
 
-    warn "Executing #{lang_key} code block..."
+    TestSilencer.warn_unless_testing("Executing #{lang_key} code block...")
 
     result = execute_with_config(code_content, lang_config, temp_dir, lang_key, input_file_path, explain, flamegraph)
     process_execution_result(result, lang_config, lang_key, explain, flamegraph)
@@ -26,7 +27,7 @@ class CodeExecutor
   end
 
   def handle_unsupported_language(lang)
-    warn "Unsupported language: #{lang}"
+    TestSilencer.warn_unless_testing "Unsupported language: #{lang}"
     "ERROR: Unsupported language: #{lang}"
   end
 
@@ -46,7 +47,13 @@ class CodeExecutor
     Tempfile.create([lang_key, temp_file_suffix], temp_dir) do |temp_file|
       temp_file.write(code_content)
       temp_file.close
-      command_to_run, exec_options = cmd_lambda.call(code_content, temp_file.path, input_file_path, explain, flamegraph)
+      command_to_run, exec_options = cmd_lambda.call(**{
+        code_content: code_content,
+        temp_file_path: temp_file.path,
+        input_file_path: input_file_path,
+        explain: explain,
+        flamegraph: flamegraph
+      })
 
       # Extract output_path if present (for mermaid)
       output_path = exec_options.delete(:output_path) if exec_options.is_a?(Hash)
@@ -64,7 +71,13 @@ class CodeExecutor
   end
 
   def execute_direct_command(code_content, cmd_lambda, input_file_path = nil, explain = false, flamegraph = false)
-    command_to_run, exec_options = cmd_lambda.call(code_content, nil, input_file_path, explain, flamegraph)
+    command_to_run, exec_options = cmd_lambda.call(**{
+      code_content: code_content,
+      temp_file_path: nil,
+      input_file_path: input_file_path,
+      explain: explain,
+      flamegraph: flamegraph
+    })
     captured_stdout, captured_stderr, captured_status_obj = Open3.capture3(command_to_run, **exec_options)
     { stdout: captured_stdout, stderr: captured_stderr, status: captured_status_obj, input_file_path: input_file_path }
   end
@@ -104,8 +117,8 @@ class CodeExecutor
   end
 
   def add_error_to_output(exit_status, lang_config, lang_key, result_output, stderr_output)
-    warn "Code execution failed for language '#{lang_key}' with status #{exit_status}."
-    warn "Stderr:\n#{stderr_output}" if stderr_has_content?(stderr_output)
+    TestSilencer.warn_unless_testing "Code execution failed for language '#{lang_key}' with status #{exit_status}."
+    TestSilencer.warn_unless_testing "Stderr:\n#{stderr_output}" if stderr_has_content?(stderr_output)
 
     is_js_error_already_formatted = lang_config && lang_config[:error_handling] == :js_specific && result_output.include?("Stderr:")
     unless result_output.downcase.include?("error:") || is_js_error_already_formatted
@@ -116,15 +129,11 @@ class CodeExecutor
     result_output
   end
 
-  def stderr_has_content?(stderr_output)
-    stderr_output && !stderr_output.strip.empty?
-  end
-
   def handle_mermaid_svg_result(result, lang_key)
     output_path = result[:output_path]
 
     unless output_path && File.exist?(output_path)
-      warn "Warning: Mermaid SVG file not generated at expected path: #{output_path}"
+      TestSilencer.warn_unless_testing "Warning: Mermaid SVG file not generated at expected path: #{output_path}"
       return "Error: SVG file not generated"
     end
 
@@ -143,7 +152,7 @@ class CodeExecutor
       relative_path = svg_filename
     end
 
-    warn "Generated Mermaid SVG: #{relative_path}"
+    TestSilencer.warn_unless_testing("Generated Mermaid SVG: #{relative_path}")
 
     # Return markdown image tag instead of typical result content
     "![Mermaid Diagram](#{relative_path})"
@@ -225,7 +234,7 @@ class CodeExecutor
         relative_path = File.basename(output_path)
       end
 
-      warn "Generated PostgreSQL flamegraph: #{relative_path}"
+      TestSilencer.warn_unless_testing("Generated PostgreSQL flamegraph: #{relative_path}")
 
       # Return a special format that the markdown processor can parse
       # Preserve any existing Dalibo link prefix
@@ -239,10 +248,10 @@ class CodeExecutor
       end
 
     rescue JSON::ParserError => e
-      warn "Error parsing EXPLAIN JSON: #{e.message}"
+      TestSilencer.warn_unless_testing "Error parsing EXPLAIN JSON: #{e.message}"
       result_output
     rescue => e
-      warn "Error generating flamegraph: #{e.message}"
+      TestSilencer.warn_unless_testing "Error generating flamegraph: #{e.message}"
       result_output
     end
   end
@@ -279,11 +288,11 @@ class CodeExecutor
           nil
         end
       else
-        warn "Failed to submit plan to Dalibo: #{response.code} #{response.message}"
+        TestSilencer.warn_unless_testing "Failed to submit plan to Dalibo: #{response.code} #{response.message}"
         nil
       end
     rescue => e
-      warn "Error submitting plan to Dalibo: #{e.message}"
+      TestSilencer.warn_unless_testing "Error submitting plan to Dalibo: #{e.message}"
       nil
     end
   end

data/lib/execution_decider.rb

@@ -12,9 +12,14 @@ class ExecutionDecider
     @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)
 
@@ -296,4 +301,23 @@ class ExecutionDecider
     # 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/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, flamegraph = 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, flamegraph = 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, flamegraph = 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
 
+      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, flamegraph = 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, flamegraph = 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, flamegraph = 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, flamegraph = 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, flamegraph = 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.12"
+    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)

data/lib/postgres_helper.rb

@@ -0,0 +1,94 @@
+require_relative "test_silencer"
+
+module PostgresHelper
+  class << self
+    def psql_command
+      @psql_command ||= detect_psql_command
+    end
+
+    def available?
+      return false if psql_command.nil?
+
+      # If using Docker, check required env vars are present
+      if using_docker?
+        has_required_env_vars?
+      else
+        true
+      end
+    end
+
+    def using_docker?
+      cmd = psql_command
+      cmd && cmd.start_with?("docker exec")
+    end
+
+    # Reset cached command detection (for tests)
+    def reset_cache!
+      @psql_command = nil
+    end
+
+    def validate_env_vars!
+      return unless using_docker?
+
+      required_vars = ["PGUSER", "PGDATABASE"]
+      missing_vars = required_vars.reject { |var| ENV[var] }
+
+      if missing_vars.any?
+        TestSilencer.abort_unless_testing "Error: PostgreSQL is running in Docker but required environment variables are missing: #{missing_vars.join(", ")}. Please set these variables before running psql commands."
+      end
+    end
+
+    private
+
+    def has_required_env_vars?
+      required_vars = ["PGUSER", "PGDATABASE"]
+      required_vars.all? { |var| ENV[var] }
+    end
+
+    def detect_psql_command
+      # Check if psql is available locally
+      return "psql" if system("command -v psql > /dev/null 2>&1")
+
+      # Check if docker is available
+      return nil unless system("command -v docker > /dev/null 2>&1")
+
+      # Find running postgres container
+      container_id = find_postgres_container
+      return nil if container_id.nil? || container_id.empty?
+
+      # Build docker exec command with environment variables passed through
+      env_vars = build_env_vars
+      "docker exec -i -u postgres #{env_vars}#{container_id} psql"
+    end
+
+    def build_env_vars
+      # Pass through PostgreSQL environment variables if they exist
+      pg_env_vars = [ "PGUSER", "PGPASSWORD", "PGDATABASE", "PGHOST", "PGPORT" ]
+      env_flags = pg_env_vars.map do |var|
+        value = ENV[var]
+        "-e #{var}=\"#{value}\" " if value
+      end.compact.join
+      env_flags.empty? ? "" : "#{env_flags} "
+    end
+
+    def find_postgres_container
+      # Try to find a running postgres container
+      # First, check for container with postgres in the name
+      output = `docker ps --filter "ancestor=postgres" --format "{{.ID}}" 2>/dev/null`.strip
+      return output.split("\n").first unless output.empty?
+
+      # Alternative: check for containers with "postgres" in name
+      output = `docker ps --filter "name=postgres" --format "{{.ID}}" 2>/dev/null`.strip
+      return output.split("\n").first unless output.empty?
+
+      # Last resort: check if any running container has psql command
+      containers = `docker ps --format "{{.ID}}" 2>/dev/null`.strip.split("\n")
+      containers.each do |container_id|
+        has_psql = system("docker exec #{container_id} which psql > /dev/null 2>&1")
+        return container_id if has_psql
+      end
+
+      nil
+    end
+  end
+end

data/lib/result_helper.rb

@@ -1,4 +1,5 @@
 require_relative "flamegraph_helper"
+require_relative "test_silencer"
 
 module ResultHelper
   include FlamegraphHelper
@@ -16,7 +17,7 @@ module ResultHelper
   end
 
   def result_block_header(lang)
-    ruby_style_result?(lang) ? "```ruby RESULT\n" : "```RESULT\n"
+    ruby_style_result?(lang) ? "```ruby\n" : "``` {result}\n"
   end
 
   def result_block_regex(lang)
@@ -24,14 +25,21 @@ module ResultHelper
       # For mermaid, look for existing image tags with .svg extension
       /^!\[.*\]\(.*\.svg\)$/i
     elsif ruby_style_result?(lang)
+      # For ruby, check for old-style ```ruby RESULT blocks (for backward compatibility during migration)
       /^```ruby\s+RESULT$/i
     else
-      /^```RESULT$/i
+      /^```\s*\{result\}$/i
     end
   end
 
-  def add_result_block(result_output, blank_line_before_new_result)
-    if mermaid_style_result?(@current_block_lang)
+  def add_result_block(result_output, blank_line_before_new_result, closing_line = nil)
+    if ruby_style_result?(@current_block_lang)
+      # For ruby, replace the code block content with xmpfilter output
+      @output_lines << result_output
+      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
+      @output_lines << (closing_line || "```\n")
+      @output_lines << "\n"
+    elsif 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
@@ -55,16 +63,17 @@ module ResultHelper
   end
 
   def handle_existing_ruby_result_block(current_line, file_enum)
-    warn "Found existing '```ruby RESULT' block, passing through."
+    TestSilencer.warn_unless_testing("Found existing '```ruby RESULT' or '```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)
+  def execute_and_add_result(blank_line_before_new_result, closing_line = nil)
+      TestSilencer.warn_unless_testing("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
+    # For ruby blocks, don't add blank line since we're replacing the code block inline, not adding a RESULT block
+    @output_lines << blank_line_before_new_result if blank_line_before_new_result && !ruby_style_result?(@current_block_lang)
 
     result_output = CodeExecutor.execute(@current_code_content, @current_block_lang, @temp_dir, @input_file_path, @current_block_explain, @current_block_flamegraph)
 
@@ -76,7 +85,12 @@ module ResultHelper
 
     # 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)
+      add_result_block(clean_result || result_after_dalibo, blank_line_before_new_result, closing_line)
+    elsif ruby_style_result?(@current_block_lang)
+      # For ruby blocks with result=false, output the original code content without xmpfilter results
+      @output_lines << @current_code_content
+      @output_lines << (closing_line || "```\n")
+      @output_lines << "\n"
     end
 
     # Always add Dalibo link if it exists, even when result=false
@@ -100,16 +114,22 @@ module ResultHelper
     end
   end
 
-  def skip_and_pass_through_result(lines_to_pass_through, file_enum, decision = nil)
+  def skip_and_pass_through_result(lines_to_pass_through, file_enum, decision = nil, closing_line = 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."
+      TestSilencer.warn_unless_testing("Skipping execution due to run=false option.")
+      # For ruby blocks, we still need to output the code content and closing line
+      if ruby_style_result?(@current_block_lang)
+        @output_lines << @current_code_content
+        @output_lines << (closing_line || "```\n")
+        @output_lines << "\n"
+      end
       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."
+      TestSilencer.warn_unless_testing("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
@@ -117,19 +137,27 @@ module ResultHelper
 
     # Check if this is flamegraph content
     if decision && decision[:flamegraph_content]
-      warn "Found existing flamegraph for current #{@current_block_lang} block, skipping execution."
+      TestSilencer.warn_unless_testing("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."
+      TestSilencer.warn_unless_testing("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
+    elsif ruby_style_result?(@current_block_lang)
+      # For ruby blocks with existing old-style RESULT blocks, discard them and output inline results
+      TestSilencer.warn_unless_testing("Found existing ruby result for current #{@current_block_lang} block, skipping execution.")
+      @output_lines << @current_code_content
+      @output_lines << (closing_line || "```\n")
+      @output_lines << "\n"
+      # Always consume and discard the old-style RESULT block
+      consume_and_discard_result_block(file_enum)
     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."
+      lang_specific_result_type = "``` {result}"
+      TestSilencer.warn_unless_testing("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
@@ -141,6 +169,12 @@ module ResultHelper
     end
   end
 
+  def consume_and_discard_result_block(file_enum)
+    consume_block_lines(file_enum) do |line|
+      # Discard the line - don't add to output
+    end
+  end
+
   def consume_existing_result_block(file_enum, consumed_lines)
     return if mermaid_style_result?(@current_block_lang)
 
@@ -161,7 +195,7 @@ module ResultHelper
         break if is_block_end?(result_block_line)
       end
     rescue StopIteration
-      warn "Warning: End of file reached while consuming result block."
+      TestSilencer.warn_unless_testing "Warning: End of file reached while consuming result block."
     end
   end
 end

data/lib/test_silencer.rb

@@ -0,0 +1,41 @@
+# Module to provide test-aware warning functionality
+module TestSilencer
+  # Helper method to detect if we're running in a test environment
+  def self.running_tests?
+    # Check for common test environment indicators
+    @running_tests ||= begin
+      caller.any? { |line| line.include?('/test/') || line.include?('minitest') || line.include?('rspec') } ||
+      defined?(Minitest) ||
+      ENV['RAILS_ENV'] == 'test' ||
+      ENV['RACK_ENV'] == 'test' ||
+      ($PROGRAM_NAME.include?('rake') && ARGV.include?('test')) ||
+      $PROGRAM_NAME.include?('rake_test_loader')
+    end
+  end
+
+  # Generic warn method that silences output during tests
+  def self.warn_unless_testing(message)
+    warn message unless running_tests?
+  end
+
+  # Silently abort during tests by raising SystemExit without printing the message
+  def self.abort_unless_testing(message)
+    if running_tests?
+      # During tests, raise SystemExit without printing the error message
+      raise SystemExit.new(1)
+    else
+      # In production, use normal abort which prints the message and exits
+      abort message
+    end
+  end
+
+  # Suppress Ruby warnings during tests
+  def self.setup_warning_suppression
+    if running_tests?
+      # Temporarily reduce verbosity during tests
+      original_verbose = $VERBOSE
+      $VERBOSE = nil
+      at_exit { $VERBOSE = original_verbose }
+    end
+  end
+end

data/markdown-run-sample/markdown-run-sample-flamegraph-20250604-233020-29c2a34ec32b.svg

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="1200" height="104" 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: 20px; 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="600" y="20" class="title" text-anchor="middle">PostgreSQL Query Execution Plan Flamegraph</text>
+  <text x="600" y="35" class="subtitle" text-anchor="middle">Total Execution Time: 0.0ms</text>
+
+  <!-- Flamegraph -->
+  <g transform="translate(0, 45)">
+      <rect class="frame"
+            x="0.0"
+            y="0"
+            width="1200.0"
+            height="24"
+            fill="#95a5a6">
+        <title>Result [0.0ms]
+Time: 0.0ms
+Percentage: 100.0%</title>
+      </rect>
+<text class="frame-text" x="4.0" y="21">Result [0.0ms]</text>
+  </g>
+</svg>

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.0
 platform: ruby
 authors:
 - Aurélien Bottazini
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcodetools
@@ -80,6 +79,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
 description: Run code blocks in Markdown files for Ruby, JavaScript, sqlite, psql,
   bash, zsh, and mermaid. Insert execution results next to the original code blocks.
   Generate SVG diagrams from mermaid blocks.
@@ -107,13 +120,17 @@ files:
 - lib/flamegraph_helper.rb
 - lib/frontmatter_parser.rb
 - lib/language_configs.rb
+- lib/language_resolver.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/postgres_helper.rb
 - lib/result_helper.rb
+- lib/test_silencer.rb
 - markdown-run-sample.md
+- markdown-run-sample/markdown-run-sample-flamegraph-20250604-233020-29c2a34ec32b.svg
 homepage: https://github.com/aurelienbottazini/markdown-run
 licenses:
 - MIT
@@ -121,7 +138,6 @@ metadata:
   homepage_uri: https://github.com/aurelienbottazini/markdown-run
   source_code_uri: https://github.com/aurelienbottazini/markdown-run
   changelog_uri: https://github.com/aurelienbottazini/markdown-run/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -136,8 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Run code blocks in Markdown files
 test_files: []