rundoc 4.1.4 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83fd435266e63543e96c3e24fc4d116cd043f2c89e396b8839d283eace07248a
-  data.tar.gz: 9818843a327f3ed3c4a46548db1dc8e9b2c706824716749d7a173563a752d6ae
+  metadata.gz: 498d5109daa7abb733fc5c27cf583bb1c84cc7b92bbccaaf9e005a51a6ec0555
+  data.tar.gz: fc72016241033a945486b5fa893b3f2cad0c8b3c7a2c44eab3f964adb7308f9e
 SHA512:
-  metadata.gz: f5972a3213f3700659aa2d9ca602821f0cb443e9e56120b5e43485da6b0240a4b7b998dea1b0637b470ac098d0fab5c7ee7922b056eebfd08575c0177bc312d9
-  data.tar.gz: c58f0fdf37e46817eb28871e1136811b0dd2c2a12925948e461f286b47de8c2b3bae1ba06345956908ac09c859ad0d1fe284d10a2c2a019516ba07a134103d07
+  metadata.gz: 5af654672de3e6051ec46377052c55b55207ce13eb29cf977d1cf793291e953d28e842fd79b0f0972f8eb83a98c6671c1834a5ac75f20da795eb686a99a02c52
+  data.tar.gz: b2acdf08759aa0c6f73410a00a4ad387da198f1f4497228c69d27dd799799e12107cc421c8f3fd5242f9517dbfd2565e71b56e2b3a6ffd77ffd879906c902d65

data/.github/workflows/ci.yml

@@ -11,9 +11,10 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
-          - 3.1
           - 3.2
           - 3.3
+          - 3.4
+          - "4.0"
           - head
     steps:
       - name: Checkout code
@@ -34,6 +35,7 @@ jobs:
       matrix:
         ruby:
           - 3.3
+          - "4.0"
           - head
     steps:
       - name: Checkout code

data/.standard.yml

@@ -1,6 +1,6 @@
 fix: true               # default: false
 parallel: true          # default: false
 format: progress        # default: Standard::Formatter
-ruby_version: 3.1       # default: RUBY_VERSION
+ruby_version: 3.2       # default: RUBY_VERSION
 ignore:                 # default: []
   - 'test/fixtures/**/*'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## HEAD
 
+## 6.0.0
+
+- Added: `rundoc.ensure_later(dir: :cwd)` command to register cleanup blocks that run on every build (success and failure). Useful for guaranteed resource teardown (e.g., destroying Heroku apps). Multiple blocks execute in order; failures in one block do not stop the rest.
+- Changed: The ruby context in `rundoc` and `rundoc.configure` commands is now the same binding as the default ERB evaluation. This means that methods can be defined in one and used in both.
+
+## 5.0.0
+
+- Added comment syntax. Use an octothorpe (`#`) after the visibility markers to comment out any commands and make them a no-op.
+- Changed: Minimum Ruby version is now 3.2 (Ruby 3.1 reached EOL in March 2025).
+- Changed: All code commands now use an Args + Runner class pattern. `register_code_command` now requires keyword arguments: `keyword:`, `args_klass:`, and `runner_klass:`.
+- Fix: `seattle_method` parser rule no longer matches across newlines. Previously, a command with no same-line arguments (e.g. `:::>> rundoc`) would consume the next line as its argument, losing the newline between content lines. (https://github.com/zombocom/rundoc/pull/118)
+
 ## 4.1.4
 
 - Fix: Net::ReadTimeout errors on `website.visit` are now retried by default (https://github.com/zombocom/rundoc/pull/103)

data/README.md

@@ -98,6 +98,8 @@ This will generate a project folder with your project in it, and a markdown `REA
   - [website.screenshot](#screenshots)
 - Configure RunDOC
   - [rundoc.configure](#configure)
+  - [rundoc.ensure_later](#ensure_later)
+  - [rundoc](#configure) an alias for `rundoc.configure`
 - Import and compose documents
   - [rundoc.require](#compose-multiple-rundoc-documents)
 
@@ -616,7 +618,7 @@ If you need to specify project specific environment variables create a file call
 
 ## Configure
 
-You can configure your docs in your docs use the `RunDOC` command
+You can configure your docs in your docs use the `RunDOC` command via `rundoc.configure` (or alias `rundoc`):
 
     ```
     :::-- rundoc.configure
@@ -624,6 +626,30 @@ You can configure your docs in your docs use the `RunDOC` command
 
 Note: Make sure you run this as a hidden command (with `-`).
 
+This will give you a Ruby codeblock that executes and gives you access to `Rundoc.configure do |config|` to configure things about your build (such as modifying your markdown document after successful builds).
+
+**Define and Re-use logic**
+
+Since it's **just ruby** :tm: you can also use it to define shared logic that can be re-used in ERB templates. For example:
+
+      ```
+      :::-- rundoc
+      def run!(command, quiet: false, error_on_fail: true)
+        puts "Running `#{command}`" unless quiet
+        output = `#{command}`
+        puts "Command `#{command}` output:\n#{output}" unless quiet
+        if error_on_fail && !$?.success?
+          raise "Error running #{command}. Output:\n#{output}"
+        end
+        output
+      end
+      ```
+
+      ```
+      :::-> print.erb
+      Hello <%= run!("heroku whoami") %>!
+      ```
+
 **After Build**
 
 This will eval any code you put under that line (in Ruby) when the build was successful but before the contents are finalized on disk. If you want to run some code after you're done building your docs you could use `Rundoc.configure` block and call the `after_build` method like this:
@@ -658,38 +684,100 @@ Sometimes sensitive info like usernames, email addresses, or passwords may be in
 
 This command `filter_sensitive` can be called multiple times with different values. Since the config is in Ruby you could iterate over an array of sensitive data
 
+## Ensure Later
+
+Run a script on EVERY build (success and failure). Used to guarantee resources are cleaned up.
+
+- Arguments
+  - `dir:` The directory where the script will be run. Must be one of these values:
+    - `:cwd` The directory where the command is first invoked. If this directory does not exist when the `rundoc.ensure_later` is invoked, it will raise an error.
+    - `:rundoc_root` The tmp directory where the script is being executed. Useful if the directory where the `rundoc.ensure_later` is defined, is deleted by the rundoc script.
+
+For example:
+
+    ```
+    :::>> $ heroku create
+    :::-- rundoc
+    @app_name = run!("heroku info --json | jq -r '.app.name'").strip
+
+    def app_name
+      @app_name
+    end
+    ```
+
+    ```ruby
+    :::-- rundoc.ensure_later(dir: :cwd)
+    if run!("heroku apps").include?(app_name)
+      puts "Cleaning up web app #{app_name}"
+      run!("heroku apps:destroy #{app_name} --confirm #{app_name}")
+    else
+      puts "App `#{app_name}` already cleaned, nothing to do"
+    end
+    ```
+
+The output of this will not be included in the document. Multiple ensure blocks can be defined and will execute in the order of their definition. Since they'll be executed EVERY time, logic must handle both success and failure cases. This execution occurs before the temp directory is removed, and before any background task shutdown ensure blocks are triggered.
+
+If a build is successful, but an `ensure_later` block fails, the build will be considered a failure. A failure in one block will not stop the rest from executing.
+
 ## Writing a new command
 
+> Note: This is an advanced topic and this interface is unstable.
+
 Rundoc does not have a stable internal command interface. You can define your own commands, but unless it is committed in this repo, it may break on a minor version change.
 
 To add a new command it needs to be parsed and called. Examples of commands being implemented are seen in `lib/rundoc/code_command`.
 
-A new command needs to be registered:
+Each command is split into two classes: an **Args** class that handles argument parsing/validation and a **Runner** class that handles execution. Both must be registered:
 
+```ruby
+Rundoc.register_code_command(
+  keyword: :lol,
+  args_klass: Rundoc::CodeCommand::LolArgs,
+  runner_klass: Rundoc::CodeCommand::LolRunner
+)
 ```
-Rundoc.register_code_command(:lol, Rundoc::CodeCommand::Lol)
-```
 
-They should inherit from Rundoc::CodeCommand:
+The Args class is a plain Ruby class. Its initialize method receives input from the document and exposes parsed values via `attr_reader`:
+
+```ruby
+class Rundoc::CodeCommand::LolArgs
+  attr_reader :message
 
+  def initialize(message)
+    @message = message
+  end
+end
 ```
-class Rundoc::CodeCommand::Lol < Rundoc::CodeCommand
-  def initialize(line)
+
+The Runner class is namespaced under `Rundoc::CodeCommand` and receives the args instance via `user_args:`:
+
+```ruby
+class Rundoc::CodeCommand::LolRunner
+  def initialize(user_args:, **)
+    @message = user_args.message
+  end
+
+  def to_md(env = {})
+    ""
+  end
+
+  def call(env = {})
+    @message
   end
 end
 ```
 
-The initialize method is called with input from the document. The command is rendered (`:::>-`) by the output of the `def call` method. The contents produced by the command (`:::->`) are rendered by the `def to_md` method.
+The command is rendered (`:::>-`) by the output of the `def call` method. The contents produced by the command (`:::->`) are rendered by the `def to_md` method.
 
 The syntax for commands is ruby-ish but it is a custom grammar implemented in `lib/peg_parser.rb` for more info on manipulating the grammar see this tutorial on how I added keword-like/hash-like syntax https://github.com/schneems/implement_ruby_hash_syntax_with_parslet_example.
 
-Command initialize methods natively support:
+Args class initialize methods natively support:
 
 - Barewords as a single string input
 - Keyword arguments
 - A combination of the two
 
-Anything that is passed to the command via "stdin" is available via a method `self.contents`. The interplay between the input and `self.contents` is not strongly defined.
+Anything that is passed to the command via "stdin" is available on the Runner via a method `self.contents`. The interplay between the input and `self.contents` is not strongly defined.
 
 ## Copyright
 

data/lib/rundoc/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rundoc
   class CLI
     module DEFAULTS
@@ -132,6 +134,9 @@ module Rundoc
     end
 
     def call
+      build_success = false
+      ensure_later_errors = []
+
       io.puts "## Running your docs"
       load_dotenv
       check_directories_empty!
@@ -159,10 +164,15 @@ module Rundoc
       Dir.chdir(execution_context.output_dir) do
         parser = Rundoc::Document.new(
           source_contents,
-          context: execution_context
+          context: execution_context,
+          io: io
         )
         output = begin
-          parser.to_md
+          begin
+            parser.to_md
+          ensure
+            ensure_later_errors = Rundoc.run_ensure_later(io: io)
+          end
         rescue StandardError, SignalException => e
           io.puts "Received exception: #{e.inspect}, cleaning up before re-raise"
           on_fail
@@ -171,6 +181,8 @@ module Rundoc
 
         on_success(output)
       end
+
+      build_success = true
     ensure
       # Stop any hanging background tasks
       Rundoc::CodeCommand::Background::ProcessSpawn.tasks.each do |name, task|
@@ -186,6 +198,10 @@ module Rundoc
           description: "tmp working directory"
         )
       end
+
+      if ensure_later_errors.any? && build_success
+        raise ensure_later_errors.first
+      end
     end
 
     private def clean_dir(dir:, description:)

data/lib/rundoc/code_command/background/log/clear.rb

@@ -1,7 +1,17 @@
+# frozen_string_literal: true
+
 class Rundoc::CodeCommand::Background::Log
-  class Clear < Rundoc::CodeCommand
+  class ClearArgs
+    attr_reader :name
+
     def initialize(name:)
       @name = name
+    end
+  end
+
+  class ClearRunner
+    def initialize(user_args:, render_command:, render_result:, io: nil, contents: nil)
+      @name = user_args.name
       @background = nil
     end
 
@@ -19,4 +29,4 @@ class Rundoc::CodeCommand::Background::Log
     end
   end
 end
-Rundoc.register_code_command(:"background.log.clear", Rundoc::CodeCommand::Background::Log::Clear)
+Rundoc.register_code_command(keyword: :"background.log.clear", args_klass: Rundoc::CodeCommand::Background::Log::ClearArgs, runner_klass: Rundoc::CodeCommand::Background::Log::ClearRunner)

data/lib/rundoc/code_command/background/log/read.rb

@@ -1,7 +1,17 @@
+# frozen_string_literal: true
+
 class Rundoc::CodeCommand::Background::Log
-  class Read < Rundoc::CodeCommand
+  class ReadArgs
+    attr_reader :name
+
     def initialize(name:)
       @name = name
+    end
+  end
+
+  class ReadRunner
+    def initialize(user_args:, render_command:, render_result:, io: nil, contents: nil)
+      @name = user_args.name
       @background = nil
     end
 
@@ -18,4 +28,4 @@ class Rundoc::CodeCommand::Background::Log
     end
   end
 end
-Rundoc.register_code_command(:"background.log.read", Rundoc::CodeCommand::Background::Log::Read)
+Rundoc.register_code_command(keyword: :"background.log.read", args_klass: Rundoc::CodeCommand::Background::Log::ReadArgs, runner_klass: Rundoc::CodeCommand::Background::Log::ReadRunner)

data/lib/rundoc/code_command/background/process_spawn.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "shellwords"
 require "timeout"
 require "fileutils"
@@ -126,7 +128,7 @@ class Rundoc::CodeCommand::Background
       Process.kill("TERM", -Process.getpgid(@pid))
       Process.wait(@pid)
     rescue Errno::ESRCH => e
-      puts "Error stopping process (command: #{command}): #{e}"
+      print_io&.puts "Error stopping process (command: #{command}): #{e}"
     ensure
       print_io&.puts "Log contents for `#{command}`:\n#{@log.read}"
     end

data/lib/rundoc/code_command/background/start.rb

@@ -1,18 +1,37 @@
+# frozen_string_literal: true
+
 require "tempfile"
 
 class Rundoc::CodeCommand::Background
-  class Start < Rundoc::CodeCommand
+  class StartArgs
+    attr_reader :command, :name, :wait, :timeout, :log, :out, :allow_fail
+
     def initialize(command, name:, wait: nil, timeout: 5, log: Tempfile.new("log"), out: "2>&1", allow_fail: false)
-      @timeout = timeout
       @command = command
       @name = name
       @wait = wait
-      @allow_fail = allow_fail
+      @timeout = timeout
       @log = log
-      @redirect = out
+      @out = out
+      @allow_fail = allow_fail
+    end
+  end
+
+  class StartRunner
+    attr_reader :io
+
+    def initialize(user_args:, render_command:, render_result:, io:, contents: nil)
+      @timeout = user_args.timeout
+      @command = user_args.command
+      @name = user_args.name
+      @wait = user_args.wait
+      @allow_fail = user_args.allow_fail
+      @log = user_args.log
+      @redirect = user_args.out
       FileUtils.touch(@log)
 
       @background = nil
+      @io = io
     end
 
     def background
@@ -22,7 +41,7 @@ class Rundoc::CodeCommand::Background
         log: @log,
         out: @redirect
       ).tap do |spawn|
-        puts "Spawning commmand: `#{spawn.command}`"
+        io.puts "Spawning commmand: `#{spawn.command}`"
         ProcessSpawn.add(@name, spawn)
       end
     end
@@ -44,4 +63,4 @@ class Rundoc::CodeCommand::Background
   end
 end
 
-Rundoc.register_code_command(:"background.start", Rundoc::CodeCommand::Background::Start)
+Rundoc.register_code_command(keyword: :"background.start", args_klass: Rundoc::CodeCommand::Background::StartArgs, runner_klass: Rundoc::CodeCommand::Background::StartRunner)

data/lib/rundoc/code_command/background/stdin_write.rb

@@ -1,14 +1,27 @@
+# frozen_string_literal: true
+
 class Rundoc::CodeCommand::Background
-  # Will send contents to the background process via STDIN along with a newline
-  #
-  #
-  class StdinWrite < Rundoc::CodeCommand
+  class StdinWriteArgs
+    attr_reader :contents, :name, :wait, :timeout, :ending
+
     def initialize(contents, name:, wait:, timeout: 5, ending: $/)
       @contents = contents
-      @ending = ending
-      @wait = wait
       @name = name
-      @timeout_value = Integer(timeout)
+      @wait = wait
+      @timeout = Integer(timeout)
+      @ending = ending
+    end
+  end
+
+  class StdinWriteRunner
+    attr_reader :contents
+
+    def initialize(user_args:, render_command:, render_result:, io: nil, contents: nil)
+      @contents = user_args.contents
+      @ending = user_args.ending
+      @wait = user_args.wait
+      @name = user_args.name
+      @timeout_value = user_args.timeout
       @contents_written = nil
       @background = nil
     end
@@ -38,4 +51,4 @@ class Rundoc::CodeCommand::Background
     end
   end
 end
-Rundoc.register_code_command(:"background.stdin_write", Rundoc::CodeCommand::Background::StdinWrite)
+Rundoc.register_code_command(keyword: :"background.stdin_write", args_klass: Rundoc::CodeCommand::Background::StdinWriteArgs, runner_klass: Rundoc::CodeCommand::Background::StdinWriteRunner)

data/lib/rundoc/code_command/background/stop.rb

@@ -1,7 +1,17 @@
+# frozen_string_literal: true
+
 class Rundoc::CodeCommand::Background
-  class Stop < Rundoc::CodeCommand
+  class StopArgs
+    attr_reader :name
+
     def initialize(name:)
       @name = name
+    end
+  end
+
+  class StopRunner
+    def initialize(user_args:, render_command:, render_result:, io: nil, contents: nil)
+      @name = user_args.name
       @background = nil
     end
 
@@ -19,4 +29,4 @@ class Rundoc::CodeCommand::Background
     end
   end
 end
-Rundoc.register_code_command(:"background.stop", Rundoc::CodeCommand::Background::Stop)
+Rundoc.register_code_command(keyword: :"background.stop", args_klass: Rundoc::CodeCommand::Background::StopArgs, runner_klass: Rundoc::CodeCommand::Background::StopRunner)

data/lib/rundoc/code_command/background/wait.rb

@@ -1,9 +1,21 @@
+# frozen_string_literal: true
+
 class Rundoc::CodeCommand::Background
-  class Wait < Rundoc::CodeCommand
+  class WaitArgs
+    attr_reader :name, :wait, :timeout
+
     def initialize(name:, wait:, timeout: 5)
       @name = name
       @wait = wait
-      @timeout_value = Integer(timeout)
+      @timeout = Integer(timeout)
+    end
+  end
+
+  class WaitRunner
+    def initialize(user_args:, render_command:, render_result:, io: nil, contents: nil)
+      @name = user_args.name
+      @wait = user_args.wait
+      @timeout_value = user_args.timeout
       @background = nil
     end
 
@@ -21,4 +33,4 @@ class Rundoc::CodeCommand::Background
     end
   end
 end
-Rundoc.register_code_command(:"background.wait", Rundoc::CodeCommand::Background::Wait)
+Rundoc.register_code_command(keyword: :"background.wait", args_klass: Rundoc::CodeCommand::Background::WaitArgs, runner_klass: Rundoc::CodeCommand::Background::WaitRunner)

data/lib/rundoc/code_command/background.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Rundoc::CodeCommand::Background
 end
 

data/lib/rundoc/code_command/bash/cd.rb

@@ -1,31 +1,25 @@
-class Rundoc::CodeCommand::Bash
-  # special purpose class to persist cd behavior across the entire program
-  # we change the directory of the parent program (rundoc) rather than
-  # changing the directory of a spawned child (via exec, ``, system, etc.)
-  class Cd < Rundoc::CodeCommand::Bash
-    def initialize(line)
+# frozen_string_literal: true
+
+class Rundoc::CodeCommand::BashRunner
+  class Cd < Rundoc::CodeCommand::BashRunner
+    def initialize(line, io: $stdout)
+      @io = io
       @line = line
     end
 
-    # Ignore duplicate chdir warnings "warning: conflicting chdir during another chdir block"
-    def supress_chdir_warning
-      old_stderr = $stderr
-      capture_stderr = StringIO.new
-      $stderr = capture_stderr
+    def suppress_chdir_warning
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
       yield
     ensure
-      if old_stderr
-        $stderr = old_stderr
-        capture_string = capture_stderr.string
-        warn capture_string if capture_string.each_line.count > 1 || !capture_string.include?("conflicting chdir")
-      end
+      $VERBOSE = old_verbose
     end
 
     def call(env)
       line = @line.sub("cd", "").strip
-      puts "running $ cd #{line}"
+      @io.puts "running $ cd #{line}"
 
-      supress_chdir_warning do
+      suppress_chdir_warning do
         Dir.chdir(line)
       end
 

data/lib/rundoc/code_command/bash.rb

@@ -1,18 +1,32 @@
-class Rundoc::CodeCommand::Bash < Rundoc::CodeCommand
-  # line = "cd ..""
-  # line = "pwd"
-  # line = "ls"
+# frozen_string_literal: true
+
+class Rundoc::CodeCommand::BashArgs
+  attr_reader :line
+
   def initialize(line)
     @line = line
-    @contents = ""
+  end
+end
+
+class Rundoc::CodeCommand::BashRunner
+  attr_reader :io, :contents
+
+  def initialize(user_args:, render_command:, render_result:, io:, contents: nil)
+    @io = io
+    @contents = contents.dup if contents && !contents.empty?
+    @line = user_args.line
     @delegate = case @line.split(" ").first.downcase
     when "cd"
-      Cd.new(@line)
+      Cd.new(@line, io: io)
     else
       false
     end
   end
 
+  def raise_on_error?
+    true
+  end
+
   def to_md(env = {})
     return @delegate.to_md(env) if @delegate
 
@@ -34,30 +48,40 @@ class Rundoc::CodeCommand::Bash < Rundoc::CodeCommand
     cmd = "(#{cmd}) 2>&1"
     msg = "Running: $ '#{cmd}'"
     msg << " with stdin: '#{stdin.inspect}'" if stdin && !stdin.empty?
-    puts msg
+    io.puts msg
 
-    result = ""
-    IO.popen(cmd, "w+") do |io|
-      io << stdin if stdin
-      io.close_write
+    result = +""
+    IO.popen(cmd, "w+") do |pipe|
+      pipe << stdin if stdin
+      pipe.close_write
 
-      until io.eof?
-        buffer = io.gets
-        puts "    #{buffer}"
+      until pipe.eof?
+        buffer = pipe.gets
+        io.puts "    #{buffer}"
 
         result << sanitize_escape_chars(buffer)
       end
     end
 
-    unless $?.success?
-      raise "Command `#{@line}` exited with non zero status: #{result}" unless keyword.to_s.include?("fail")
+    if raise_on_error? && !$?.success?
+      raise "Command `#{@line}` exited with non zero status: #{result}"
     end
     result
   end
 end
 
-Rundoc.register_code_command(:bash, Rundoc::CodeCommand::Bash)
-Rundoc.register_code_command(:"$", Rundoc::CodeCommand::Bash)
-Rundoc.register_code_command(:"fail.$", Rundoc::CodeCommand::Bash)
+class Rundoc::CodeCommand::BashRunnerFailOk < Rundoc::CodeCommand::BashRunner
+  def raise_on_error?
+    false
+  end
+end
+
+Rundoc.register_code_command(keyword: :bash, args_klass: Rundoc::CodeCommand::BashArgs, runner_klass: Rundoc::CodeCommand::BashRunner)
+Rundoc.register_code_command(keyword: :"$", args_klass: Rundoc::CodeCommand::BashArgs, runner_klass: Rundoc::CodeCommand::BashRunner)
+Rundoc.register_code_command(
+  keyword: :"fail.$",
+  args_klass: Rundoc::CodeCommand::BashArgs,
+  runner_klass: Rundoc::CodeCommand::BashRunnerFailOk
+)
 
 require "rundoc/code_command/bash/cd"

data/lib/rundoc/code_command/comment.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Rundoc::CodeCommand::CommentArgs
+  attr_reader :line
+
+  def initialize(line = nil)
+    @line = line
+  end
+end
+
+class Rundoc::CodeCommand::CommentRunner
+  def initialize(user_args:, render_command:, render_result:, io:, contents: nil)
+    @io = io
+    @line = user_args&.line
+    @contents = contents
+  end
+
+  def call(env = {})
+    @io.puts "Skipping command (commented out): # #{@line}\n#{@contents}".strip
+    ""
+  end
+
+  def to_md(env = {})
+    ""
+  end
+end
+
+Rundoc.register_code_command(
+  keyword: :"#",
+  args_klass: Rundoc::CodeCommand::CommentArgs,
+  runner_klass: Rundoc::CodeCommand::CommentRunner,
+  always_hidden: true
+)