markdown-run 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac1a715b89896b392f75d2222bda1a4f5899dda9da7a12871548faee8d3c86bb
-  data.tar.gz: 5fd7954991346dd940594b264d5b162a91451ed7c89e7510eb6b0315d2c39195
+  metadata.gz: 921255b90c33af932d6ac33284a24d4f0fc61b5fe3ec0afb45f912c8fcc6e678
+  data.tar.gz: 076f40ed6dc79bafbc7bdba3198f39fabf56754d74e1ef6bd38f451cc34ccafd
 SHA512:
-  metadata.gz: 1ee917248f47a0ccc7770fdd419fe3d65dfe2ca99c79d44efe0b46a9fd599761e0c218e622c39989c806de07f92480c0de1e4c7c869d7d9f7db2439a9fb70fd0
-  data.tar.gz: 2c3eeb35fee738e405c30bdbb5fee6e8cad6bb0acc599c1115ad77315179e28dd37c6aace1b125c5306d9702b2cbc4c2dec1394695c9908a73853917f73a1fa3
+  metadata.gz: 01c7168af16a7788b80acb43553f2ae81ee0a8d1dfe7bf7cf048a6c7a77a898257fb1308b277282d9494464189322eab67b164a8c694f0aa8437db8bc8654d36
+  data.tar.gz: 4f719733a2fbea191224f8c0fbcbb44f559d2d9bec1352f9d6c6caf851550593eb3622b2453cfdd584513d3b186f085157cf17cde5dfe61706f60a6d8b2e8050

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.1.8] - 2025-06-01
+
+- Added run option
+
+## [0.1.7] - 2025-06-01
+
+- Added rerun functionality
+
 ## [0.1.6] - 2025-06-01
 
 - Refactor code to state pattern

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,9 +52,31 @@ example vscode keybinding
   },
 ```
 
+### Code block options
+
+- `run=true` or `run=false` to control whether a code block should be executed at all. `run=true` is the default if not specified
+- `rerun=true` or `rerun=false` to control whether a code block should be re-executed if a result block already exists. `rerun=false` is the default if not specified
+
+Options can be combined. If `run=false` is specified, the code block will not execute regardless of the `rerun` setting.
+
+Examples:
+
+```js run=false
+console.log("This will not execute at all");
+```
+
+```js rerun=true
+console.log("This will re-execute even if result exists");
+```
+
+```js run=true rerun=false
+console.log("This will execute only if no result exists");
+```
+
 ## 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:
 

data/exe/markdown-run

@@ -88,6 +88,8 @@ class MarkdownProcessor
     @state = :outside_code_block
     @current_block_lang = ""
     @current_code_content = ""
+    @current_block_rerun = false
+    @current_block_run = true
     @aliases = {}
   end
 
@@ -193,6 +195,26 @@ class MarkdownProcessor
     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 parse_run_option(options_string)
+    return true unless options_string
+    
+    # Match run=true or run=false
+    match = options_string.match(/run\s*=\s*(true|false)/i)
+    return true unless match
+    
+    match[1].downcase == "true"
+  end
+
   def safe_enum_operation(file_enum, operation)
     file_enum.send(operation)
   rescue StopIteration
@@ -221,11 +243,12 @@ class MarkdownProcessor
   def handle_outside_code_block(current_line, file_enum)
     if current_line.match?(/^```ruby\s+RESULT$/i)
       handle_existing_ruby_result_block(current_line, file_enum)
-    elsif (match_data = current_line.match(/^```(\w+)$/i))
+    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)
+        start_code_block(current_line, lang, options_string)
       else
         @output_lines << current_line
       end
@@ -255,9 +278,11 @@ class MarkdownProcessor
     @state = :inside_result_block
   end
 
-  def start_code_block(current_line, lang)
+  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
@@ -273,6 +298,7 @@ class MarkdownProcessor
     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)
@@ -282,17 +308,37 @@ class MarkdownProcessor
   end
 
   def decide_execution(file_enum)
+    # If run=false, skip execution entirely (no result block creation)
+    unless @current_block_run
+      return { execute: false, lines_to_pass_through: [] }
+    end
+
     peek1 = peek_next_line(file_enum)
     expected_header_regex = result_block_regex(@current_block_lang)
 
     if line_matches_pattern?(peek1, expected_header_regex)
-      return { execute: false, lines_to_pass_through: [file_enum.next] }
+      # 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)
-        return { execute: false, lines_to_pass_through: [consumed_blank_line, file_enum.next] }
+        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
@@ -313,6 +359,12 @@ class MarkdownProcessor
   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
+
     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."
@@ -334,9 +386,23 @@ class MarkdownProcessor
     end
   end
 
+  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
+
   def reset_code_block_state
     @state = :outside_code_block
     @current_code_content = ""
+    @current_block_rerun = false
+    @current_block_run = true
   end
 end
 

data/lib/markdown/run/version.rb

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

data/test_markdown_exec.rb

@@ -10,6 +10,9 @@ 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
@@ -131,4 +134,164 @@ class TestMarkdownExec < Minitest::Test
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Aurélien Bottazini
@@ -57,11 +57,11 @@ files:
 - lib/markdown/run/version.rb
 - markdown-run-sample.md
 - test_markdown_exec.rb
-homepage: https://rubygems.org/gems/markdown-run
+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: