rundoc 4.0.0 → 4.1.1

data/test/integration/website_test.rb

@@ -23,7 +23,7 @@ class IntegrationWebsiteTest < Minitest::Test
           output_dir: screenshots_dir.parent,
           screenshots_dirname: screenshots_dirname
         )
-        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
+        actual = parsed.to_md.gsub(Rundoc::FencedCodeBlock::AUTOGEN_WARNING, "")
 
         expected = "![Screenshot of https://example.com/](screenshots/screenshot_1.png)"
         assert_equal expected, actual.strip

data/test/rundoc/code_section_test.rb

@@ -14,10 +14,11 @@ class CodeSectionTest < Minitest::Test
 
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
-        match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-        result = Rundoc::CodeSection.new(
-          match,
-          keyword: ":::",
+        match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+        result = Rundoc::FencedCodeBlock.new(
+          fence: match[:fence],
+          lang: match[:lang],
+          code: match[:contents],
           context: default_context
         ).render
         assert_equal "", result
@@ -33,13 +34,14 @@ class CodeSectionTest < Minitest::Test
 
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    result = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    result = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     ).render
-    assert_equal contents, result.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "\n")
+    assert_equal contents, result.gsub(Rundoc::FencedCodeBlock::AUTOGEN_WARNING, "\n")
   end
 
   def test_show_command_hide_render
@@ -49,15 +51,16 @@ class CodeSectionTest < Minitest::Test
       ```
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    code_section = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    code_section = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     )
     code_section.render
 
-    code_command = code_section.commands.first
+    code_command = code_section.executed_commands.first
     assert_equal true, code_command.render_command
     assert_equal false, code_command.render_result
 
@@ -67,15 +70,16 @@ class CodeSectionTest < Minitest::Test
       ```
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    code_section = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    code_section = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     )
     code_section.render
 
-    code_command = code_section.commands.first
+    code_command = code_section.executed_commands.first
     assert_equal true, code_command.render_command
     assert_equal false, code_command.render_result
   end
@@ -87,16 +91,17 @@ class CodeSectionTest < Minitest::Test
       ```
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    code_section = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    code_section = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     )
     code_section.render
 
-    puts code_section.commands.inspect
-    code_command = code_section.commands.first
+    puts code_section.executed_commands.inspect
+    code_command = code_section.executed_commands.first
     assert_equal true, code_command.render_command
     assert_equal true, code_command.render_result
   end
@@ -108,15 +113,16 @@ class CodeSectionTest < Minitest::Test
       ```
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    code_section = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    code_section = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     )
     code_section.render
 
-    code_command = code_section.commands.first
+    code_command = code_section.executed_commands.first
     assert_equal false, code_command.render_command
     assert_equal false, code_command.render_result
 
@@ -126,15 +132,16 @@ class CodeSectionTest < Minitest::Test
       ```
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    code_section = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    code_section = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     )
     code_section.render
 
-    code_command = code_section.commands.first
+    code_command = code_section.executed_commands.first
     assert_equal false, code_command.render_command
     assert_equal false, code_command.render_result
   end
@@ -146,15 +153,16 @@ class CodeSectionTest < Minitest::Test
       ```
     RUBY
 
-    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
-    code_section = Rundoc::CodeSection.new(
-      match,
-      keyword: ":::",
+    match = contents.match(Rundoc::Document::CODEBLOCK_REGEX)
+    code_section = Rundoc::FencedCodeBlock.new(
+      fence: match[:fence],
+      lang: match[:lang],
+      code: match[:contents],
       context: default_context
     )
     code_section.render
 
-    code_command = code_section.commands.first
+    code_command = code_section.executed_commands.first
     assert_equal false, code_command.render_command
     assert_equal true, code_command.render_result
   end

data/test/rundoc/parser_test.rb

@@ -17,7 +17,7 @@ class ParserTest < Minitest::Test
       Dir.chdir(dir) do
         expected = "sup\n\n```\n$ mkdir foo\n$ ls\nfoo\n```\n\nyo\n"
         parsed = parse_contents(contents)
-        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
+        actual = parsed.to_md.gsub(Rundoc::FencedCodeBlock::AUTOGEN_WARNING, "")
         assert_equal expected, actual
       end
     end
@@ -39,7 +39,7 @@ class ParserTest < Minitest::Test
       Dir.chdir(dir) do
         expected = "sup\n\nIn file `foo/code.rb` write:\n\n```\na = 1 + 1\nb = a * 2\n```\nyo\n"
         parsed = parse_contents(contents)
-        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
+        actual = parsed.to_md.gsub(Rundoc::FencedCodeBlock::AUTOGEN_WARNING, "")
         assert_equal expected, actual
       end
     end
@@ -57,7 +57,7 @@ class ParserTest < Minitest::Test
       Dir.chdir(dir) do
         expected = "\nIn file `foo/newb.rb` write:\n\n```\nputs 'hello world'\n$ cat foo/newb.rb\nputs 'hello world'\n```\n"
         parsed = parse_contents(contents)
-        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
+        actual = parsed.to_md.gsub(Rundoc::FencedCodeBlock::AUTOGEN_WARNING, "")
         assert_equal expected, actual
       end
     end

data/test/rundoc/peg_parser_test.rb

@@ -240,22 +240,6 @@ class PegParserTest < Minitest::Test
   end
 
   def test_no_args
-    # input = String.new
-    # input << %Q{rundoc}
-    # parser = Rundoc::PegParser.new.no_args_method
-    # tree = parser.parse_with_debug(input)
-    # actual = @transformer.apply(tree)
-    # assert_equal("rundoc", actual.to_s)
-
-    # input = String.new
-    # input << %Q{:::-- rundoc\n}
-    # parser = Rundoc::PegParser.new.command
-    # tree = parser.parse_with_debug(input)
-
-    # actual = @transformer.apply(tree)
-    # assert_equal :rundoc, actual.keyword
-    # assert_nil(actual.original_args)
-
     input = +""
     input << %(:::-- rundoc\n)
     input << %(email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`\n)
@@ -333,19 +317,7 @@ class PegParserTest < Minitest::Test
     actual = @transformer.apply(tree)
     assert_equal ["rails server", {name: "server"}], actual.original_args
 
-    # input = +""
-    # input << %Q{background.start("rails server", name: "server")}
-    # parser = Rundoc::PegParser.new.method_call
-
-    # tree = parser.parse_with_debug(input)
-
-    # puts tree.inspect
-
-    # actual = @transformer.apply(tree)
-    # assert_equal :"background.start", actual.keyword
-
     # ================
-
     input = +""
     input << %{call("foo", "bar")}
 
@@ -358,7 +330,6 @@ class PegParserTest < Minitest::Test
     assert_equal ["foo", "bar"], actual.original_args
 
     # ======================
-
     input = +""
     input << %{call("foo", "bar", biz: "baz")}
 
@@ -372,14 +343,10 @@ class PegParserTest < Minitest::Test
   def test_positional_args_code_block
     input = +""
     input << %{:::>> background.start("rails server", name: "server")\n}
-    # input << %Q{:::-- background.stop(name: "server")\n}
 
     parser = Rundoc::PegParser.new.command
 
     tree = parser.parse_with_debug(input)
-
-    # puts tree.inspect
-
     actual = @transformer.apply(tree)
     assert_equal :"background.start", actual.keyword
     assert_equal ["rails server", {name: "server"}], actual.original_args

data/test/rundoc/regex_test.rb

@@ -4,36 +4,20 @@ class RegexTest < Minitest::Test
   def setup
   end
 
-  def test_indent_regex
-    contents = <<~RUBY
-      foo
-      
-          $ cd
-          yo
-          sup
-      
-      bar
-    RUBY
-
-    regex = Rundoc::Parser::INDENT_BLOCK
-    parsed = contents.match(/#{regex}/).to_s
-    assert_equal "\n    $ cd\n    yo\n    sup\n", parsed
-  end
-
   def test_github_regex
     contents = <<~RUBY
       foo
-      
+
       ```
       $ cd
       yo
       sup
       ```
-      
+
       bar
     RUBY
 
-    regex = Rundoc::Parser::GITHUB_BLOCK
+    regex = Rundoc::Document::GITHUB_BLOCK
     parsed = contents.match(/#{regex}/m).to_s
     assert_equal "```\n$ cd\nyo\nsup\n```\n", parsed
   end
@@ -41,74 +25,40 @@ class RegexTest < Minitest::Test
   def test_github_tagged_regex
     contents = <<~RUBY
       foo
-      
+
       ```ruby
       $ cd
       yo
       sup
       ```
-      
+
       bar
     RUBY
 
-    regex = Rundoc::Parser::GITHUB_BLOCK
+    regex = Rundoc::Document::GITHUB_BLOCK
     parsed = contents.match(/#{regex}/m).to_s
     assert_equal "```ruby\n$ cd\nyo\nsup\n```\n", parsed
   end
 
-  def test_command_regex
-    regex = Rundoc::Parser::COMMAND_REGEX.call(":::")
-
-    contents = ":::$ mkdir schneems"
-    match = contents.match(regex)
-    assert_equal "", match[:tag]
-    assert_equal "$", match[:command]
-    assert_equal "mkdir schneems", match[:statement]
-
-    contents = ":::=$ mkdir schneems"
-    match = contents.match(regex)
-    assert_equal "=", match[:tag]
-    assert_equal "$", match[:command]
-    assert_equal "mkdir schneems", match[:statement]
-
-    contents = ":::=       $ mkdir schneems"
-    match = contents.match(regex)
-    assert_equal "=", match[:tag]
-    assert_equal "$", match[:command]
-    assert_equal "mkdir schneems", match[:statement]
-
-    contents = ":::-$ mkdir schneems"
-    match = contents.match(regex)
-    assert_equal "-", match[:tag]
-    assert_equal "$", match[:command]
-    assert_equal "mkdir schneems", match[:statement]
-
-    contents = ":::- $ mkdir schneems"
-    match = contents.match(regex)
-    assert_equal "-", match[:tag]
-    assert_equal "$", match[:command]
-    assert_equal "mkdir schneems", match[:statement]
-  end
-
   def test_codeblock_regex
     contents = <<~RUBY
       foo
-      
+
       ```
       :::>$ mkdir
       ```
-      
+
       zoo
-      
+
       ```
       :::>$ cd ..
       something
       ```
-      
+
       bar
     RUBY
 
-    regex = Rundoc::Parser::CODEBLOCK_REGEX
+    regex = Rundoc::Document::CODEBLOCK_REGEX
 
     actual = contents.partition(regex)
     expected = ["foo\n\n",
@@ -133,7 +83,7 @@ class RegexTest < Minitest::Test
       ```java
       :::>> write app/controllers/Application.java
       package controllers;
-      
+
       import static java.util.concurrent.TimeUnit.SECONDS;
       import models.Pinger;
       import play.libs.Akka;
@@ -146,7 +96,7 @@ class RegexTest < Minitest::Test
       import akka.actor.ActorRef;
       import akka.actor.Cancellable;
       import akka.actor.Props;
-      
+
       public class Application extends Controller {
           public static WebSocket<String> pingWs() {
               return new WebSocket<String>() {
@@ -159,7 +109,7 @@ class RegexTest < Minitest::Test
                                                          Akka.system().dispatcher(),
                                                          null
                                                          );
-      
+
                       in.onClose(new Callback0() {
                         @Override
                         public void invoke() throws Throwable {
@@ -167,14 +117,14 @@ class RegexTest < Minitest::Test
                         }
                       });
                   }
-      
+
               };
           }
-      
+
           public static Result pingJs() {
               return ok(views.js.ping.render());
           }
-      
+
           public static Result index() {
               return ok(index.render());
           }
@@ -182,7 +132,7 @@ class RegexTest < Minitest::Test
       ```
     RUBY
 
-    regex = Rundoc::Parser::CODEBLOCK_REGEX
+    regex = Rundoc::Document::CODEBLOCK_REGEX
     match = contents.match(regex)
     assert_equal "java", match[:lang]
     assert_equal "```", match[:fence]
@@ -205,7 +155,7 @@ class RegexTest < Minitest::Test
       :::>> $ echo "hello"
       ```
     MD
-    regex = Rundoc::Parser::CODEBLOCK_REGEX
+    regex = Rundoc::Document::CODEBLOCK_REGEX
     match = code_block_with_newline.match(regex)
     assert_equal expected, match.to_s.strip
 

data/test/test_helper.rb

@@ -19,12 +19,11 @@ class Minitest::Test
     source_path: nil,
     screenshots_dirname: nil
   )
-
     Rundoc::Context::Execution.new(
-      output_dir: output_dir || Pathname("/dev/null"),
-      source_path: source_path || Pathname("/dev/null"),
+      output_dir: output_dir || Pathname(File::NULL),
+      source_path: source_path || Pathname(File::NULL),
       with_contents_dir: nil,
-      screenshots_dirname: screenshots_dirname || Pathname("/dev/null")
+      screenshots_dirname: screenshots_dirname || Pathname(File::NULL)
     )
   end
 
@@ -39,7 +38,7 @@ class Minitest::Test
       source_path: source_path,
       screenshots_dirname: screenshots_dirname
     )
-    Rundoc::Parser.new(
+    Rundoc::Document.new(
       contents,
       context: context
     )
@@ -60,7 +59,7 @@ class Minitest::Test
   end
 
   def strip_autogen_warning(string)
-    string.gsub!(Rundoc::CodeSection::AUTOGEN_WARNING, "")
+    string.gsub!(Rundoc::FencedCodeBlock::AUTOGEN_WARNING, "")
     string.gsub!(/<!-- STOP.*STOP -->/m, "")
     string
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rundoc
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.1
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-30 00:00:00.000000000 Z
+date: 2024-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -215,6 +215,7 @@ files:
 - lib/rundoc/code_command/file_command/remove.rb
 - lib/rundoc/code_command/no_such_command.rb
 - lib/rundoc/code_command/pipe.rb
+- lib/rundoc/code_command/pre/erb.rb
 - lib/rundoc/code_command/print/erb.rb
 - lib/rundoc/code_command/print/text.rb
 - lib/rundoc/code_command/raw.rb
@@ -227,10 +228,10 @@ files:
 - lib/rundoc/code_command/website/screenshot.rb
 - lib/rundoc/code_command/website/visit.rb
 - lib/rundoc/code_command/write.rb
-- lib/rundoc/code_section.rb
 - lib/rundoc/context/after_build.rb
 - lib/rundoc/context/execution.rb
-- lib/rundoc/parser.rb
+- lib/rundoc/document.rb
+- lib/rundoc/fenced_code_block.rb
 - lib/rundoc/peg_parser.rb
 - lib/rundoc/version.rb
 - rundoc.gemspec
@@ -264,6 +265,7 @@ files:
 - test/integration/after_build_test.rb
 - test/integration/background_stdin_test.rb
 - test/integration/failure_test.rb
+- test/integration/pre_erb_test.rb
 - test/integration/print_test.rb
 - test/integration/require_test.rb
 - test/integration/website_test.rb

data/lib/rundoc/code_section.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-module Rundoc
-  # A code secttion respesents a block of fenced code
-  #
-  # A document can have multiple code sections
-  class CodeSection
-    class ParseError < StandardError
-      def initialize(options = {})
-        keyword = options[:keyword]
-        command = options[:command]
-        line_number = options[:line_number]
-        block = options[:block].lines.map do |line|
-          if line == command
-            "    > #{line}"
-          else
-            "      #{line}"
-          end
-        end.join("")
-
-        msg = "Error parsing (line:#{line_number}):\n"
-        msg << ">  '#{command.strip}'\n"
-        msg << "No such registered command: '#{keyword}'\n"
-        msg << "registered commands: #{Rundoc.known_commands.inspect}\n\n"
-        msg << block
-        msg << "\n"
-        super(msg)
-      end
-    end
-
-    COMMAND_REGEX = Rundoc::Parser::COMMAND_REGEX # todo: move whole thing
-    AUTOGEN_WARNING = "\n<!-- STOP. This document is autogenerated. Do not manually modify. See the top of the doc for more details. -->"
-    attr_accessor :original, :fence, :lang, :code, :commands, :keyword
-
-    PARTIAL_RESULT = []
-    PARTIAL_ENV = {}
-
-    def initialize(match, keyword:, context:)
-      @original = match.to_s
-      @commands = []
-      @stack = []
-      @keyword = keyword
-      @context = context
-      @fence = match[:fence]
-      @lang = match[:lang]
-      @code = match[:contents]
-      parse_code_command
-      PARTIAL_RESULT.clear
-      PARTIAL_ENV.clear
-    end
-
-    def render
-      result = []
-      env = {}
-      env[:commands] = []
-      env[:fence_start] = "#{fence}#{lang}"
-      env[:fence_end] = "#{fence}#{AUTOGEN_WARNING}"
-      env[:before] = []
-      env[:after] = []
-      env[:context] = @context
-
-      @stack.each do |s|
-        unless s.respond_to?(:call)
-          result << s
-          next
-        end
-
-        code_command = s
-        code_output = code_command.call(env) || ""
-        code_line = code_command.to_md(env) || ""
-
-        env[:commands] << {object: code_command, output: code_output, command: code_line}
-
-        tmp_result = []
-        tmp_result << code_line if code_command.render_command?
-        tmp_result << code_output if code_command.render_result?
-
-        result << tmp_result unless code_command.hidden?
-
-        PARTIAL_RESULT.replace(result)
-        PARTIAL_ENV.replace(env)
-      end
-
-      return "" if hidden?
-
-      self.class.to_doc(result: result, env: env)
-    end
-
-    def self.partial_result_to_doc
-      to_doc(result: PARTIAL_RESULT, env: PARTIAL_ENV)
-    end
-
-    def self.to_doc(result:, env:)
-      array = [env[:before]]
-
-      result.flatten!
-      result.compact!
-      result.map! { |s| s.respond_to?(:rstrip) ? s.rstrip : s }
-      result.reject!(&:empty?)
-      result.map!(&:to_s)
-
-      if !result.empty?
-        array << env[:fence_start]
-        array << result
-        array << env[:fence_end]
-      end
-      array << env[:after]
-
-      array.flatten!
-      array.compact!
-      array.map! { |s| s.respond_to?(:rstrip) ? s.rstrip : s }
-      array.reject!(&:empty?)
-      array.map!(&:to_s)
-
-      array.join("\n") << "\n"
-    end
-
-    # all of the commands are hidden
-    def hidden?
-      !not_hidden?
-    end
-
-    # one or more of the commands are not hidden
-    def not_hidden?
-      return true if commands.empty?
-      commands.map(&:not_hidden?).detect { |c| c }
-    end
-
-    def parse_code_command
-      parser = Rundoc::PegParser.new.code_block
-      tree = parser.parse(@code)
-      actual = Rundoc::PegTransformer.new.apply(tree)
-      actual = [actual] unless actual.is_a?(Array)
-      actual.each do |code_command|
-        @stack << "\n" if commands.last.is_a?(Rundoc::CodeCommand)
-        @stack << code_command
-        commands << code_command
-      end
-    rescue ::Parslet::ParseFailed => e
-      raise "Could not compile code:\n#{@code}\nReason: #{e.message}"
-    end
-
-    # def check_parse_error(command, code_block)
-    #   return unless code_command = @stack.last
-    #   return unless code_command.is_a?(Rundoc::CodeCommand::NoSuchCommand)
-    #   @original.lines.each_with_index do |line, index|
-    #     next unless line == command
-    #     raise ParseError.new(keyword:     code_command.keyword,
-    #                          block:       code_block,
-    #                          command:     command,
-    #                          line_number: index.next)
-    #   end
-    # end
-  end
-end