rundoc 0.0.1 → 1.1.1

data/test/fixtures/require/dependency/rundoc.md

@@ -0,0 +1,5 @@
+```
+:::>> $ mkdir foo
+:::>> $ cd foo
+:::>> $ echo "hello" >> hello.txt
+```

data/test/fixtures/require/main/rundoc.md

@@ -0,0 +1,10 @@
+# Hello
+
+```
+:::-- rundoc.require "../dependency/rundoc.md"
+```
+
+```
+:::>> $ ruby -e "raise 'nope' unless File.read('hello.txt').chomp == 'hello'"
+```
+

data/test/fixtures/screenshot/rundoc.md

@@ -0,0 +1,10 @@
+# Hello
+
+```
+:::>> website.visit(name: "google", url: "https://www.google.com")
+# session.visit("https://www.codetriage.com")
+:::>> website.screenshot(name: "google", upload: "s3")
+```
+
+
+## There

data/test/rundoc/code_commands/append_file_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AppendFileTest < Test::Unit::TestCase
+class AppendFileTest < Minitest::Test
 
   def test_appends_to_a_file
     Dir.mktmpdir do |dir|
@@ -15,8 +15,8 @@ class AppendFileTest < Test::Unit::TestCase
 
         result = File.read(file)
 
-        assert_match /foo/, result
-        assert_match /bar/, result
+        assert_match(/foo/, result)
+        assert_match(/bar/, result)
 
         cc = Rundoc::CodeCommand::FileCommand::Append.new(file)
         cc << "baz"
@@ -29,14 +29,14 @@ class AppendFileTest < Test::Unit::TestCase
     end
   end
 
-    def test_appends_to_a_file_at_line_number
+  def test_appends_to_a_file_at_line_number
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
 
-contents = <<-CONTENTS
+        contents = <<-CONTENTS
 source 'https://rubygems.org'
 gem 'rails', '4.0.0'
-CONTENTS
+        CONTENTS
 
         file = "foo.rb"
         line = 2
@@ -52,4 +52,31 @@ CONTENTS
     end
   end
 
+  def test_globs_filenames
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        filename = "file-#{Time.now.utc.strftime("%Y%m%d%H%M%S")}.txt"
+        FileUtils.touch(filename)
+        cc = Rundoc::CodeCommand::FileCommand::Append.new("file-*.txt")
+        cc << "some text"
+        cc.call
+
+        assert_equal "\nsome text\n", File.read(filename)
+      end
+    end
+  end
+
+  def test_glob_multiple_matches_raises
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        FileUtils.touch("file-1234.txt")
+        FileUtils.touch("file-5678.txt")
+        assert_raises do
+          cc = Rundoc::CodeCommand::FileCommand::Append.new("file-*.txt")
+          cc << "some text"
+          cc.call
+        end
+      end
+    end
+  end
 end

data/test/rundoc/code_commands/background_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class BackgroundTest < Minitest::Test
+  def test_process_spawn_gc
+    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: "tail2",
+          wait: "f"
+        )
+
+        GC.start
+
+        output = background_start.call
+
+        assert_match("foo", output)
+        assert_equal(true, background_start.alive?)
+
+        background_stop = Rundoc::CodeCommand::Background::Stop.new(name: "tail2")
+        background_stop.call
+
+        assert_equal(false, background_start.alive?)
+      end
+    end
+  end
+
+  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"
+        )
+        output = background_start.call
+
+        assert_match("foo", output)
+        assert_equal(true, background_start.alive?)
+
+        log_read = Rundoc::CodeCommand::Background::Log::Read.new(name: "tail")
+        output = log_read.call
+
+        assert_equal("foo", output.chomp)
+
+        log_clear = Rundoc::CodeCommand::Background::Log::Clear.new(name: "tail")
+        output = log_clear.call
+        assert_equal("", output)
+
+        `echo 'bar' >> #{file}`
+
+        log_read = Rundoc::CodeCommand::Background::Log::Read.new(name: "tail")
+        output = log_read.call
+
+        assert_equal("bar", output.chomp)
+
+        background_stop = Rundoc::CodeCommand::Background::Stop.new(name: "tail")
+        background_stop.call
+
+        assert_equal(false, background_start.alive?)
+      end
+    end
+  end
+end

data/test/rundoc/code_commands/bash_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class BashTest < Test::Unit::TestCase
+class BashTest < Minitest::Test
 
   def test_bash_returns_cd
     original_dir = `pwd`

data/test/rundoc/code_commands/pipe_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class PipeTest < Test::Unit::TestCase
+class PipeTest < Minitest::Test
 
   def test_pipe
     pipe_cmd = "tail -n 2"

data/test/rundoc/code_commands/remove_contents_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class RemoveContentsTest < Test::Unit::TestCase
+class RemoveContentsTest < Minitest::Test
 
   def setup
     @gemfile = <<-RUBY
@@ -21,14 +21,13 @@ class RemoveContentsTest < Test::Unit::TestCase
         @file = "foo.rb"
         `echo "#{@gemfile}" >> #{@file}`
 
-        assert_match /sqlite3/, File.read(@file)
+        assert_match(/sqlite3/, File.read(@file))
 
         cc = Rundoc::CodeCommand::FileCommand::Remove.new(@file)
         cc << "gem 'sqlite3'"
         cc.call
 
-        result = File.read(@file)
-        refute_match /sqlite3/, File.read(@file)
+        refute_match(/sqlite3/, File.read(@file))
 
         env = {}
         env[:commands] = []

data/test/rundoc/code_section_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class CodeSectionTest < Test::Unit::TestCase
+class CodeSectionTest < Minitest::Test
 
   def setup
   end
@@ -10,7 +10,7 @@ class CodeSectionTest < Test::Unit::TestCase
 sup
 
 ```
-:::-  $ mkdir foo
+:::--  $ mkdir foo
 ```
 
 yo
@@ -39,4 +39,97 @@ RUBY
     assert_equal contents, result
   end
 
+  def test_show_command_hide_render
+    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 false, code_command.render_result
+
+    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 false, code_command.render_result
+  end
+
+  def test_show_command_show_render
+    contents = <<-RUBY
+```
+:::>> $ echo "foo"
+```
+RUBY
+
+    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
+    code_section = Rundoc::CodeSection.new(match, keyword: ":::")
+    code_section.render
+
+    puts code_section.commands.inspect
+    code_command = code_section.commands.first
+    assert_equal true, code_command.render_command
+    assert_equal true, code_command.render_result
+  end
+
+  def test_hide_command_hide_render
+    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_result
+
+    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_result
+  end
+
+  def test_hide_command_show_render
+    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 true, code_command.render_result
+  end
+
 end

data/test/rundoc/parser_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ParserTest < Test::Unit::TestCase
+class ParserTest < Minitest::Test
 
   def setup
   end
@@ -10,8 +10,8 @@ class ParserTest < Test::Unit::TestCase
 sup
 
 ```
-:::  $ mkdir foo
-:::= $ ls
+:::>-  $ mkdir foo
+:::>> $ ls
 ```
 
 yo
@@ -24,11 +24,6 @@ RUBY
         parsed = Rundoc::Parser.new(contents)
         actual = parsed.to_md
         assert_equal expected, actual
-
-        parsed = Rundoc::Parser.new("\n```\n:::= $ ls\n```\n")
-        actual = parsed.to_md
-        expected = "\n```\n$ ls\nfoo\n```\n"
-        assert_equal expected, actual
       end
     end
   end
@@ -39,7 +34,7 @@ RUBY
 sup
 
 ```
-:::= write foo/code.rb
+:::>> write foo/code.rb
 a = 1 + 1
 b = a * 2
 ```
@@ -60,9 +55,9 @@ RUBY
     contents =  <<-RUBY
 
 ```
-:::= write foo/newb.rb
+:::>> write foo/newb.rb
 puts 'hello world'
-:::= $ cat foo/newb.rb
+:::>> $ cat foo/newb.rb
 ```
 RUBY
 
@@ -81,14 +76,13 @@ RUBY
 
     contents =  <<-RUBY
 ```
-:::= irb --simple-prompt
+:::>> irb --simple-prompt
 a = 3
 b = "foo" * a
 puts b
 ```
 RUBY
 
-
     Dir.mktmpdir do |dir|
       Dir.chdir(dir) do
 

data/test/rundoc/peg_parser_test.rb

@@ -0,0 +1,381 @@
+require 'test_helper'
+require 'parslet/convenience'
+
+class PegParserTest < Minitest::Test
+  def setup
+    @transformer = Rundoc::PegTransformer.new
+  end
+
+  def test_string
+    input = %Q{"hello world"}
+    parser = Rundoc::PegParser.new.string
+    tree = parser.parse_with_debug(input)
+    expected = {:string => "hello world"}
+    assert_equal expected, tree
+
+    actual = @transformer.apply(tree)
+    assert_equal "hello world", actual
+  end
+
+  def test_keyword_args
+    input = %Q{foo: 'bar', baz: "boo"}
+    parser = Rundoc::PegParser.new.named_args
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    expected = {foo: 'bar', baz: "boo"}
+    assert_equal expected, actual
+  end
+
+  def test_method_call
+    input = %Q{sup(foo: 'bar')}
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :sup, actual.keyword
+    assert_equal({foo: 'bar'}, actual.original_args)
+
+    # seattle style
+    input = %Q{sup foo: 'bar' }
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    assert_equal :sup, actual.keyword
+    assert_equal({foo: 'bar'}, actual.original_args)
+
+    # with a dot
+    input = %Q{sup.you foo: 'bar' }
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    assert_equal :"sup.you", actual.keyword
+    assert_equal({foo: 'bar'}, actual.original_args)
+  end
+
+  def test_with_string_arg
+    input = %Q{sup("hey")}
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :sup, actual.keyword
+    assert_equal("hey", actual.original_args)
+
+    input = %Q{sup "hey"}
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :sup, actual.keyword
+    assert_equal("hey", actual.original_args)
+
+    input = %Q{sup hey}
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :sup, actual.keyword
+    assert_equal("hey", actual.original_args)
+
+    input = %Q{ $ cat foo.rb}
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :"$", actual.keyword
+    assert_equal("cat foo.rb", actual.original_args)
+  end
+
+  def test_visability
+    input = %Q{>>}
+    parser = Rundoc::PegParser.new.visability
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    assert_equal true, actual.command?
+    assert_equal true, actual.result?
+
+    input = %Q{->}
+    parser = Rundoc::PegParser.new.visability
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    assert_equal false, actual.command?
+    assert_equal true, actual.result?
+
+    input = %Q{--}
+    parser = Rundoc::PegParser.new.visability
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    assert_equal false, actual.command?
+    assert_equal false, actual.result?
+
+    input = %Q{>-}
+    parser = Rundoc::PegParser.new.visability
+    tree = parser.parse_with_debug(input)
+    actual = @transformer.apply(tree)
+    assert_equal true, actual.command?
+    assert_equal false, actual.result?
+  end
+
+  def test_command
+    input = %Q{:::>> $ cat foo.rb\n}
+    parser = Rundoc::PegParser.new.command
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :"$", actual.keyword
+    assert_equal("cat foo.rb", actual.original_args)
+  end
+
+  def test_command_with_stdin
+    input = String.new
+    input << ":::>> file.write hello.txt\n"
+    input << "world\n"
+
+    parser = Rundoc::PegParser.new.command_with_stdin
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :"file.write", actual.keyword
+    assert_equal("hello.txt", actual.original_args)
+    assert_equal("world\n", actual.contents)
+  end
+
+  def test_command_with_stdin_no_string
+    input = String.new
+    input << ":::>> file.write hello.txt\n"
+
+    parser = Rundoc::PegParser.new.command_with_stdin
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal :"file.write", actual.keyword
+    assert_equal("hello.txt", actual.original_args)
+  end
+
+  def test_multiple_commands_stdin
+    input = String.new
+    input << ":::>> file.write hello.txt\n"
+    input << "world\n"
+    input << ":::>> file.write cinco.txt\n"
+    input << "\n\n\n"
+    input << "  river\n"
+
+    parser = Rundoc::PegParser.new.multiple_commands
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal :"file.write", actual.first.keyword
+    assert_equal("hello.txt", actual.first.original_args)
+    assert_equal("world\n", actual.first.contents)
+
+    assert_equal :"file.write", actual.last.keyword
+    assert_equal("cinco.txt", actual.last.original_args)
+    assert_equal("\n\n\n  river\n", actual.last.contents)
+  end
+
+  def test_multiple_commands_with_fence
+    input = String.new
+    input << "```\n"
+    input << ":::>> file.write hello.txt\n"
+    input << "world\n"
+    input << "```\n"
+
+    parser = Rundoc::PegParser.new.fenced_commands
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal :"file.write", actual.first.keyword
+    assert_equal("hello.txt", actual.first.original_args)
+    assert_equal("world\n", actual.first.contents)
+  end
+
+  def test_raw
+    input = String.new
+    input << "hello.txt\n"
+    input << "world\n"
+    input << ":::>> $ cd foo\n"
+
+    parser = Rundoc::PegParser.new.raw_code
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal "hello.txt\nworld\n", actual.first.contents
+    assert_equal :"$", actual.last.keyword
+    assert_equal("cd foo", actual.last.original_args)
+  end
+
+
+  def test_quotes_in_shell_commands
+    input = %Q{:::>- $ git commit -m "init"\n}
+    parser = Rundoc::PegParser.new.code_block
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal :"$", actual.last.keyword
+    assert_equal('git commit -m "init"', actual.last.original_args)
+  end
+
+  def test_raises_on_syntax
+    input = %Q{:::> $ git commit -m "init"\n}
+    assert_raises(Rundoc::PegTransformer::TransformError) do
+      parser = Rundoc::PegParser.new.code_block
+      tree = parser.parse_with_debug(input)
+
+      actual = @transformer.apply(tree)
+    end
+  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 = String.new
+    input << %Q{:::-- rundoc\n}
+    input << %Q{email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`\n}
+
+    parser = Rundoc::PegParser.new.command_with_stdin
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :rundoc, actual.keyword
+    assert_equal("email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`", actual.original_args)
+  end
+
+  def test_rundoc_sub_commands_no_quotes
+    input = String.new
+    input << %Q{:::-- rundoc.depend_on ../foo/bar.md\n}
+
+    parser = Rundoc::PegParser.new.command_with_stdin
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal :"rundoc.depend_on", actual.keyword
+  end
+
+  def test_seattle_style_method_call
+    input = String.new
+    input << %Q{rundoc.depend_on '../foo/bar.md'}
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal :"rundoc.depend_on", actual.keyword
+  end
+
+  def test_rundoc_seattle_sub_command
+    input = String.new
+    input << %Q{:::>> rundoc.depend_on '../foo/bar.md'\n}
+
+    parser = Rundoc::PegParser.new.command
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+
+    assert_equal :"rundoc.depend_on", actual.keyword
+  end
+
+  def test_positional_args
+    input = +""
+    input << %Q{call("foo", "bar", biz: "baz")}
+
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    # =====================================
+    #
+    # Handles more than one value, but not only one value
+    actual = @transformer.apply(tree)
+    assert_equal ["foo", "bar", { biz: "baz"}], actual.original_args
+
+    input = +""
+    input << %Q{call("foo", biz: "baz")}
+
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal ["foo", { biz: "baz"}], actual.original_args
+
+    input = +""
+    input << %Q{call("rails server", name: "server")}
+
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    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 << %Q{call("foo", "bar")}
+
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    # puts tree.inspect
+
+    actual = @transformer.apply(tree)
+    assert_equal ["foo", "bar"], actual.original_args
+
+    # ======================
+
+    input = +""
+    input << %Q{call("foo", "bar", biz: "baz")}
+
+    parser = Rundoc::PegParser.new.method_call
+    tree = parser.parse_with_debug(input)
+
+    actual = @transformer.apply(tree)
+    assert_equal ["foo", "bar", { biz: "baz"}], actual.original_args
+  end
+
+  def test_positional_args_code_block
+
+    input = +""
+    input << %Q{:::>> 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
+  end
+end