markdown-run 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b936d0e6cdca8201af8d50e9bf92919de41f768973712ef0c4d46839de3d00a
-  data.tar.gz: 9b72d1b9628b665c0fd0efcf71d2a75c746226b1593d1b4b338e94da8c774020
+  metadata.gz: c11a9addb3e251e9830fe2126d2d752dc8c04c879b607d1ee0ad80998d51b294
+  data.tar.gz: '014954e8178d28729dfa86350a9e92aa91010892e6d177a5f7616dfd0e9ad72b'
 SHA512:
-  metadata.gz: 105eb78e176854df961af1227c5eb9dc7c51c7647b46f14612560d53b2551d5292475450ee88065cfe85aef3962b17d0f464179a2f4f6fd9426435359344e50c
-  data.tar.gz: 5f8f611391d234a6cf5fc19784c8bb14604fd8da27589c93de714226773633ba4ca1b7c36ce7259e6899cc90d0283fc0e20b50b2ef5a67b728b3703fba78e18a
+  metadata.gz: 5a26f680f607d52d7ceb0b0f31cca84af2a811ed2a70f6f73f9ab6ae3f9032f9135943c9e765df4d9714cbbd766179de14bab8006148e1d65d27a26388dd935c
+  data.tar.gz: 3ed109437211b62afd2dcdf1469e3103db9bd36a13be207f0ea636d67163c269e4a199e9a4b901ed4f7756319b5aa9c20f00e7613106be463c5139965f209fbf

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.1.7] - 2025-06-01
+
+- Added rerun functionality
+
+## [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

data/README.md

@@ -8,6 +8,15 @@ Do not rerun code blocks if result block is present.
 
 Meant to be used from the terminal or from an editor with a keybinding.
 
+Supported languages:
+
+- Javascript
+- Ruby
+- sqlite3
+- postgresql
+- bash
+- zsh
+
 ## Installation
 
 `gem install markdown-run`
@@ -43,6 +52,29 @@ example vscode keybinding
   },
 ```
 
+### Code block options
+
+- `rerun=true` or `rerun=false` for a code block to rerun or skip execution. `rerun=true` is the default if not specified
+
+example:
+
+```js rerun=false
+console.log("hello world");
+```
+
+## 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,349 @@ 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 = ""
+    @current_block_rerun = false
+    @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
+  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
-    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
+      frontmatter_lines << line
+      @output_lines << line
+    end
 
-      # Peek ahead logic
-      peek1 = nil
-      begin; peek1 = file_enum.peek; rescue StopIteration; end # If EOF, execute_this_block remains true
+    return if frontmatter_lines.empty?
 
-      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"
+    begin
+      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
 
-      expected_header_regex = is_ruby_style_result ? /^```ruby\s+RESULT$/i : /^```RESULT$/i
+  def extract_aliases(frontmatter)
+    markdown_run_config = frontmatter["markdown-run"]
+    return unless markdown_run_config.is_a?(Hash)
 
-      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
+    aliases = markdown_run_config["alias"]
+    return unless aliases.is_a?(Array)
 
-        peek2 = nil
-        begin; peek2 = file_enum.peek; rescue StopIteration; end # EOF after blank line
+    aliases.each do |alias_config|
+      next unless alias_config.is_a?(Hash)
 
-        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
+      alias_config.each do |alias_name, target_lang|
+        @aliases[alias_name.to_s] = target_lang.to_s
       end
+    end
+  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
+  def resolve_language(lang)
+    @aliases[lang] || lang
+  end
+
+  def ruby_style_result?(lang)
+    lang_config = SUPPORTED_LANGUAGES[lang]
+    lang_config && lang_config[:result_block_type] == "ruby"
+  end
+
+  def result_block_header(lang)
+    ruby_style_result?(lang) ? "```ruby RESULT\n" : "```RESULT\n"
+  end
+
+  def result_block_regex(lang)
+    ruby_style_result?(lang) ? /^```ruby\s+RESULT$/i : /^```RESULT$/i
+  end
+
+  def is_block_end?(line)
+    line.strip == "```"
+  end
+
+  def has_content?(content)
+    !content.strip.empty?
+  end
+
+  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
+
+  def line_matches_pattern?(line, pattern)
+    line && line.match?(pattern)
+  end
+
+  def is_blank_line?(line)
+    line && line.strip == ""
+  end
+
+  def parse_rerun_option(options_string)
+    return false unless options_string
+    
+    # Match rerun=true or rerun=false
+    match = options_string.match(/rerun\s*=\s*(true|false)/i)
+    return false unless match
+    
+    match[1].downcase == "true"
+  end
+
+  def safe_enum_operation(file_enum, operation)
+    file_enum.send(operation)
+  rescue StopIteration
+    nil
+  end
+
+  def get_next_line(file_enum)
+    safe_enum_operation(file_enum, :next)
+  end
+
+  def peek_next_line(file_enum)
+    safe_enum_operation(file_enum, :peek)
+  end
+
+  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 # loop
+  end
 
-  # 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)
+  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+)(?:\s+(.*))?$/i))
+      lang = match_data[1].downcase
+      options_string = match_data[2]
+      resolved_lang = resolve_language(lang)
+      if SUPPORTED_LANGUAGES.key?(resolved_lang)
+        start_code_block(current_line, lang, options_string)
+      else
+        @output_lines << current_line
+      end
+    else
+      @output_lines << current_line
     end
   end
-  warn "Markdown processing complete. Output written to #{input_file_path}"
-  true # Indicate success
-end
 
-if ARGV.empty?
+  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
 
- require "minitest/spec"
-  require "bundler/inline"
-  gemfile(true) do
-    source "https://rubygems.org"
-    gem "minitest", "5.25.5" # Specify the required version
-    gem "rcodetools"
+  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
 
-  puts "Running tests..."
-  require "minitest/autorun"
+  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
 
-# --- 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 start_code_block(current_line, lang, options_string = nil)
+    @output_lines << current_line
+    @current_block_lang = resolve_language(lang)
+    @current_block_rerun = parse_rerun_option(options_string)
+    @state = :inside_code_block
+    @current_code_content = ""
   end
 
-  def teardown
-    FileUtils.remove_entry @temp_dir if @temp_dir && Dir.exist?(@temp_dir)
+  def accumulate_code_content(current_line)
+    @current_code_content += current_line
+    @output_lines << current_line
   end
 
-  def create_md_file(content)
-    File.write(@test_md_file_path, content)
-    @test_md_file_path
+  def end_code_block(current_line, file_enum)
+    @output_lines << current_line
+
+    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])
+    else
+      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum)
+    end
+
+    reset_code_block_state
   end
 
-  def read_md_file
-    File.read(@test_md_file_path)
+  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)
+      # If rerun=true, execute even if result block exists
+      if @current_block_rerun
+        # Consume the existing result block and execute
+        consumed_lines = [file_enum.next]
+        consume_existing_result_block(file_enum, consumed_lines)
+        return { execute: true, consumed_lines: consumed_lines }
+      else
+        return { execute: false, lines_to_pass_through: [file_enum.next] }
+      end
+    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)
+        if @current_block_rerun
+          # Consume the blank line and existing result block, then execute
+          consumed_lines = [consumed_blank_line, file_enum.next]
+          consume_existing_result_block(file_enum, consumed_lines)
+          return { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line }
+        else
+          return { execute: false, lines_to_pass_through: [consumed_blank_line, file_enum.next] }
+        end
+      else
+        return { execute: true, blank_line: consumed_blank_line }
+      end
+    else
+      return { execute: true }
+    end
   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 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 test_psql_block_execution
-    skip "Skipping test_psql_block_execution on GitHub CI" if ENV['CI']
+  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"
 
-    md_content = <<~MARKDOWN
-      ```psql
-      SELECT 'hello psql test';
-      ```
-    MARKDOWN
-    create_md_file(md_content)
-    process_markdown_file_main(@test_md_file_path)
+    warn "Found existing '#{lang_specific_result_type}' block for current #{@current_block_lang} block, skipping execution."
 
-    expected_output = <<~MARKDOWN.strip
-      ```psql
-      SELECT 'hello psql test';
-      ```
+    @output_lines.concat(lines_to_pass_through)
 
-      ```RESULT
-      hello psql test
-      ```
-    MARKDOWN
-    assert_equal expected_output, read_md_file.strip
+    consume_result_block_content(file_enum)
   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"
+  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
 
-  def test_skip_execution_if_result_block_exists
-    original_content = <<~MARKDOWN
-      ```psql
-      SELECT 'this should not run';
-      ```
+  def consume_existing_result_block(file_enum, consumed_lines)
+    begin
+      loop do
+        result_block_line = file_enum.next
+        consumed_lines << result_block_line
+        break if is_block_end?(result_block_line)
+      end
+    rescue StopIteration
+      warn "Warning: End of file reached while consuming existing result block for rerun."
+    end
+  end
 
-      ```RESULT
-      pre-existing 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 = ""
+    @current_block_rerun = false
+  end
+end
 
-    assert_equal original_content.strip, read_md_file.strip, "Should not execute if 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
 
-  def test_skip_execution_if_ruby_result_block_exists
-    original_content = <<~MARKDOWN
-      ```ruby
-      puts "this should not run either"
-      ```
+  temp_dir = File.dirname(File.expand_path(input_file_path))
+  file_enum = File.foreach(input_file_path, chomp: false).to_enum
 
-      ```ruby RESULT
-      this is a pre-existing ruby result
-      ```
-    MARKDOWN
-    create_md_file(original_content)
-    process_markdown_file_main(@test_md_file_path)
+  processor = MarkdownProcessor.new(temp_dir)
+  output_lines = processor.process_file(file_enum)
 
-    assert_equal original_content.strip, read_md_file.strip, "Should not execute if ```ruby RESULT block exists"
+  # 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.5"
+    VERSION = "0.1.7"
   end
 end

data/test_markdown_exec.rb

@@ -0,0 +1,204 @@
+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
+
+  def test_rerun_functionality
+    # Test 1: Default behavior (no rerun option) should skip existing result
+    md_content_with_result = <<~MARKDOWN
+      ```ruby
+      puts "Should not change: \#{Time.now.to_i}"
+      ```
+
+      ```ruby RESULT
+      Should not change: 999999999
+      ```
+    MARKDOWN
+    create_md_file(md_content_with_result)
+    process_markdown_file_main(@test_md_file_path)
+
+    file_content = read_md_file
+    assert file_content.include?("Should not change: 999999999"), "Default behavior should preserve existing result"
+    refute file_content.match?(/Should not change: (?!999999999)\d+/), "Default behavior should not generate new timestamp"
+
+    # Test 2: rerun=false should skip existing result
+    md_content_rerun_false = <<~MARKDOWN
+      ```ruby rerun=false
+      puts "Should not change either: \#{Time.now.to_i}"
+      ```
+
+      ```ruby RESULT
+      Should not change either: 888888888
+      ```
+    MARKDOWN
+    create_md_file(md_content_rerun_false)
+    process_markdown_file_main(@test_md_file_path)
+
+    file_content = read_md_file
+    assert file_content.include?("Should not change either: 888888888"), "rerun=false should preserve existing result"
+    refute file_content.match?(/Should not change either: (?!888888888)\d+/), "rerun=false should not generate new timestamp"
+
+    # Test 3: rerun=true should replace existing result
+    md_content_rerun_true = <<~MARKDOWN
+      ```ruby rerun=true
+      puts "Should change: \#{Time.now.to_i}"
+      ```
+
+      ```ruby RESULT
+      Should change: 777777777
+      ```
+    MARKDOWN
+    create_md_file(md_content_rerun_true)
+    process_markdown_file_main(@test_md_file_path)
+
+    file_content = read_md_file
+    refute file_content.include?("Should change: 777777777"), "rerun=true should replace existing result"
+    assert file_content.match?(/Should change: \d+/), "rerun=true should generate new result with actual timestamp"
+
+    # Test 4: rerun=true with blank line before result block
+    md_content_rerun_true_blank = <<~MARKDOWN
+      ```ruby rerun=true
+      puts "Should also change: \#{Time.now.to_i}"
+      ```
+
+      ```ruby RESULT
+      Should also change: 666666666
+      ```
+    MARKDOWN
+    create_md_file(md_content_rerun_true_blank)
+    process_markdown_file_main(@test_md_file_path)
+
+    file_content = read_md_file
+    refute file_content.include?("Should also change: 666666666"), "rerun=true with blank line should replace existing result"
+    assert file_content.match?(/Should also change: \d+/), "rerun=true with blank line should generate new result"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Aurélien Bottazini
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-19 00:00:00.000000000 Z
+date: 2025-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcodetools
@@ -53,13 +53,15 @@ files:
 - LICENSE.txt
 - README.md
 - exe/markdown-run
+- lib/language_configs.rb
 - lib/markdown/run/version.rb
 - markdown-run-sample.md
-homepage: https://rubygems.org/gems/markdown-run
+- test_markdown_exec.rb
+homepage: https://github.com/aurelienbottazini/markdown-run
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://rubygems.org/gems/markdown-run
+  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: