markdown-run 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00367c7c6c302db7b935780c6bb63f6deec1175516f82999ed7295f4b88794b6
-  data.tar.gz: dbf713b531a435d794e40da3f9e4f2d04b9a78e859bedba44649ed0ac46a5898
+  metadata.gz: ac1a715b89896b392f75d2222bda1a4f5899dda9da7a12871548faee8d3c86bb
+  data.tar.gz: 5fd7954991346dd940594b264d5b162a91451ed7c89e7510eb6b0315d2c39195
 SHA512:
-  metadata.gz: 5680e8dfa751cd59afc0cd5e92070cd6eb6d3d24c13a53f44212cc7f4398cd2504e3f63718c15f3e00ba92b8d87aced3a9d92804e9a25922b7af833c9d4608bb
-  data.tar.gz: 5778ebed3f7495f478fdc370faa06c8b7c38ada306de254103849ee18a14251f94a281d0fd91d78207c79fe27bac125e4cdf24dd78c039085e0013b67796b898
+  metadata.gz: 1ee917248f47a0ccc7770fdd419fe3d65dfe2ca99c79d44efe0b46a9fd599761e0c218e622c39989c806de07f92480c0de1e4c7c869d7d9f7db2439a9fb70fd0
+  data.tar.gz: 2c3eeb35fee738e405c30bdbb5fee6e8cad6bb0acc599c1115ad77315179e28dd37c6aace1b125c5306d9702b2cbc4c2dec1394695c9908a73853917f73a1fa3

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.1.6] - 2025-06-01
+
+- Refactor code to state pattern
+- Add yaml frontmatter to support aliases for code blocks
+
+## [0.1.5] - 2025-05-19
+
+- Remove gif files from release
+
 ## [0.1.4] - 2025-05-18
 
 - Add support for zsh, bash, sh

data/README.md

@@ -43,6 +43,18 @@ example vscode keybinding
   },
 ```
 
+## Frontmatter
+
+You can add a yaml frontmatter to redefine code block behavior.
+For example sql blocks run by default against sqlite
+To have them run with postgres you can add at the top of your markdown file:
+
+```yaml
+markdown-run:
+  alias:
+    - sql: psql
+```
+
 ## Demo
 
 ![VSCode Usage](docs/markdown-run-vscode.gif)

data/exe/markdown-run

@@ -3,119 +3,61 @@
 require "tempfile"
 require "open3"
 require "fileutils"
-
-# --- Language Execution Configuration ---
-JS_CONFIG = {
-  command: ->(_code_content, temp_file_path) {
-    # Check if bun is available
-    bun_exists = system("command -v bun > /dev/null 2>&1")
-    if bun_exists
-      [ "bun #{temp_file_path}", {} ]
-    else
-      # Fallback to node if bun is not available
-      [ "node #{temp_file_path}", {} ]
-    end
-  },
-  temp_file_suffix: ".js",
-  error_handling: :js_specific # For specific stderr appending on error
-}.freeze
-
-SQLITE_CONFIG = {
-  command: ->(code_content, temp_file_path) { [ "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) {
-      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."
-      end
-      [ "psql -A -t -X", { stdin_data: code_content } ]
-    }
-  },
-  "ruby" => {
-    command: ->(_code_content, temp_file_path) {
-      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."
-      end
-      [ "xmpfilter #{temp_file_path}", {} ]
-    },
-    temp_file_suffix: ".rb",
-    result_block_type: "ruby" # For special '```ruby RESULT' blocks
-  },
-  "js" => JS_CONFIG,
-  "javascript" => JS_CONFIG, # Alias for js
-  "sqlite" => SQLITE_CONFIG,
-  "sqlite3" => SQLITE_CONFIG, # Alias for sqlite
-  "bash" => {
-    command: ->(_code_content, temp_file_path) {
-      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."
-      end
-      [ "bash #{temp_file_path}", {} ]
-    },
-    temp_file_suffix: ".sh"
-  },
-  "zsh" => {
-    command: ->(_code_content, temp_file_path) {
-      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."
-      end
-      [ "zsh #{temp_file_path}", {} ]
-    },
-    temp_file_suffix: ".zsh"
-  },
-  "sh" => {
-    command: ->(_code_content, temp_file_path) {
-      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."
-      end
-      [ "sh #{temp_file_path}", {} ]
-    },
-    temp_file_suffix: ".sh"
-  }
-}.freeze
-
-LANGUAGE_REGEX_PART = SUPPORTED_LANGUAGES.keys.map { |lang| Regexp.escape(lang) }.join("|").freeze
-CODE_BLOCK_START_REGEX = /^```(#{LANGUAGE_REGEX_PART})$/i
-# --- End Language Execution Configuration ---
+require "yaml"
+require_relative "../lib/language_configs"
 
 # Script to process markdown files, execute code blocks based on language,
 # and insert their results back into the markdown.
 
+def stderr_has_content?(stderr_output)
+  stderr_output && !stderr_output.strip.empty?
+end
+
+def format_captured_output(captured_status_obj, captured_stderr, captured_stdout, lang_config)
+  result_output = captured_stdout
+  stderr_output = captured_stderr
+  exit_status = captured_status_obj.exitstatus
+
+  # JS-specific: Append stderr to result if execution failed and stderr has content
+  if lang_config && lang_config[:error_handling] == :js_specific && exit_status != 0 && stderr_has_content?(stderr_output)
+    result_output += "\nStderr:\n#{stderr_output.strip}"
+  end
+  return exit_status, result_output, stderr_output
+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)
+
+  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
+    error_prefix = "Execution failed (status: #{exit_status})."
+    error_prefix += " Stderr: #{stderr_output.strip}" if stderr_has_content?(stderr_output)
+    result_output = "#{error_prefix}\n#{result_output}"
+  end
+  result_output
+end
+
 def execute_code_block(code_content, lang, temp_dir)
-  result_output = ""
-  stderr_output = ""
-  exit_status = 0
-  captured_stdout = nil
-  captured_stderr = nil
   captured_status_obj = nil
 
   lang_key = lang.downcase # Normalize lang input for lookup
   lang_config = SUPPORTED_LANGUAGES[lang_key]
 
   if lang_config
+    exit_status = 0
     warn "Executing #{lang_key} code block..." # Generic description
     cmd_lambda = lang_config[:command]
     temp_file_suffix = lang_config[:temp_file_suffix]
 
-    # Determine command and options using the lambda
-    # The lambda receives code_content and a potential temp_file_path
-    # It returns [command_string, options_hash_for_open3]
-
+    captured_stdout = nil
     if temp_file_suffix # Needs a temporary file. Use lang_key as prefix.
       Tempfile.create([ lang_key, temp_file_suffix ], temp_dir) do |temp_file|
         temp_file.write(code_content)
         temp_file.close
         # Pass temp_file.path. Lambda decides if it needs code_content directly.
         command_to_run, exec_options = cmd_lambda.call(code_content, temp_file.path)
-        captured_stdout, captured_stderr, captured_status_obj = Open3.capture3(command_to_run, **exec_options)
+        captured_stdout, _, captured_status_obj = Open3.capture3(command_to_run, **exec_options)
       end
     else # Direct command execution (e.g., psql that takes stdin)
       # Pass nil for temp_file_path. Lambda decides if it needs code_content.
@@ -129,292 +71,307 @@ def execute_code_block(code_content, lang, temp_dir)
     # captured_status_obj remains nil, so common assignments below won't run
   end
 
-  # Common assignment logic for cases that used Open3.capture3
   if captured_status_obj
-    result_output = captured_stdout
-    stderr_output = captured_stderr
-    exit_status = captured_status_obj.exitstatus
-
-    # JS-specific: Append stderr to result if execution failed and stderr has content
-    if lang_config && lang_config[:error_handling] == :js_specific && exit_status != 0 && stderr_output && !stderr_output.strip.empty?
-      result_output += "\nStderr:\n#{stderr_output.strip}" # Ensure stripping
-    end
+    exit_status, result_output, stderr_output = format_captured_output(captured_status_obj, captured_stderr, captured_stdout, lang_config)
   end
 
-  # Common error message enhancement
   if exit_status != 0
-    warn "Code execution failed for language '#{lang_key}' with status #{exit_status}."
-    warn "Stderr:\n#{stderr_output}" if stderr_output && !stderr_output.strip.empty?
-
-    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
-      error_prefix = "Execution failed (status: #{exit_status})."
-      error_prefix += " Stderr: #{stderr_output.strip}" if stderr_output && !stderr_output.strip.empty?
-      result_output = "#{error_prefix}\n#{result_output}"
-    end
+    result_output = add_error_to_output(exit_status, lang_config, lang_key, result_output, stderr_output)
   end
   result_output
 end
 
-def process_markdown_file_main(input_file_path)
-  unless File.exist?(input_file_path) && File.readable?(input_file_path)
-    warn "Error: Input file '#{input_file_path}' not found or not readable."
-    return false # Indicate failure
+class MarkdownProcessor
+  def initialize(temp_dir)
+    @temp_dir = temp_dir
+    @output_lines = []
+    @state = :outside_code_block
+    @current_block_lang = ""
+    @current_code_content = ""
+    @aliases = {}
   end
 
-  temp_dir = File.dirname(File.expand_path(input_file_path))
-  output_lines = []
-  file_enum = File.foreach(input_file_path, chomp: false).to_enum
+  def process_file(file_enum)
+    parse_frontmatter(file_enum)
 
-  in_code_block = false
-  current_block_lang = ""
-  current_code_content = ""
+    loop do
+      current_line = get_next_line(file_enum)
+      break unless current_line
 
-  loop do
-    current_line = nil
-    begin
-      current_line = file_enum.next
-    rescue StopIteration
-      break # End of file
+      handle_line(current_line, file_enum)
     end
+    @output_lines
+  end
 
-    if !in_code_block
-      # Case 1: A ```ruby RESULT block encountered directly
-      if current_line.match?(/^```ruby\s+RESULT$/i)
-        warn "Found existing '```ruby RESULT' block, passing through."
-        output_lines << current_line # The ```ruby RESULT line
-        begin
-          loop do
-            block_line = file_enum.next
-            output_lines << block_line
-            break if block_line.strip == "```"
-          end
-        rescue StopIteration
-          warn "Warning: End of file reached inside a '```ruby RESULT' block."
-          break # Exit main loop, as the file is malformed or ended abruptly
-        end
-        next # Continue to the next line from the file
-      # Case 2: Start of a new executable code block ```lang
-      elsif (match_data = current_line.match(CODE_BLOCK_START_REGEX))
-        output_lines << current_line # The opening ```lang line
-        current_block_lang = match_data[1].downcase
-        in_code_block = true
-        current_code_content = "" # Reset for the new block
-        next # Continue to the next line from the file
-      # Case 3: Any other line (normal text, non-executable ```foo, or generic ```RESULT not after an exec block)
-      else
-        output_lines << current_line
-        next # Continue to the next line from the file
-      end
-    elsif current_line.strip == "```" # We are in_code_block (current_block_lang is set, current_code_content is accumulating)
-      # Case 4: End of the current code block (```)
-      output_lines << current_line # The closing ``` of the code block
-
-      execute_this_block = true # Assume execution by default
-      lines_to_pass_through_if_skipped = [] # For blank line + RESULT header if skipping
-      blank_line_before_new_result = nil # If a blank line is consumed but block is still executed
-
-      # Peek ahead logic
-      peek1 = nil
-      begin; peek1 = file_enum.peek; rescue StopIteration; end # If EOF, execute_this_block remains true
-
-      current_lang_config = SUPPORTED_LANGUAGES[current_block_lang] # Get config for the current block
-      is_ruby_style_result = current_lang_config && current_lang_config[:result_block_type] == "ruby"
-
-      expected_header_regex = is_ruby_style_result ? /^```ruby\s+RESULT$/i : /^```RESULT$/i
-
-      if peek1 && peek1.match?(expected_header_regex)
-        execute_this_block = false
-        lines_to_pass_through_if_skipped << file_enum.next # Consume RESULT header
-      elsif peek1 && peek1.strip == "" # Blank line detected
-        consumed_blank_line = file_enum.next # Consume the blank line from enum
-
-        peek2 = nil
-        begin; peek2 = file_enum.peek; rescue StopIteration; end # EOF after blank line
-
-        if peek2 && peek2.match?(expected_header_regex)
-          execute_this_block = false
-          lines_to_pass_through_if_skipped << consumed_blank_line # Add consumed blank line
-          lines_to_pass_through_if_skipped << file_enum.next # Consume RESULT header
-        else
-          # Blank line, but not followed by a RESULT header (or EOF after blank).
-          # We will execute the block. The consumed_blank_line should be outputted.
-          blank_line_before_new_result = consumed_blank_line
-          # execute_this_block remains true
-        end
-      end
-      # If peek1 was nil (EOF) or something else not matching, execute_this_block remains true.
-
-      if execute_this_block
-        output_lines << blank_line_before_new_result if blank_line_before_new_result
-        if !current_code_content.strip.empty?
-          warn "Executing #{current_block_lang} code block..."
-          result_output = execute_code_block(current_code_content, current_block_lang, temp_dir)
-
-          output_lines << "\n" if blank_line_before_new_result.nil?
-          output_lines << (is_ruby_style_result ? "```ruby RESULT\n" : "```RESULT\n")
-          output_lines << result_output
-          output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
-          output_lines << "```\n\n" # Ensures a blank line after the RESULT block
-        else
-          warn "Skipping empty code block for language '#{current_block_lang}'."
-        end
-      else # Do not execute; a RESULT block follows and was identified
-        lang_specific_result_type = is_ruby_style_result ? "```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_if_skipped) # Add blank line (if any) and RESULT header
-
-        # Consume the rest of the RESULT block content until its closing ```
-        begin
-          loop do
-            result_block_line = file_enum.next
-            output_lines << result_block_line
-            break if result_block_line.strip == "```"
-          end
-        rescue StopIteration
-          warn "Warning: End of file reached inside a skipped 'RESULT' block."
-          break # Exit main loop
-        end
+  private
+
+  def parse_frontmatter(file_enum)
+    first_line = peek_next_line(file_enum)
+    return unless first_line&.strip == "---"
+
+    # Consume the opening ---
+    @output_lines << file_enum.next
+    frontmatter_lines = []
+
+    loop do
+      line = get_next_line(file_enum)
+      break unless line
+
+      if line.strip == "---"
+        @output_lines << line
+        break
       end
 
-      in_code_block = false
-      current_code_content = "" # Reset for next block
-      next
-      # Case 5: Line inside an active code block
-    else
-      current_code_content += current_line
-      output_lines << current_line # This line is part of the original code block being recorded
-      next # Continue to the next line from the file
+      frontmatter_lines << line
+      @output_lines << line
     end
-  end # loop
 
-  # Write the modified content back to the input file
-  Tempfile.create([ "md_exec_out_", File.extname(input_file_path) ], temp_dir) do |temp_output_file|
-    temp_output_file.write(output_lines.join(""))
-    temp_output_file.close
+    return if frontmatter_lines.empty?
+
     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."
-      FileUtils.cp(temp_output_file.path, input_file_path)
-      FileUtils.rm_f(temp_output_file.path)
+      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}"
     end
   end
-  warn "Markdown processing complete. Output written to #{input_file_path}"
-  true # Indicate success
-end
 
-if ARGV.empty?
+  def extract_aliases(frontmatter)
+    markdown_run_config = frontmatter["markdown-run"]
+    return unless markdown_run_config.is_a?(Hash)
+
+    aliases = markdown_run_config["alias"]
+    return unless aliases.is_a?(Array)
+
+    aliases.each do |alias_config|
+      next unless alias_config.is_a?(Hash)
 
- require "minitest/spec"
-  require "bundler/inline"
-  gemfile(true) do
-    source "https://rubygems.org"
-    gem "minitest", "5.25.5" # Specify the required version
-    gem "rcodetools"
+      alias_config.each do |alias_name, target_lang|
+        @aliases[alias_name.to_s] = target_lang.to_s
+      end
+    end
   end
 
-  puts "Running tests..."
-  require "minitest/autorun"
+  def resolve_language(lang)
+    @aliases[lang] || lang
+  end
 
-# --- Minitest Test Class Definition ---
-class TestMarkdownExec < Minitest::Test
-  def setup
-    @temp_dir = Dir.mktmpdir("markdown_exec_tests")
-    @test_md_file_path = File.join(@temp_dir, "test.md")
+  def ruby_style_result?(lang)
+    lang_config = SUPPORTED_LANGUAGES[lang]
+    lang_config && lang_config[:result_block_type] == "ruby"
   end
 
-  def teardown
-    FileUtils.remove_entry @temp_dir if @temp_dir && Dir.exist?(@temp_dir)
+  def result_block_header(lang)
+    ruby_style_result?(lang) ? "```ruby RESULT\n" : "```RESULT\n"
   end
 
-  def create_md_file(content)
-    File.write(@test_md_file_path, content)
-    @test_md_file_path
+  def result_block_regex(lang)
+    ruby_style_result?(lang) ? /^```ruby\s+RESULT$/i : /^```RESULT$/i
   end
 
-  def read_md_file
-    File.read(@test_md_file_path)
+  def is_block_end?(line)
+    line.strip == "```"
   end
 
-  def test_script_runs_without_error_on_empty_file
-    create_md_file("")
-    assert process_markdown_file_main(@test_md_file_path), "Processing empty file should succeed"
-    assert_equal "", read_md_file.strip, "Empty file should remain empty after processing"
+  def has_content?(content)
+    !content.strip.empty?
   end
 
-  def test_psql_block_execution
-    skip "Skipping test_psql_block_execution on GitHub CI" if ENV['CI']
+  def add_result_block(result_output, blank_line_before_new_result)
+    @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
 
-    md_content = <<~MARKDOWN
-      ```psql
-      SELECT 'hello psql test';
-      ```
-    MARKDOWN
-    create_md_file(md_content)
-    process_markdown_file_main(@test_md_file_path)
+  def line_matches_pattern?(line, pattern)
+    line && line.match?(pattern)
+  end
 
-    expected_output = <<~MARKDOWN.strip
-      ```psql
-      SELECT 'hello psql test';
-      ```
+  def is_blank_line?(line)
+    line && line.strip == ""
+  end
 
-      ```RESULT
-      hello psql test
-      ```
-    MARKDOWN
-    assert_equal expected_output, read_md_file.strip
+  def safe_enum_operation(file_enum, operation)
+    file_enum.send(operation)
+  rescue StopIteration
+    nil
   end
 
-  def test_ruby_block_execution_and_result_generation
-    md_content = <<~MARKDOWN
-      ```ruby
-      puts "Hello from Ruby"
-      p 1 + 2
-      ```
-    MARKDOWN
-    create_md_file(md_content)
-    process_markdown_file_main(@test_md_file_path)
+  def get_next_line(file_enum)
+    safe_enum_operation(file_enum, :next)
+  end
 
-    file_content = read_md_file
-    assert file_content.include?("```ruby\nputs \"Hello from Ruby\""), "Original Ruby code should be present"
-    assert file_content.include?("```ruby RESULT\n"), "Ruby RESULT block should be created"
-    assert file_content.include?("3"), "Output from p 1 + 2 should be in the result"
+  def peek_next_line(file_enum)
+    safe_enum_operation(file_enum, :peek)
   end
 
-  def test_skip_execution_if_result_block_exists
-    original_content = <<~MARKDOWN
-      ```psql
-      SELECT 'this should not run';
-      ```
+  def handle_line(current_line, file_enum)
+    case @state
+    when :outside_code_block
+      handle_outside_code_block(current_line, file_enum)
+    when :inside_code_block
+      handle_inside_code_block(current_line, file_enum)
+    when :inside_result_block
+      handle_inside_result_block(current_line, file_enum)
+    end
+  end
 
-      ```RESULT
-      pre-existing result
-      ```
-    MARKDOWN
-    create_md_file(original_content)
-    process_markdown_file_main(@test_md_file_path)
+  def handle_outside_code_block(current_line, file_enum)
+    if current_line.match?(/^```ruby\s+RESULT$/i)
+      handle_existing_ruby_result_block(current_line, file_enum)
+    elsif (match_data = current_line.match(/^```(\w+)$/i))
+      lang = match_data[1].downcase
+      resolved_lang = resolve_language(lang)
+      if SUPPORTED_LANGUAGES.key?(resolved_lang)
+        start_code_block(current_line, lang)
+      else
+        @output_lines << current_line
+      end
+    else
+      @output_lines << current_line
+    end
+  end
+
+  def handle_inside_code_block(current_line, file_enum)
+    if is_block_end?(current_line)
+      end_code_block(current_line, file_enum)
+    else
+      accumulate_code_content(current_line)
+    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 start_code_block(current_line, lang)
+    @output_lines << current_line
+    @current_block_lang = resolve_language(lang)
+    @state = :inside_code_block
+    @current_code_content = ""
+  end
+
+  def accumulate_code_content(current_line)
+    @current_code_content += current_line
+    @output_lines << current_line
+  end
+
+  def end_code_block(current_line, file_enum)
+    @output_lines << current_line
+
+    decision = decide_execution(file_enum)
+
+    if decision[:execute]
+      execute_and_add_result(decision[:blank_line])
+    else
+      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum)
+    end
+
+    reset_code_block_state
+  end
+
+  def decide_execution(file_enum)
+    peek1 = peek_next_line(file_enum)
+    expected_header_regex = result_block_regex(@current_block_lang)
+
+    if line_matches_pattern?(peek1, expected_header_regex)
+      return { execute: false, lines_to_pass_through: [file_enum.next] }
+    elsif is_blank_line?(peek1)
+      consumed_blank_line = file_enum.next
+      peek2 = peek_next_line(file_enum)
+
+      if line_matches_pattern?(peek2, expected_header_regex)
+        return { execute: false, lines_to_pass_through: [consumed_blank_line, file_enum.next] }
+      else
+        return { execute: true, blank_line: consumed_blank_line }
+      end
+    else
+      return { execute: true }
+    end
+  end
+
+  def execute_and_add_result(blank_line_before_new_result)
+    @output_lines << blank_line_before_new_result if blank_line_before_new_result
+
+    if has_content?(@current_code_content)
+      result_output = execute_code_block(@current_code_content, @current_block_lang, @temp_dir)
+      add_result_block(result_output, blank_line_before_new_result)
+    else
+      warn "Skipping empty code block for language '#{@current_block_lang}'."
+    end
+  end
+
+  def skip_and_pass_through_result(lines_to_pass_through, file_enum)
+    lang_specific_result_type = ruby_style_result?(@current_block_lang) ? "```ruby RESULT" : "```RESULT"
 
-    assert_equal original_content.strip, read_md_file.strip, "Should not execute if RESULT block exists"
+    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
 
-  def test_skip_execution_if_ruby_result_block_exists
-    original_content = <<~MARKDOWN
-      ```ruby
-      puts "this should not run either"
-      ```
+  def consume_result_block_content(file_enum)
+    begin
+      loop do
+        result_block_line = file_enum.next
+        @output_lines << result_block_line
+        break if is_block_end?(result_block_line)
+      end
+    rescue StopIteration
+      warn "Warning: End of file reached inside a skipped 'RESULT' block."
+    end
+  end
 
-      ```ruby RESULT
-      this is a pre-existing ruby result
-      ```
-    MARKDOWN
-    create_md_file(original_content)
-    process_markdown_file_main(@test_md_file_path)
+  def reset_code_block_state
+    @state = :outside_code_block
+    @current_code_content = ""
+  end
+end
 
-    assert_equal original_content.strip, read_md_file.strip, "Should not execute if ```ruby RESULT block exists"
+def process_markdown_file_main(input_file_path)
+  unless File.exist?(input_file_path) && File.readable?(input_file_path)
+    warn "Error: Input file '#{input_file_path}' not found or not readable."
+    return false # Indicate failure
   end
+
+  temp_dir = File.dirname(File.expand_path(input_file_path))
+  file_enum = File.foreach(input_file_path, chomp: false).to_enum
+
+  processor = MarkdownProcessor.new(temp_dir)
+  output_lines = processor.process_file(file_enum)
+
+  # Write the modified content back to the input file
+  Tempfile.create([ "md_exec_out_", File.extname(input_file_path) ], temp_dir) do |temp_output_file|
+    temp_output_file.write(output_lines.join(""))
+    temp_output_file.close
+    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."
+      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}"
+  true # Indicate success
 end
+
+if ARGV.empty?
+  puts "Running tests..."
+  require_relative "../test_markdown_exec"
+else
+  process_markdown_file_main(ARGV[0])
 end
 
-process_markdown_file_main(ARGV[0]) unless ARGV.empty?

data/lib/language_configs.rb

@@ -0,0 +1,80 @@
+JS_CONFIG = {
+  command: ->(_code_content, temp_file_path) {
+    # Check if bun is available
+    bun_exists = system("command -v bun > /dev/null 2>&1")
+    if bun_exists
+      [ "bun #{temp_file_path}", {} ]
+    else
+      # Fallback to node if bun is not available
+      [ "node #{temp_file_path}", {} ]
+    end
+  },
+  temp_file_suffix: ".js",
+  error_handling: :js_specific # For specific stderr appending on error
+}.freeze
+
+SQLITE_CONFIG = {
+  command: ->(code_content, temp_file_path) { [ "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) {
+      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."
+      end
+      [ "psql -A -t -X", { stdin_data: code_content } ]
+    }
+  },
+  "ruby" => {
+    command: ->(_code_content, temp_file_path) {
+      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."
+      end
+      [ "xmpfilter #{temp_file_path}", {} ]
+    },
+    temp_file_suffix: ".rb",
+    result_block_type: "ruby" # For special '```ruby RESULT' blocks
+  },
+  "js" => JS_CONFIG,
+  "javascript" => JS_CONFIG, # Alias for js
+  "sql" => SQLITE_CONFIG,
+  "sqlite" => SQLITE_CONFIG,
+  "sqlite3" => SQLITE_CONFIG, # Alias for sqlite
+  "bash" => {
+    command: ->(_code_content, temp_file_path) {
+      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."
+      end
+      [ "bash #{temp_file_path}", {} ]
+    },
+    temp_file_suffix: ".sh"
+  },
+  "zsh" => {
+    command: ->(_code_content, temp_file_path) {
+      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."
+      end
+      [ "zsh #{temp_file_path}", {} ]
+    },
+    temp_file_suffix: ".zsh"
+  },
+  "sh" => {
+    command: ->(_code_content, temp_file_path) {
+      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."
+      end
+      [ "sh #{temp_file_path}", {} ]
+    },
+    temp_file_suffix: ".sh"
+  }
+}.freeze
+
+LANGUAGE_REGEX_PART = SUPPORTED_LANGUAGES.keys.map { |lang| Regexp.escape(lang) }.join("|").freeze
+CODE_BLOCK_START_REGEX = /^```(#{LANGUAGE_REGEX_PART})$/i

data/lib/markdown/run/version.rb

@@ -2,6 +2,6 @@
 
 module Markdown
   module Run
-    VERSION = "0.1.4"
+    VERSION = "0.1.6"
   end
 end

data/test_markdown_exec.rb

@@ -0,0 +1,134 @@
+require "bundler/inline"
+gemfile(true) do
+  source "https://rubygems.org"
+  gem "minitest", "5.25.5" # Specify the required version
+  gem "rcodetools"
+end
+
+require "minitest/test"
+require "minitest/autorun"
+require "fileutils"
+require "tmpdir"
+
+# --- Minitest Test Class Definition ---
+class TestMarkdownExec < Minitest::Test
+  def setup
+    @temp_dir = Dir.mktmpdir("markdown_exec_tests")
+    @test_md_file_path = File.join(@temp_dir, "test.md")
+  end
+
+  def teardown
+    FileUtils.remove_entry @temp_dir if @temp_dir && Dir.exist?(@temp_dir)
+  end
+
+  def create_md_file(content)
+    File.write(@test_md_file_path, content)
+    @test_md_file_path
+  end
+
+  def read_md_file
+    File.read(@test_md_file_path)
+  end
+
+  def test_script_runs_without_error_on_empty_file
+    create_md_file("")
+    assert process_markdown_file_main(@test_md_file_path), "Processing empty file should succeed"
+    assert_equal "", read_md_file.strip, "Empty file should remain empty after processing"
+  end
+
+  def test_psql_block_execution
+    skip "Skipping test_psql_block_execution on GitHub CI" if ENV['CI']
+
+    md_content = <<~MARKDOWN
+      ```psql
+      SELECT 'hello psql test';
+      ```
+    MARKDOWN
+    create_md_file(md_content)
+    process_markdown_file_main(@test_md_file_path)
+
+    expected_output = <<~MARKDOWN.strip
+      ```psql
+      SELECT 'hello psql test';
+      ```
+
+      ```RESULT
+      hello psql test
+      ```
+    MARKDOWN
+    assert_equal expected_output, read_md_file.strip
+  end
+
+  def test_ruby_block_execution_and_result_generation
+    md_content = <<~MARKDOWN
+      ```ruby
+      puts "Hello from Ruby"
+      p 1 + 2
+      ```
+    MARKDOWN
+    create_md_file(md_content)
+    process_markdown_file_main(@test_md_file_path)
+
+    file_content = read_md_file
+    assert file_content.include?("```ruby\nputs \"Hello from Ruby\""), "Original Ruby code should be present"
+    assert file_content.include?("```ruby RESULT\n"), "Ruby RESULT block should be created"
+    assert file_content.include?("3"), "Output from p 1 + 2 should be in the result"
+  end
+
+  def test_skip_execution_if_result_block_exists
+    original_content = <<~MARKDOWN
+      ```psql
+      SELECT 'this should not run';
+      ```
+
+      ```RESULT
+      pre-existing result
+      ```
+    MARKDOWN
+    create_md_file(original_content)
+    process_markdown_file_main(@test_md_file_path)
+
+    assert_equal original_content.strip, read_md_file.strip, "Should not execute if RESULT block exists"
+  end
+
+  def test_skip_execution_if_ruby_result_block_exists
+    original_content = <<~MARKDOWN
+      ```ruby
+      puts "this should not run either"
+      ```
+
+      ```ruby RESULT
+      this is a pre-existing ruby result
+      ```
+    MARKDOWN
+    create_md_file(original_content)
+    process_markdown_file_main(@test_md_file_path)
+
+    assert_equal original_content.strip, read_md_file.strip, "Should not execute if ```ruby RESULT block exists"
+  end
+
+  def test_frontmatter_alias_functionality
+    skip "Skipping test_frontmatter_alias_functionality on GitHub CI" if ENV['CI']
+
+    md_content = <<~MARKDOWN
+      ---
+      markdown-run:
+        alias:
+          - sql: psql
+      ---
+
+      # Test Document
+
+      ```sql
+      SELECT 'aliased to psql' as test;
+      ```
+    MARKDOWN
+    create_md_file(md_content)
+    process_markdown_file_main(@test_md_file_path)
+
+    file_content = read_md_file
+    assert file_content.include?("```sql\nSELECT 'aliased to psql' as test;"), "Original SQL code should be present"
+    assert file_content.include?("```RESULT\n"), "RESULT block should be created for aliased language"
+    assert file_content.include?("aliased to psql"), "Output should contain the expected result"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Aurélien Bottazini
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-18 00:00:00.000000000 Z
+date: 2025-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcodetools
@@ -52,10 +52,11 @@ files:
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
-- docs/markdown-run-vscode.gif
 - exe/markdown-run
+- lib/language_configs.rb
 - lib/markdown/run/version.rb
 - markdown-run-sample.md
+- test_markdown_exec.rb
 homepage: https://rubygems.org/gems/markdown-run
 licenses:
 - MIT