markdown-run 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c11a9addb3e251e9830fe2126d2d752dc8c04c879b607d1ee0ad80998d51b294
-  data.tar.gz: '014954e8178d28729dfa86350a9e92aa91010892e6d177a5f7616dfd0e9ad72b'
+  metadata.gz: 921255b90c33af932d6ac33284a24d4f0fc61b5fe3ec0afb45f912c8fcc6e678
+  data.tar.gz: 076f40ed6dc79bafbc7bdba3198f39fabf56754d74e1ef6bd38f451cc34ccafd
 SHA512:
-  metadata.gz: 5a26f680f607d52d7ceb0b0f31cca84af2a811ed2a70f6f73f9ab6ae3f9032f9135943c9e765df4d9714cbbd766179de14bab8006148e1d65d27a26388dd935c
-  data.tar.gz: 3ed109437211b62afd2dcdf1469e3103db9bd36a13be207f0ea636d67163c269e4a199e9a4b901ed4f7756319b5aa9c20f00e7613106be463c5139965f209fbf
+  metadata.gz: 01c7168af16a7788b80acb43553f2ae81ee0a8d1dfe7bf7cf048a6c7a77a898257fb1308b277282d9494464189322eab67b164a8c694f0aa8437db8bc8654d36
+  data.tar.gz: 4f719733a2fbea191224f8c0fbcbb44f559d2d9bec1352f9d6c6caf851550593eb3622b2453cfdd584513d3b186f085157cf17cde5dfe61706f60a6d8b2e8050

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.1.8] - 2025-06-01
+
+- Added run option
+
 ## [0.1.7] - 2025-06-01
 
 - Added rerun functionality

data/README.md

@@ -54,12 +54,23 @@ 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
+- `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
 
-example:
+Options can be combined. If `run=false` is specified, the code block will not execute regardless of the `rerun` setting.
 
-```js rerun=false
-console.log("hello world");
+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

data/exe/markdown-run

@@ -89,6 +89,7 @@ class MarkdownProcessor
     @current_block_lang = ""
     @current_code_content = ""
     @current_block_rerun = false
+    @current_block_run = true
     @aliases = {}
   end
 
@@ -204,6 +205,16 @@ class MarkdownProcessor
     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
@@ -271,6 +282,7 @@ class MarkdownProcessor
     @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
@@ -296,6 +308,11 @@ 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)
 
@@ -342,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."
@@ -379,6 +402,7 @@ class MarkdownProcessor
     @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.7"
+    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
@@ -201,4 +204,94 @@ class TestMarkdownExec < Minitest::Test
     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.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Aurélien Bottazini