rundoc 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e89c8353e4727ae39613f24c38bf3a69f027c6d1e533e64e281a588405ff57f
-  data.tar.gz: 34df7f620c446901596deec889b9c8f785bd10e0441a54e1904b799ae9b8f0cd
+  metadata.gz: d21f4ac48ad2eab762969c03ce386aeb097f99162d38716e4736de44c9bbac83
+  data.tar.gz: 79f9be265a84d8474e3ed7d55d90781e9999790b6cf5e578943db89e0fec7ee9
 SHA512:
-  metadata.gz: beb56a43157798ba53c4e63d715fd75892bc6d2b93bd0b8d379168c4dcc8807af3c31a5b8ac1a8af6215fa738bad6f8b4e2df525bae1c6590ef8bf7d3e94b29d
-  data.tar.gz: 8f6555c197fc600cc5cbf60af7d558213f50ec2a01b3d72f57e09eec628ba3169a512230b9ae106071afb2b536a6b7a314b3a8a832eb64e158565d977ab28e06
+  metadata.gz: fcf456c89f09000ddeeaf7aa22654acf419f36294b9e88dec9735f9ec3fcab315085dd6ee97cbd63eb580078e009968219b5240a6fe7a6db4c022d1b878d97cb
+  data.tar.gz: 8e2ee0bd6fa26b8b8906ec9b2267a9e98feedc40b54dc53ca457937a7199865c2c6b7663837a067802426321fc93740da3038289ea516139a573a1e5679c8724

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## HEAD
 
+## 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/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.1"
 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)

metadata

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