rundoc 3.1.0 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e89c8353e4727ae39613f24c38bf3a69f027c6d1e533e64e281a588405ff57f
-  data.tar.gz: 34df7f620c446901596deec889b9c8f785bd10e0441a54e1904b799ae9b8f0cd
+  metadata.gz: 2c2298eda9572df3a7acbb3d9a81ba5bdc2b5c80ba5ebc913d22308780aeff47
+  data.tar.gz: d9b2f86f1cfe167657f4d0d76c23f44340b6f992b959864401c1496241fbcbea
 SHA512:
-  metadata.gz: beb56a43157798ba53c4e63d715fd75892bc6d2b93bd0b8d379168c4dcc8807af3c31a5b8ac1a8af6215fa738bad6f8b4e2df525bae1c6590ef8bf7d3e94b29d
-  data.tar.gz: 8f6555c197fc600cc5cbf60af7d558213f50ec2a01b3d72f57e09eec628ba3169a512230b9ae106071afb2b536a6b7a314b3a8a832eb64e158565d977ab28e06
+  metadata.gz: 0db0233ad2b0773f453f2eb487bebc2d3cd3fb114f44aaf2295206250722ca3c4a29ceb558d1546de88865cdb120bc113ac828397b9a50c04c06b50e9aa0a0d2
+  data.tar.gz: d89e65b47bca1d1bd76f5894621c2ea53a957215008b043e3be6e672e87093e3a6af3a8696c9ab03e1dcf2ebb39b8362b882bc38235a0e4c1718744f30d2592c

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## HEAD
 
+## 3.1.2
+
+- Fix: Using `rundoc.require` inside of a document that was `rundoc.require`-d now sources files from the correct relative document path (https://github.com/zombocom/rundoc/pull/84)
+- Fix: `rundoc <file> --with-contents <dir>` now expands the path passed in to the `--with-contents` so relative paths can safely be used (https://github.com/zombocom/rundoc/pull/83)
+
+## 3.1.1
+
+- Fix: Include all code sections in the event of a failure, not just the last one (https://github.com/zombocom/rundoc/pull/71)
+
 ## 3.1.0
 
 - Add: `--with-contents` flag that accepts a directory. The **contents** of the directory (and not the directory itself) will be copied into the working dir before execution. This is useful for debugging a single rundoc step. ()

data/README.md

@@ -88,6 +88,7 @@ This will generate a project folder with your project in it, and a markdown `REA
   - [background.stop](#background)
   - [background.log.read](#background)
   - [background.log.clear](#background)
+  - [background.wait](#background)
 - Take screenshots
   - [website.visit](#screenshots)
   - [website.nav](#screenshots)
@@ -410,6 +411,13 @@ To start a process, pass in the command as the first arg, and give it a name (so
 :::>> background.start("rails server", name: "server")
 ```
 
+- Arguments
+  - name: Identifier of the background process, used in later invocations.
+  - wait (Optional): A string to wait for before continuing. This is useful to block moving on until an event happend such as a server was booted or web request was received. Also see `background.wait`
+  - timeout (Optional): A number of seconds to wait for a given string to be found in the logs.
+  - out (Optional): A bash redirect. Defaults to `2>&1` to merge stderr and stdout together.
+  - allow_fail (Optional): Set to `true` if the command exiting shouldn't halt doc generation. Poorly named, may be renamed in the future.
+
 You can make the background process wait until it receives a certain string in the logs. For instance to make sure that the server is fully booted:
 
 ```
@@ -422,18 +430,38 @@ You can stop the process by referencing the name:
 :::-- background.stop(name: "server")
 ```
 
+- Arguments
+  - name
+
 You can also get the log contents:
 
 ```
 :::>> background.log.read(name: "server")
 ```
 
+- Arguments
+  - name
+
 You can also truncate the logs:
 
 ```
 :::>> background.log.clear(name: "server")
 ```
 
+- Arguments
+  - name
+
+You can also wait for a given string to appear in the logs:
+
+```
+:::>> background.wait(name: "server", wait: "method=GET")
+```
+
+- Arguments
+  - name
+  - wait: Same as `background.start` a string value to look for before continuing.
+  - timeout: Maximum number of seconds to wait
+
 ## Screenshots
 
 You'll need selenium and `chromedriver` installed on your system to make screenshots work. On a mac you can run:

data/lib/rundoc/cli.rb

@@ -203,7 +203,7 @@ module Rundoc
         to: on_failure_dir
       )
 
-      on_failure_dir.join("RUNDOC_FAILED.md").write(Rundoc::CodeSection.partial_result_to_doc)
+      on_failure_dir.join("RUNDOC_FAILED.md").write(Rundoc::Parser.partial_result_to_doc)
     end
 
     private def on_success(output)

data/lib/rundoc/cli_argument_parser.rb

@@ -111,7 +111,7 @@ module Rundoc
         end
 
         opts.on("--with-contents <dir>", "Copies contents of directory into the tmp working dir") do |v|
-          options[:with_contents_dir] = v
+          options[:with_contents_dir] = File.expand_path(v)
         end
 
         opts.on("--on-success-dir <dir>", "Success dir, relative to CWD. i.e. `<rundoc.md/dir>/#{CLI::DEFAULTS::ON_SUCCESS_DIR}/`.") do |v|

data/lib/rundoc/code_command/rundoc/require.rb

@@ -14,12 +14,17 @@ class ::Rundoc::CodeCommand
       end
 
       def call(env = {})
-        document_path = @path.expand_path(env[:context].source_dir)
+        execution_context = env[:context]
+        document_path = @path.expand_path(execution_context.source_dir)
 
-        puts "rundoc.require: Start executing #{@path.to_s.inspect}"
         output = Rundoc::Parser.new(
           document_path.read,
-          context: env[:context]
+          context: Rundoc::Context::Execution.new(
+            source_path: document_path,
+            output_dir: execution_context.output_dir,
+            screenshots_dirname: execution_context.screenshots_dir,
+            with_contents_dir: execution_context.with_contents_dir
+          )
         ).to_md
 
         if render_result?

data/lib/rundoc/code_section.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 module Rundoc
-  # holds code, parses and creates CodeCommand
+  # A code secttion respesents a block of fenced code
+  #
+  # A document can have multiple code sections
   class CodeSection
     class ParseError < StandardError
       def initialize(options = {})

data/lib/rundoc/parser.rb

@@ -1,4 +1,8 @@
 module Rundoc
+  # This poorly named class is responsible for taking in the raw markdown and running it
+  #
+  # It works by pulling out the code blocks (CodeSection), and putting them onto a stack.
+  # It then executes each in turn and records the results.
   class Parser
     DEFAULT_KEYWORD = ":::"
     INDENT_BLOCK = '(?<before_indent>(^\s*$\n|\A)(^(?:[ ]{4}|\t))(?<indent_contents>.*)(?<after_indent>[^\s].*$\n?(?:(?:^\s*$\n?)*^(?:[ ]{4}|\t).*[^\s].*$\n?)*))'
@@ -7,6 +11,7 @@ module Rundoc
     COMMAND_REGEX = ->(keyword) {
       /^#{keyword}(?<tag>(\s|=|-|>)?(=|-|>)?)\s*(?<command>(\S)+)\s+(?<statement>.*)$/
     }
+    PARTIAL_RESULT = []
 
     attr_reader :contents, :keyword, :stack, :context
 
@@ -17,6 +22,7 @@ module Rundoc
       @keyword = keyword
       @stack = []
       partition
+      PARTIAL_RESULT.clear
     end
 
     def to_md
@@ -27,13 +33,26 @@ module Rundoc
         else
           s
         end
+        PARTIAL_RESULT.replace(result)
       end
-      result.join("")
+
+      self.class.to_doc(result: result)
     rescue => e
       File.write("README.md", result.join(""))
       raise e
     end
 
+    def self.partial_result_to_doc
+      out = to_doc(result: PARTIAL_RESULT)
+      unfinished = CodeSection.partial_result_to_doc
+      out << unfinished if unfinished
+      out
+    end
+
+    def self.to_doc(result:)
+      result.join("")
+    end
+
     # split into [before_code, code, after_code], process code, and re-run until tail is empty
     def partition
       until contents.empty?

data/lib/rundoc/version.rb

@@ -1,3 +1,3 @@
 module Rundoc
-  VERSION = "3.1.0"
+  VERSION = "3.1.2"
 end

data/test/integration/failure_test.rb

@@ -1,7 +1,58 @@
 require "test_helper"
 
 class IntegrationFailureTest < Minitest::Test
-  def test_writes_to_dir_on_failure
+  def test_writes_to_dir_on_failure_two_block
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        dir = Pathname(dir)
+
+        source_path = dir.join("RUNDOC.md")
+        source_path.write <<~EOF
+          ```
+          :::>> $ mkdir one
+          :::>> $ touch one/rofl.txt
+          ```
+
+          ```
+          :::>> $ mkdir two
+          :::>> $ touch two/rofl.txt
+          :::>> $ touch does/not/exist.txt
+          ```
+        EOF
+
+        io = StringIO.new
+
+        error = nil
+        begin
+          Rundoc::CLI.new(
+            io: io,
+            source_path: source_path,
+            on_success_dir: dir.join(SUCCESS_DIRNAME)
+          ).call
+        rescue => e
+          error = e
+        end
+
+        assert error
+        assert_includes error.message, "exited with non zero status"
+
+        refute dir.join(SUCCESS_DIRNAME).join("two").exist?
+        refute dir.join(SUCCESS_DIRNAME).join("two").join("rofl.txt").exist?
+
+        assert dir.join(FAILURE_DIRNAME).join("two").exist?
+        assert dir.join(FAILURE_DIRNAME).join("two").join("rofl.txt").exist?
+
+        doc = dir.join(FAILURE_DIRNAME).join("RUNDOC_FAILED.md").read
+        assert_includes doc, "$ mkdir one"
+        assert_includes doc, "$ touch one/rofl.txt"
+
+        assert_includes doc, "$ mkdir two"
+        assert_includes doc, "$ touch two/rofl.txt"
+      end
+    end
+  end
+
+  def test_writes_to_dir_on_failure_one_block
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
         dir = Pathname(dir)

data/test/integration/require_test.rb

@@ -60,4 +60,38 @@ class IntegrationRequireTest < Minitest::Test
       end
     end
   end
+
+  def test_require_is_relative_to_current_file_not_source_file
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        dir = Pathname(dir)
+
+        source_path = dir.join("RUNDOC.md")
+        source_path.write <<~EOF
+          ```
+          :::>> rundoc.require "./src/a.md"
+          ```
+        EOF
+
+        dir.join("src").tap(&:mkpath).join("a.md").write <<~EOF
+          ```
+          :::-> rundoc.require "./b.md"
+          ```
+        EOF
+
+        dir.join("src").join("b.md").write <<~EOF
+          ```
+          :::-> print.text Hello World!
+          ```
+        EOF
+
+        parsed = parse_contents(
+          source_path.read,
+          source_path: source_path
+        )
+        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
+        assert_equal "Hello World!", actual.strip
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rundoc
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.2
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-21 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor