rundoc 1.1.3 → 2.0.1

data/test/rundoc/code_commands/background_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class BackgroundTest < Minitest::Test
   def test_process_spawn_gc
@@ -9,8 +9,7 @@ class BackgroundTest < Minitest::Test
 
         background_start = Rundoc::CodeCommand::Background::Start.new("tail -f #{file}",
           name: "tail2",
-          wait: "f"
-        )
+          wait: "f")
 
         GC.start
 
@@ -30,14 +29,12 @@ class BackgroundTest < Minitest::Test
   def test_background_start
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
-
         file = "foo.txt"
         `echo 'foo' >> #{file}`
 
         background_start = Rundoc::CodeCommand::Background::Start.new("tail -f #{file}",
           name: "tail",
-          wait: "f"
-        )
+          wait: "f")
         output = background_start.call
 
         assert_match("foo", output)

data/test/rundoc/code_commands/bash_test.rb

@@ -1,36 +1,34 @@
-require 'test_helper'
+require "test_helper"
 
 class BashTest < Minitest::Test
-
   def test_bash_returns_cd
     original_dir = `pwd`
     Rundoc::CodeCommand::Bash.new("cd ..").call
-    now_dir      = `pwd`
+    now_dir = `pwd`
     refute_equal original_dir, now_dir
   ensure
     Dir.chdir(original_dir.strip)
   end
 
   def test_bash_stderr_with_or_is_capture
-
     command = "1>&2 echo 'msg to STDERR 1' || 1>&2 echo 'msg to STDERR 2'"
     bash = Rundoc::CodeCommand::Bash.new(command)
     assert_equal "$ #{command}", bash.to_md
-    assert_equal "msg to STDERR 1\n",   bash.call
+    assert_equal "msg to STDERR 1\n", bash.call
   end
 
   def test_bash_shells_and_shows_correctly
     ["pwd", "ls"].each do |command|
-      bash  = Rundoc::CodeCommand::Bash.new(command)
+      bash = Rundoc::CodeCommand::Bash.new(command)
       assert_equal "$ #{command}", bash.to_md
-      assert_equal `#{command}`,   bash.call
+      assert_equal `#{command}`, bash.call
     end
   end
 
   def test_stdin
     command = "tail -n 2"
-    bash  = Rundoc::CodeCommand::Bash.new(command)
+    bash = Rundoc::CodeCommand::Bash.new(command)
     bash << "foo\nbar\nbaz\n"
-    assert_equal "bar\nbaz\n",   bash.call
+    assert_equal "bar\nbaz\n", bash.call
   end
 end

data/test/rundoc/code_commands/pipe_test.rb

@@ -1,12 +1,12 @@
-require 'test_helper'
+require "test_helper"
 
 class PipeTest < Minitest::Test
   def test_pipe
     pipe_cmd = "tail -n 2"
-    cmd      = "ls"
-    out      = `#{cmd}`
-    pipe     = Rundoc::CodeCommand::Pipe.new(pipe_cmd)
-    actual   = pipe.call(commands: [{command: cmd, output: out}])
+    cmd = "ls"
+    out = `#{cmd}`
+    pipe = Rundoc::CodeCommand::Pipe.new(pipe_cmd)
+    actual = pipe.call(commands: [{command: cmd, output: out}])
 
     expected = `#{cmd} | #{pipe_cmd}`
     assert_equal expected, actual
@@ -14,10 +14,10 @@ class PipeTest < Minitest::Test
 
   def test_moar_pipe_with_dollar
     pipe_cmd = "tail -n 2"
-    cmd      = "ls"
-    out      = `#{cmd}`
-    pipe     = Rundoc::CodeCommand::Pipe.new("$ #{pipe_cmd}")
-    actual   = pipe.call(commands: [{command: cmd, output: out}])
+    cmd = "ls"
+    out = `#{cmd}`
+    pipe = Rundoc::CodeCommand::Pipe.new("$ #{pipe_cmd}")
+    actual = pipe.call(commands: [{command: cmd, output: out}])
 
     expected = `#{cmd} | #{pipe_cmd}`
     assert_equal expected, actual

data/test/rundoc/code_commands/print_test.rb

@@ -0,0 +1,94 @@
+require "test_helper"
+
+class PrintTest < Minitest::Test
+  def test_plain_text_before_block
+    env = {}
+    env[:before] = []
+
+    input = %($ rails new myapp # Not a command since it's missing the ":::>>")
+    cmd = Rundoc::CodeCommand::PrintText.new(input)
+    cmd.render_command = false
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal "", cmd.call
+    assert_equal ["$ rails new myapp # Not a command since it's missing the \":::>>\""], env[:before]
+  end
+
+  def test_plain_text_in_block
+    env = {}
+    env[:before] = []
+
+    input = %($ rails new myapp # Not a command since it's missing the ":::>>")
+    cmd = Rundoc::CodeCommand::PrintText.new(input)
+    cmd.render_command = true
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal input, cmd.call
+
+    assert_equal [], env[:before]
+  end
+
+  def test_erb_before_block
+    env = {}
+    env[:before] = []
+
+    input = %($ rails new <%= 'myapp' %> # Not a command since it's missing the ":::>>")
+    cmd = Rundoc::CodeCommand::PrintERB.new(input)
+    cmd.render_command = false
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal "", cmd.call
+    assert_equal ["$ rails new myapp # Not a command since it's missing the \":::>>\""],
+      env[:before]
+  end
+
+  def test_erb_in_block
+    env = {}
+    env[:before] = []
+
+    cmd = Rundoc::CodeCommand::PrintERB.new
+    cmd.contents = %(<%= "foo" %>)
+    cmd.render_command = true
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal "foo", cmd.call
+    assert_equal [], env[:before]
+  end
+
+  def test_binding_is_preserved
+    env = {}
+    env[:before] = []
+    cmd = Rundoc::CodeCommand::PrintERB.new
+    cmd.contents = %{<%= @foo = SecureRandom.hex(16) %>}
+    cmd.render_command = true
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal [], env[:before]
+    expected = cmd.call
+
+    assert !expected.empty?
+
+    cmd = Rundoc::CodeCommand::PrintERB.new
+    cmd.contents = %(<%= @foo %>)
+    cmd.render_command = true
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal expected, cmd.call
+    assert_equal [], env[:before]
+
+    cmd = Rundoc::CodeCommand::PrintERB.new(binding: "different")
+    cmd.contents = %(<%= @foo %>)
+    cmd.render_command = true
+    cmd.render_result = true
+
+    assert_equal "", cmd.to_md(env)
+    assert_equal "", cmd.call
+    assert_equal [], env[:before]
+  end
+end

data/test/rundoc/code_commands/remove_contents_test.rb

@@ -1,7 +1,6 @@
-require 'test_helper'
+require "test_helper"
 
 class RemoveContentsTest < Minitest::Test
-
   def setup
     @gemfile = <<-RUBY
 
@@ -17,7 +16,6 @@ class RemoveContentsTest < Minitest::Test
   def test_appends_to_a_file
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
-
         @file = "foo.rb"
         `echo "#{@gemfile}" >> #{@file}`
 
@@ -31,10 +29,11 @@ class RemoveContentsTest < Minitest::Test
 
         env = {}
         env[:commands] = []
-        env[:before]   = "```ruby"
+        env[:before] = []
+        env[:fence_start] = "```ruby"
         cc.to_md(env)
 
-        assert_equal "In file `foo.rb` remove:\n\n```ruby", env[:before]
+        assert_equal ["In file `foo.rb` remove:", Rundoc::CodeCommand::NEWLINE], env[:before]
       end
     end
   end

data/test/rundoc/code_section_test.rb

@@ -1,21 +1,16 @@
-require 'test_helper'
+require "test_helper"
 
 class CodeSectionTest < Minitest::Test
-
-  def setup
-  end
-
   def test_does_not_render_if_all_contents_hidden
-    contents =  <<-RUBY
-sup
+    contents = <<~RUBY
+      sup
 
-```
-:::--  $ mkdir foo
-```
-
-yo
-RUBY
+      ```
+      :::--  $ mkdir foo
+      ```
 
+      yo
+    RUBY
 
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
@@ -26,55 +21,55 @@ RUBY
     end
   end
 
-
   def test_no_code
-    contents = <<-RUBY
-```ruby
-gem 'sqlite3'
-```
-RUBY
+    contents = <<~RUBY
+      ```ruby
+      gem 'sqlite3'
+      ```
+
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     result = Rundoc::CodeSection.new(match, keyword: ":::").render
-    assert_equal contents, result
+    assert_equal contents, result.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "\n")
   end
 
   def test_show_command_hide_render
-    contents = <<-RUBY
-```
-:::>- $ echo "foo"
-```
-RUBY
+    contents = <<~RUBY
+      ```
+      :::>- $ echo "foo"
+      ```
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     code_section = Rundoc::CodeSection.new(match, keyword: ":::")
     code_section.render
 
     code_command = code_section.commands.first
-    assert_equal true,  code_command.render_command
+    assert_equal true, code_command.render_command
     assert_equal false, code_command.render_result
 
-    contents = <<-RUBY
-```
-:::>- $ echo "foo"
-```
-RUBY
+    contents = <<~RUBY
+      ```
+      :::>- $ echo "foo"
+      ```
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     code_section = Rundoc::CodeSection.new(match, keyword: ":::")
     code_section.render
 
     code_command = code_section.commands.first
-    assert_equal true,  code_command.render_command
+    assert_equal true, code_command.render_command
     assert_equal false, code_command.render_result
   end
 
   def test_show_command_show_render
-    contents = <<-RUBY
-```
-:::>> $ echo "foo"
-```
-RUBY
+    contents = <<~RUBY
+      ```
+      :::>> $ echo "foo"
+      ```
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     code_section = Rundoc::CodeSection.new(match, keyword: ":::")
@@ -87,49 +82,48 @@ RUBY
   end
 
   def test_hide_command_hide_render
-    contents = <<-RUBY
-```
-:::-- $ echo "foo"
-```
-RUBY
+    contents = <<~RUBY
+      ```
+      :::-- $ echo "foo"
+      ```
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     code_section = Rundoc::CodeSection.new(match, keyword: ":::")
     code_section.render
 
     code_command = code_section.commands.first
-    assert_equal false,  code_command.render_command
+    assert_equal false, code_command.render_command
     assert_equal false, code_command.render_result
 
-    contents = <<-RUBY
-```
-:::-- $ echo "foo"
-```
-RUBY
+    contents = <<~RUBY
+      ```
+      :::-- $ echo "foo"
+      ```
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     code_section = Rundoc::CodeSection.new(match, keyword: ":::")
     code_section.render
 
     code_command = code_section.commands.first
-    assert_equal false,  code_command.render_command
+    assert_equal false, code_command.render_command
     assert_equal false, code_command.render_result
   end
 
   def test_hide_command_show_render
-    contents = <<-RUBY
-```
-:::-> $ echo "foo"
-```
-RUBY
+    contents = <<~RUBY
+      ```
+      :::-> $ echo "foo"
+      ```
+    RUBY
 
     match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
     code_section = Rundoc::CodeSection.new(match, keyword: ":::")
     code_section.render
 
     code_command = code_section.commands.first
-    assert_equal false,  code_command.render_command
+    assert_equal false, code_command.render_command
     assert_equal true, code_command.render_result
   end
-
 end

data/test/rundoc/parser_test.rb

@@ -1,98 +1,65 @@
-require 'test_helper'
+require "test_helper"
 
 class ParserTest < Minitest::Test
-
-  def setup
-  end
-
   def test_parse_bash
-    contents =  <<-RUBY
-sup
+    contents = <<~RUBY
+      sup
 
-```
-:::>-  $ mkdir foo
-:::>> $ ls
-```
-
-yo
-RUBY
+      ```
+      :::>-  $ mkdir foo
+      :::>> $ ls
+      ```
 
+      yo
+    RUBY
 
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
         expected = "sup\n\n```\n$ mkdir foo\n$ ls\nfoo\n```\n\nyo\n"
         parsed = Rundoc::Parser.new(contents)
-        actual = parsed.to_md
+        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
         assert_equal expected, actual
       end
     end
   end
 
-
   def test_parse_write_commands
-    contents =  <<-RUBY
-sup
+    contents = <<~RUBY
+      sup
 
-```
-:::>> write foo/code.rb
-a = 1 + 1
-b = a * 2
-```
-yo
-RUBY
+      ```
+      :::>> write foo/code.rb
+      a = 1 + 1
+      b = a * 2
+      ```
+      yo
+    RUBY
 
     Dir.mktmpdir do |dir|
       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 = Rundoc::Parser.new(contents)
-        actual = parsed.to_md
+        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
         assert_equal expected, actual
       end
     end
 
+    contents = <<~RUBY
 
-    contents =  <<-RUBY
-
-```
-:::>> write foo/newb.rb
-puts 'hello world'
-:::>> $ cat foo/newb.rb
-```
-RUBY
+      ```
+      :::>> write foo/newb.rb
+      puts 'hello world'
+      :::>> $ cat foo/newb.rb
+      ```
+    RUBY
 
     Dir.mktmpdir do |dir|
       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 = Rundoc::Parser.new(contents)
-        actual = parsed.to_md
+        actual = parsed.to_md.gsub(Rundoc::CodeSection::AUTOGEN_WARNING, "")
         assert_equal expected, actual
       end
     end
   end
-
-  def test_irb
-
-    contents =  <<-RUBY
-```
-:::>> irb --simple-prompt
-a = 3
-b = "foo" * a
-puts b
-```
-RUBY
-
-    Dir.mktmpdir do |dir|
-      Dir.chdir(dir) do
-
-        parsed = Rundoc::Parser.new(contents)
-        actual = parsed.to_md
-        expected = "```\n$ irb --simple-prompt\na = 3\n=> 3\r\nb = \"foo\" * a\n=> \"foofoofoo\"\r\nputs b\nfoofoofoo\r\n=> nil\n```\n"
-        assert_equal expected, actual
-      end
-    end
-
-  end
-
 end