markdown-run 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1139e0ccb6ed1b5b4ee2cef44cf067c83fc8a92ad750eae2e256725282534b68
-  data.tar.gz: 8887f778eaec56e6bdbb84d0a48f8db82fbd52cabbcdea01c48f4cffb5ff410b
+  metadata.gz: 7e078472cf91253d16b3341865954ead4ce1d6539d509c5ed6d54302c5a3147d
+  data.tar.gz: 76f40572409ed01a1797c4902896b783d3a0403783031fca8c8dff04a1499acf
 SHA512:
-  metadata.gz: 6656d86bf179be5a044a95ccbc1a9c11e68642a35ed2ffa99138dc0de653ed4b2e176a9763f08b765d409ec232e4b9eda4779b166c97b7304ed156a48b147c93
-  data.tar.gz: 3f8771ece0365e9a1c7073a6d749d41570776b59e9cbe0c38383516cce9cf0261a2ba287aadb30278ee0cf72e859fe4b4cb072fa89294bc3a525700fdec5ff9c
+  metadata.gz: ea3ecacb94cbe3e52dacb9fdb4ea447790990cee631fd890f5389d483157d7e16621eda6dba68dddf13d1e1f5f499b8bc2ac3952e2ca1752f133f5aa496403b1
+  data.tar.gz: 8ae64565dc336f5158a877c54a02520bc6a0e6923c6bbdd705c2cff8c848ff832f0a0683f30c2e86df883a356d89e60269cebb219d9a9732212fc5edfd27fea6

data/CHANGELOG.md

@@ -1,49 +1,53 @@
 ## [Unreleased]
 
+## [0.1.11] - 2025-06-04
+
+-   options are customizable with the yaml frontmatter
+
 ## [0.1.10] - 2025-06-03
 
-- standalone options for codeblocks (run instead of run=true)
-- explain option for psql code blocks with Dalibo visualization links
-- Fixed Dalibo URL generation to properly submit plans via HTTP POST
-- Added result option to control result block visibility (result=false hides result blocks while still executing code)
+-   standalone options for codeblocks (run instead of run=true)
+-   explain option for psql code blocks with Dalibo visualization links
+-   Fixed Dalibo URL generation to properly submit plans via HTTP POST
+-   Added result option to control result block visibility (result=false hides result blocks while still executing code)
 
 ## [0.1.9] - 2025-06-02
 
-- mermaid codeblocks
+-   mermaid codeblocks
 
 ## [0.1.8] - 2025-06-01
 
-- Added run option
+-   Added run option
 
 ## [0.1.7] - 2025-06-01
 
-- Added rerun functionality
+-   Added rerun functionality
 
 ## [0.1.6] - 2025-06-01
 
-- Refactor code to state pattern
-- Add yaml frontmatter to support aliases for code blocks
+-   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
+-   Remove gif files from release
 
 ## [0.1.4] - 2025-05-18
 
-- Add support for zsh, bash, sh
+-   Add support for zsh, bash, sh
 
 ## [0.1.3] - 2025-05-14
 
-- Fix missing minitest dep
+-   Fix missing minitest dep
 
 ## [0.1.2] - 2025-05-14
 
-- Gemfile update
+-   Gemfile update
 
 ## [0.1.1] - 2025-05-14
 
-- Added checks for missing dependencies
+-   Added checks for missing dependencies
 
 ## [0.1.0] - 2025-05-13
 
-- Initial release
+-   Initial release

data/README.md

@@ -135,6 +135,65 @@ markdown-run:
     - sql: psql
 ```
 
+### Setting Defaults
+
+You can override the default behavior for code block options using frontmatter:
+
+```yaml
+markdown-run:
+  defaults:
+    rerun: true
+    result: false
+  psql:
+    explain: true
+  ruby:
+    rerun: false
+```
+
+**Priority order (highest to lowest):**
+
+1. Explicit options in code blocks (e.g., `rerun=true`)
+2. Language-specific defaults (e.g., `psql: { explain: true }`)
+3. Global defaults (e.g., `defaults: { rerun: true }`)
+4. Built-in application defaults
+
+**Available options for defaults:**
+
+- `run`: Control whether code blocks execute (default: `true`)
+- `rerun`: Control whether to re-execute if result exists (default: `false`)
+- `result`: Control whether to show result blocks (default: `true`)
+- `explain`: For psql blocks, generate explain plans (default: `false`)
+
+**Examples:**
+
+Make all code blocks rerun by default:
+
+```yaml
+markdown-run:
+  defaults:
+    rerun: true
+```
+
+Hide result blocks by default but enable explain for psql:
+
+```yaml
+markdown-run:
+  defaults:
+    result: false
+  psql:
+    explain: true
+```
+
+Language-specific settings override global defaults:
+
+```yaml
+markdown-run:
+  defaults:
+    rerun: false # Global default
+  ruby:
+    rerun: true # Ruby blocks will rerun, others won't
+```
+
 ## Demo
 
 ![VSCode Usage](docs/markdown-run-vscode.gif)

data/lib/code_block_helper.rb

@@ -0,0 +1,62 @@
+module CodeBlockHelper
+  private
+
+  def reset_code_block_state
+    @state = :outside_code_block
+    @current_code_content = ""
+    @current_block_lang = ""
+
+
+    @current_block_rerun = false
+    @current_block_run = true
+    @current_block_explain = false
+    @current_block_result = true
+  end
+
+
+  def start_code_block(current_line, lang, options_string = nil)
+    @output_lines << current_line
+    @current_block_lang = 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)
+    @current_block_result = @code_block_parser.parse_result_option(options_string, @current_block_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]
+      # 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, decision)
+    end
+
+    reset_code_block_state
+  end
+
+  def decide_execution(file_enum)
+    decider = ExecutionDecider.new(@current_block_run, @current_block_rerun, @current_block_lang, @current_block_explain, @current_block_result)
+    decision = decider.decide(file_enum, method(:result_block_regex))
+
+    # Handle the consume_existing flag for rerun scenarios
+    if decision[:consume_existing]
+      consume_existing_result_block(file_enum, decision[:consumed_lines])
+    elsif decision[:consume_existing_dalibo]
+      # Dalibo links are already consumed in the decision process
+      # Just acknowledge they were consumed
+    end
+
+    decision
+  end
+end

data/lib/code_block_parser.rb

@@ -34,20 +34,24 @@ class CodeBlockParser
     line.strip == BLOCK_END_PATTERN
   end
 
-  def parse_run_option(options_string)
-    parse_boolean_option(options_string, "run", true)
+  def parse_run_option(options_string, language = nil)
+    default_value = @frontmatter_parser.get_default_value("run", language, true)
+    parse_boolean_option(options_string, "run", default_value)
   end
 
-  def parse_rerun_option(options_string)
-    parse_boolean_option(options_string, "rerun", false)
+  def parse_rerun_option(options_string, language = nil)
+    default_value = @frontmatter_parser.get_default_value("rerun", language, false)
+    parse_boolean_option(options_string, "rerun", default_value)
   end
 
-  def parse_explain_option(options_string)
-    parse_boolean_option(options_string, "explain", false)
+  def parse_explain_option(options_string, language = nil)
+    default_value = @frontmatter_parser.get_default_value("explain", language, false)
+    parse_boolean_option(options_string, "explain", default_value)
   end
 
-  def parse_result_option(options_string)
-    parse_boolean_option(options_string, "result", true)
+  def parse_result_option(options_string, language = nil)
+    default_value = @frontmatter_parser.get_default_value("result", language, true)
+    parse_boolean_option(options_string, "result", default_value)
   end
 
   private

data/lib/code_executor.rb

@@ -21,6 +21,12 @@ class CodeExecutor
 
   private
 
+
+
+  def stderr_has_content?(stderr_output)
+    stderr_output && !stderr_output.strip.empty?
+  end
+
   def handle_unsupported_language(lang)
     warn "Unsupported language: #{lang}"
     "ERROR: Unsupported language: #{lang}"
@@ -167,31 +173,25 @@ class CodeExecutor
 
   def submit_plan_to_dalibo(plan_json)
     begin
-      # Start with HTTPS directly to avoid the HTTP->HTTPS redirect
       uri = URI('https://explain.dalibo.com/new')
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
-      http.read_timeout = 10  # 10 seconds timeout
+      http.read_timeout = 10
 
-      # Prepare the JSON payload
       payload = {
         'plan' => plan_json,
         'title' => "Query Plan - #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}",
         'query' => ''
       }
 
-      # Create the POST request
       request = Net::HTTP::Post.new(uri)
       request['Content-Type'] = 'application/json'
       request.body = JSON.generate(payload)
 
-      # Send the request and follow redirects to get the final URL
       response = http.request(request)
 
-      # Dalibo returns a redirect to the plan URL
       if response.is_a?(Net::HTTPRedirection)
         location = response['location']
-        # Make sure it's a full URL
         if location
           if location.start_with?('/')
             location = "https://explain.dalibo.com#{location}"

data/lib/dalibo_helper.rb

@@ -0,0 +1,39 @@
+module DaliboHelper
+  private
+
+  DALIBO_LINK_PREFIX = "DALIBO_LINK:"
+
+  def extract_dalibo_link(result_output)
+    # Check if the result contains a Dalibo link marker
+    if result_output.start_with?(DALIBO_LINK_PREFIX)
+      lines = result_output.split("\n", 2)
+      dalibo_url = lines[0].sub(DALIBO_LINK_PREFIX, "")
+      clean_result = lines[1] || ""
+      dalibo_link = "**Dalibo Visualization:** [View Query Plan](#{dalibo_url})"
+      [dalibo_link, clean_result]
+    else
+      [nil, result_output]
+    end
+  end
+
+  def consume_dalibo_link_if_present(file_enum, consumed_lines)
+    # Look ahead to see if there are Dalibo links after the result block
+    begin
+      # Keep consuming blank lines and Dalibo links until we hit something else
+      loop do
+        next_line = peek_next_line(file_enum)
+
+        if is_blank_line?(next_line)
+          consumed_lines << file_enum.next
+        elsif next_line&.start_with?("**Dalibo Visualization:**")
+          consumed_lines << file_enum.next
+        else
+          # Hit something that's not a blank line or Dalibo link, stop consuming
+          break
+        end
+      end
+    rescue StopIteration
+      # End of file reached, nothing more to consume
+    end
+  end
+end

data/lib/frontmatter_parser.rb

@@ -6,9 +6,11 @@ class FrontmatterParser
 
   def initialize
     @aliases = {}
+    @defaults = {}
+    @language_defaults = {}
   end
 
-  attr_reader :aliases
+  attr_reader :aliases, :defaults, :language_defaults
 
   def parse_frontmatter(file_enum, output_lines)
     first_line = peek_next_line(file_enum)
@@ -22,6 +24,26 @@ class FrontmatterParser
     @aliases[lang] || lang
   end
 
+  def get_default_value(option_name, language, fallback_default)
+    # Priority order:
+    # 1. Language-specific defaults (e.g., psql: { explain: true })
+    # 2. Global defaults (e.g., defaults: { rerun: true })
+    # 3. Fallback default (hardcoded in the application)
+
+    # Check language-specific defaults first
+    if @language_defaults[language] && @language_defaults[language].key?(option_name)
+      return @language_defaults[language][option_name]
+    end
+
+    # Check global defaults
+    if @defaults.key?(option_name)
+      return @defaults[option_name]
+    end
+
+    # Return fallback default
+    fallback_default
+  end
+
   private
 
   def collect_frontmatter_lines(file_enum, output_lines)
@@ -58,14 +80,34 @@ class FrontmatterParser
     markdown_run_config = frontmatter["markdown-run"]
     return unless markdown_run_config.is_a?(Hash)
 
+    # Extract aliases
     aliases = markdown_run_config["alias"]
-    return unless aliases.is_a?(Array)
+    if aliases.is_a?(Array)
+      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
+        end
+      end
+    end
+
+    # Extract defaults
+    defaults = markdown_run_config["defaults"]
+    if defaults.is_a?(Hash)
+      defaults.each do |option_name, option_value|
+        @defaults[option_name.to_s] = option_value
+      end
+    end
 
-    aliases.each do |alias_config|
-      next unless alias_config.is_a?(Hash)
+    # Extract language-specific defaults
+    markdown_run_config.each do |key, value|
+      next if ["alias", "defaults"].include?(key)
+      next unless value.is_a?(Hash)
 
-      alias_config.each do |alias_name, target_lang|
-        @aliases[alias_name.to_s] = target_lang.to_s
+      @language_defaults[key.to_s] = {}
+      value.each do |option_name, option_value|
+        @language_defaults[key.to_s][option_name.to_s] = option_value
       end
     end
   end

data/lib/markdown/run/version.rb

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

data/lib/markdown_processor.rb

@@ -4,20 +4,22 @@ require_relative "code_block_parser"
 require_relative "code_executor"
 require_relative "execution_decider"
 require_relative "enum_helper"
+require_relative "dalibo_helper"
+require_relative "code_block_helper"
+require_relative "result_helper"
 
 class MarkdownProcessor
   include EnumHelper
+  include DaliboHelper
+  include CodeBlockHelper
+  include ResultHelper
+
   def initialize(temp_dir, input_file_path = nil)
     @temp_dir = temp_dir
     @input_file_path = input_file_path
     @output_lines = []
-    @state = :outside_code_block
-    @current_block_lang = ""
-    @current_code_content = ""
-    @current_block_rerun = false
-    @current_block_run = true
-    @current_block_explain = false
-    @current_block_result = true
+    reset_code_block_state
+
     @frontmatter_parser = FrontmatterParser.new
     @code_block_parser = CodeBlockParser.new(@frontmatter_parser)
   end
@@ -40,31 +42,6 @@ class MarkdownProcessor
     @frontmatter_parser.resolve_language(lang)
   end
 
-  def ruby_style_result?(lang)
-    lang_config = SUPPORTED_LANGUAGES[lang]
-    lang_config && lang_config[:result_block_type] == "ruby"
-  end
-
-  def mermaid_style_result?(lang)
-    lang_config = SUPPORTED_LANGUAGES[lang]
-    lang_config && lang_config[:result_handling] == :mermaid_svg
-  end
-
-  def result_block_header(lang)
-    ruby_style_result?(lang) ? "```ruby RESULT\n" : "```RESULT\n"
-  end
-
-  def result_block_regex(lang)
-    if mermaid_style_result?(lang)
-      # For mermaid, look for existing image tags with .svg extension
-      /^!\[.*\]\(.*\.svg\)$/i
-    elsif ruby_style_result?(lang)
-      /^```ruby\s+RESULT$/i
-    else
-      /^```RESULT$/i
-    end
-  end
-
   def is_block_end?(line)
     @code_block_parser.is_block_end?(line)
   end
@@ -73,22 +50,6 @@ class MarkdownProcessor
     !content.strip.empty?
   end
 
-  def add_result_block(result_output, blank_line_before_new_result)
-    if mermaid_style_result?(@current_block_lang)
-      # For mermaid, add the image tag directly without a result block
-      @output_lines << "\n" if blank_line_before_new_result.nil?
-      @output_lines << result_output
-      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
-      @output_lines << "\n"
-    else
-      @output_lines << "\n" if blank_line_before_new_result.nil?
-      @output_lines << result_block_header(@current_block_lang)
-      @output_lines << result_output
-      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
-      @output_lines << "```\n\n"
-    end
-  end
-
   def line_matches_pattern?(line, pattern)
     line && line.match?(pattern)
   end
@@ -97,22 +58,6 @@ class MarkdownProcessor
     line && line.strip == ""
   end
 
-  def parse_rerun_option(options_string)
-    @code_block_parser.parse_rerun_option(options_string)
-  end
-
-  def parse_run_option(options_string)
-    @code_block_parser.parse_run_option(options_string)
-  end
-
-  def parse_explain_option(options_string)
-    @code_block_parser.parse_explain_option(options_string)
-  end
-
-  def parse_result_option(options_string)
-    @code_block_parser.parse_result_option(options_string)
-  end
-
   def handle_line(current_line, file_enum)
     case @state
     when :outside_code_block
@@ -144,199 +89,4 @@ class MarkdownProcessor
       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, options_string = nil)
-    @output_lines << current_line
-    @current_block_lang = resolve_language(lang)
-    @current_block_rerun = parse_rerun_option(options_string)
-    @current_block_run = parse_run_option(options_string)
-    @current_block_explain = parse_explain_option(options_string)
-    @current_block_result = parse_result_option(options_string)
-    @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]
-      # 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, decision)
-    end
-
-    reset_code_block_state
-  end
-
-  def decide_execution(file_enum)
-    decider = ExecutionDecider.new(@current_block_run, @current_block_rerun, @current_block_lang, @current_block_explain, @current_block_result)
-    decision = decider.decide(file_enum, method(:result_block_regex))
-
-    # Handle the consume_existing flag for rerun scenarios
-    if decision[:consume_existing]
-      consume_existing_result_block(file_enum, decision[:consumed_lines])
-    elsif decision[:consume_existing_dalibo]
-      # Dalibo links are already consumed in the decision process
-      # Just acknowledge they were consumed
-    end
-
-    decision
-  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 = CodeExecutor.execute(@current_code_content, @current_block_lang, @temp_dir, @input_file_path, @current_block_explain)
-
-      # Check if result contains a Dalibo link for psql explain queries
-      dalibo_link, clean_result = extract_dalibo_link(result_output)
-
-      # Add the result block only if result=true (default)
-      if @current_block_result
-        add_result_block(clean_result || result_output, blank_line_before_new_result)
-      end
-
-      # Always add Dalibo link if it exists, even when result=false
-      if dalibo_link
-        # Add appropriate spacing based on whether result block was shown
-        if @current_block_result
-          @output_lines << "#{dalibo_link}\n\n"
-        else
-          @output_lines << "\n#{dalibo_link}\n\n"
-        end
-      end
-    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, decision = nil)
-    # Handle run=false case where there are no lines to pass through
-    if lines_to_pass_through.empty?
-      warn "Skipping execution due to run=false option."
-      return
-    end
-
-    # Check if this is Dalibo content
-    if decision && decision[:dalibo_content]
-      warn "Found existing Dalibo link for current #{@current_block_lang} block, skipping execution."
-      @output_lines.concat(lines_to_pass_through)
-      # No additional consumption needed for Dalibo links
-      return
-    end
-
-    if mermaid_style_result?(@current_block_lang)
-      warn "Found existing mermaid SVG image for current #{@current_block_lang} block, skipping execution."
-      @output_lines.concat(lines_to_pass_through)
-      # For mermaid, no additional consumption needed since it's just an image line
-    else
-      lang_specific_result_type = ruby_style_result?(@current_block_lang) ? "```ruby RESULT" : "```RESULT"
-      warn "Found existing '#{lang_specific_result_type}' block for current #{@current_block_lang} block, skipping execution."
-      @output_lines.concat(lines_to_pass_through)
-      consume_result_block_content(file_enum)
-    end
-  end
-
-  def consume_result_block_content(file_enum)
-    consume_block_lines(file_enum) do |line|
-      @output_lines << line
-    end
-  end
-
-  def consume_existing_result_block(file_enum, consumed_lines)
-    if mermaid_style_result?(@current_block_lang)
-      # For mermaid, there's no result block to consume, just the image line
-      # The image line should already be in consumed_lines from ExecutionDecider
-      return
-    end
-
-    consume_block_lines(file_enum) do |line|
-      consumed_lines << line
-    end
-
-    # After consuming the result block, check if there's a Dalibo link to consume as well
-    consume_dalibo_link_if_present(file_enum, consumed_lines)
-  end
-
-  def consume_block_lines(file_enum)
-    begin
-      loop do
-        result_block_line = file_enum.next
-        yield result_block_line
-        break if is_block_end?(result_block_line)
-      end
-    rescue StopIteration
-      warn "Warning: End of file reached while consuming result block."
-    end
-  end
-
-  def reset_code_block_state
-    @state = :outside_code_block
-    @current_code_content = ""
-    @current_block_rerun = false
-    @current_block_run = true
-    @current_block_explain = false
-    @current_block_result = true
-  end
-
-  def stderr_has_content?(stderr_output)
-    stderr_output && !stderr_output.strip.empty?
-  end
-
-  def extract_dalibo_link(result_output)
-    # Check if the result contains a Dalibo link marker
-    if result_output.start_with?("DALIBO_LINK:")
-      lines = result_output.split("\n", 2)
-      dalibo_url = lines[0].sub("DALIBO_LINK:", "")
-      clean_result = lines[1] || ""
-      dalibo_link = "**Dalibo Visualization:** [View Query Plan](#{dalibo_url})"
-      [dalibo_link, clean_result]
-    else
-      [nil, result_output]
-    end
-  end
-
-  def consume_dalibo_link_if_present(file_enum, consumed_lines)
-    # Look ahead to see if there are Dalibo links after the result block
-    begin
-      # Keep consuming blank lines and Dalibo links until we hit something else
-      loop do
-        next_line = peek_next_line(file_enum)
-
-        if is_blank_line?(next_line)
-          consumed_lines << file_enum.next
-        elsif next_line&.start_with?("**Dalibo Visualization:**")
-          consumed_lines << file_enum.next
-        else
-          # Hit something that's not a blank line or Dalibo link, stop consuming
-          break
-        end
-      end
-    rescue StopIteration
-      # End of file reached, nothing more to consume
-    end
-  end
-
 end

data/lib/result_helper.rb

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

metadata

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