markdown-run 0.1.8 → 0.1.9

data/lib/markdown_processor.rb

@@ -0,0 +1,262 @@
+require_relative "language_configs"
+require_relative "frontmatter_parser"
+require_relative "code_block_parser"
+require_relative "code_executor"
+require_relative "execution_decider"
+require_relative "enum_helper"
+
+class MarkdownProcessor
+  include EnumHelper
+  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
+    @frontmatter_parser = FrontmatterParser.new
+    @code_block_parser = CodeBlockParser.new(@frontmatter_parser)
+  end
+
+  def process_file(file_enum)
+    @frontmatter_parser.parse_frontmatter(file_enum, @output_lines)
+
+    loop do
+      current_line = get_next_line(file_enum)
+      break unless current_line
+
+      handle_line(current_line, file_enum)
+    end
+    @output_lines
+  end
+
+  private
+
+  def resolve_language(lang)
+    @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
+
+  def has_content?(content)
+    !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
+
+  def is_blank_line?(line)
+    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 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
+
+  def handle_outside_code_block(current_line, file_enum)
+    if @code_block_parser.is_ruby_result_block?(current_line)
+      handle_existing_ruby_result_block(current_line, file_enum)
+    else
+      parsed_header = @code_block_parser.parse_code_block_header(current_line)
+      if parsed_header && parsed_header[:is_supported]
+        start_code_block(current_line, parsed_header[:original_lang], parsed_header[:options_string])
+      else
+        @output_lines << current_line
+      end
+    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, 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)
+    @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)
+    end
+
+    reset_code_block_state
+  end
+
+  def decide_execution(file_enum)
+    decider = ExecutionDecider.new(@current_block_run, @current_block_rerun, @current_block_lang)
+    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])
+    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)
+      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)
+    # 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
+
+    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
+  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
+  end
+
+  def stderr_has_content?(stderr_output)
+    stderr_output && !stderr_output.strip.empty?
+  end
+end

data/lib/markdown_run.rb

@@ -0,0 +1,20 @@
+require_relative "language_configs"
+require_relative "markdown_processor"
+require_relative "markdown_file_writer"
+
+module MarkdownRun
+  def self.run_code_blocks(input_file_path)
+    unless File.exist?(input_file_path) && File.readable?(input_file_path)
+      abort "Error: Input file '#{input_file_path}' not found or not readable."
+    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, input_file_path)
+    output_lines = processor.process_file(file_enum)
+
+    # Write the modified content back to the input file
+    MarkdownFileWriter.write_output_to_file(output_lines, input_file_path)
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Aurélien Bottazini
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-01 00:00:00.000000000 Z
+date: 2025-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcodetools
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.5
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -31,15 +31,44 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 5.25.5
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
         version: 5.25.5
-description: Run code blocks in Markdown files for Ruby, JavaScript, sqlite and psql.
-  Insert execution results next to the original code blocks.
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Run code blocks in Markdown files for Ruby, JavaScript, sqlite, psql,
+  bash, zsh, and mermaid. Insert execution results next to the original code blocks.
+  Generate SVG diagrams from mermaid blocks.
 email:
 - 32635+aurelienbottazini@users.noreply.github.com
 executables:
@@ -48,15 +77,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- ".tool-versions"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
+- Rakefile
 - exe/markdown-run
+- lib/code_block_parser.rb
+- lib/code_executor.rb
+- lib/enum_helper.rb
+- lib/execution_decider.rb
+- lib/frontmatter_parser.rb
 - lib/language_configs.rb
 - lib/markdown/run/version.rb
+- lib/markdown_file_writer.rb
+- lib/markdown_processor.rb
+- lib/markdown_run.rb
 - markdown-run-sample.md
-- test_markdown_exec.rb
 homepage: https://github.com/aurelienbottazini/markdown-run
 licenses:
 - MIT
@@ -79,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Run code blocks in Markdown files

data/test_markdown_exec.rb

@@ -1,297 +0,0 @@
-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"
-
-# Load the main script to access process_markdown_file_main
-load File.expand_path("./exe/markdown-run", __dir__)
-
-# --- 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
-
-  def test_run_functionality
-    # Test 1: Default behavior (run=true implicit) should execute new code block
-    md_content_default = <<~MARKDOWN
-      ```ruby
-      puts "Should execute by default"
-      ```
-    MARKDOWN
-    create_md_file(md_content_default)
-    process_markdown_file_main(@test_md_file_path)
-
-    file_content = read_md_file
-    assert file_content.include?("```ruby RESULT"), "Default behavior should create result block"
-    assert file_content.include?("Should execute by default"), "Default behavior should execute and show output"
-
-    # Test 2: run=true explicit should execute new code block
-    md_content_run_true = <<~MARKDOWN
-      ```ruby run=true
-      puts "Should execute with run=true"
-      ```
-    MARKDOWN
-    create_md_file(md_content_run_true)
-    process_markdown_file_main(@test_md_file_path)
-
-    file_content = read_md_file
-    assert file_content.include?("```ruby RESULT"), "run=true should create result block"
-    assert file_content.include?("Should execute with run=true"), "run=true should execute and show output"
-
-    # Test 3: run=false should not execute at all (no result block created)
-    md_content_run_false = <<~MARKDOWN
-      ```ruby run=false
-      puts "Should not execute"
-      puts "No result block should be created"
-      ```
-    MARKDOWN
-    create_md_file(md_content_run_false)
-    process_markdown_file_main(@test_md_file_path)
-
-    file_content = read_md_file
-    refute file_content.include?("```ruby RESULT"), "run=false should not create result block"
-    refute file_content.match?(/puts "Should not execute"\n# >>/), "run=false should not execute code (no # >> output)"
-    assert file_content.include?("puts \"Should not execute\""), "run=false should preserve original code block"
-
-    # Test 4: run=false with existing result block should skip execution but preserve result
-    md_content_run_false_with_result = <<~MARKDOWN
-      ```ruby run=false
-      puts "Should not execute"
-      ```
-
-      ```ruby RESULT
-      Old result that should be preserved
-      ```
-    MARKDOWN
-    create_md_file(md_content_run_false_with_result)
-    process_markdown_file_main(@test_md_file_path)
-
-    file_content = read_md_file
-    assert file_content.include?("Old result that should be preserved"), "run=false should preserve existing result"
-    refute file_content.match?(/puts "Should not execute"\n# >>/), "run=false should not create new execution output"
-
-    # Test 5: Combined options - run=false with rerun=true should still not execute
-    md_content_combined = <<~MARKDOWN
-      ```ruby run=false rerun=true
-      puts "Should not execute despite rerun=true"
-      ```
-
-      ```ruby RESULT
-      Existing result
-      ```
-    MARKDOWN
-    create_md_file(md_content_combined)
-    process_markdown_file_main(@test_md_file_path)
-
-    file_content = read_md_file
-    assert file_content.include?("Existing result"), "run=false should override rerun=true"
-    refute file_content.match?(/puts "Should not execute despite rerun=true"\n# >>/), "run=false should prevent execution even with rerun=true"
-
-    # Test 6: Combined options - run=true with rerun=false should execute if no result exists
-    md_content_run_true_rerun_false = <<~MARKDOWN
-      ```ruby run=true rerun=false
-      puts "Should execute because no result exists"
-      ```
-    MARKDOWN
-    create_md_file(md_content_run_true_rerun_false)
-    process_markdown_file_main(@test_md_file_path)
-
-    file_content = read_md_file
-    assert file_content.include?("```ruby RESULT"), "run=true rerun=false should execute when no result exists"
-    assert file_content.include?("Should execute because no result exists"), "run=true rerun=false should show output when no result exists"
-  end
-end