rundoc 0.0.1

data/test/rundoc/code_commands/append_file_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class AppendFileTest < Test::Unit::TestCase
+
+  def test_appends_to_a_file
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+
+        file = "foo.rb"
+        `echo 'foo' >> #{file}`
+
+        cc = Rundoc::CodeCommand::FileCommand::Append.new(file)
+        cc << "bar"
+        cc.call
+
+        result = File.read(file)
+
+        assert_match /foo/, result
+        assert_match /bar/, result
+
+        cc = Rundoc::CodeCommand::FileCommand::Append.new(file)
+        cc << "baz"
+        cc.call
+
+        actual   = File.read(file)
+        expected = "foo\nbar\nbaz\n"
+        assert_equal expected, actual
+      end
+    end
+  end
+
+    def test_appends_to_a_file_at_line_number
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+
+contents = <<-CONTENTS
+source 'https://rubygems.org'
+gem 'rails', '4.0.0'
+CONTENTS
+
+        file = "foo.rb"
+        line = 2
+        `echo '#{contents}' >> #{file}`
+
+        cc = Rundoc::CodeCommand::FileCommand::Append.new("#{file}##{line}")
+        cc << "gem 'pg'"
+        cc.call
+
+        expected = "source https://rubygems.org\ngem 'pg'\ngem rails, 4.0.0\n\n"
+        assert_equal expected, File.read(file)
+      end
+    end
+  end
+
+end

data/test/rundoc/code_commands/bash_test.rb

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

data/test/rundoc/code_commands/pipe_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class PipeTest < Test::Unit::TestCase
+
+  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}])
+
+    expected = `#{cmd} | #{pipe_cmd}`
+    assert_equal expected, actual
+  end
+end

data/test/rundoc/code_commands/remove_contents_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class RemoveContentsTest < Test::Unit::TestCase
+
+  def setup
+    @gemfile = <<-RUBY
+
+    source 'https://rubygems.org'
+
+    # Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
+    gem 'rails', '4.0.0'
+
+    gem 'sqlite3'
+    RUBY
+  end
+
+  def test_appends_to_a_file
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+
+        @file = "foo.rb"
+        `echo "#{@gemfile}" >> #{@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)
+
+        env = {}
+        env[:commands] = []
+        env[:before]   = "```ruby"
+        cc.to_md(env)
+
+        assert_equal "In file `foo.rb` remove:\n\n```ruby", env[:before]
+      end
+    end
+  end
+end

data/test/rundoc/code_section_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class CodeSectionTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_does_not_render_if_all_contents_hidden
+    contents =  <<-RUBY
+sup
+
+```
+:::-  $ mkdir foo
+```
+
+yo
+RUBY
+
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
+        result = Rundoc::CodeSection.new(match, keyword: ":::").render
+        assert_equal "", result
+      end
+    end
+  end
+
+
+  def test_no_code
+    contents = <<-RUBY
+```ruby
+gem 'sqlite3'
+```
+RUBY
+
+    match = contents.match(Rundoc::Parser::CODEBLOCK_REGEX)
+    result = Rundoc::CodeSection.new(match, keyword: ":::").render
+    assert_equal contents, result
+  end
+
+end

data/test/rundoc/parser_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class ParserTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_parse_bash
+    contents =  <<-RUBY
+sup
+
+```
+:::  $ 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
+        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
+
+
+  def test_parse_write_commands
+    contents =  <<-RUBY
+sup
+
+```
+:::= 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
+        assert_equal expected, actual
+      end
+    end
+
+
+    contents =  <<-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
+        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

data/test/rundoc/regex_test.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+
+class RegexTest < Test::Unit::TestCase
+
+  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
+    parsed = contents.match(/#{regex}/m).to_s
+    assert_equal "```\n$ cd\nyo\nsup\n```\n", parsed
+  end
+
+  def test_github_tagged_regex
+    contents =  <<-RUBY
+foo
+
+```ruby
+$ cd
+yo
+sup
+```
+
+bar
+RUBY
+
+    regex  = Rundoc::Parser::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
+
+    actual   = contents.partition(regex)
+    expected = ["foo\n\n",
+                "```\n:::$ mkdir\n```\n",
+                "\nzoo\n\n```\n:::$ cd ..\nsomething\n```\n\nbar\n"]
+
+    assert_equal  expected, actual
+
+    str = "```\n:::$ mkdir\n```\n"
+    match = str.match(regex)
+    assert_equal ":::$ mkdir\n", match[:contents]
+
+    str = "\n\n```\n:::$ cd ..\nsomething\n```\n\nbar\n"
+    match = str.match(regex)
+    assert_equal ":::$ cd ..\nsomething\n", match[:contents]
+
+    # partition, shift, codebloc,
+  end
+
+  def test_complex_regex
+
+    contents =  <<-RUBY
+```java
+:::= write app/controllers/Application.java
+package controllers;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import models.Pinger;
+import play.libs.Akka;
+import play.libs.F.Callback0;
+import play.mvc.Controller;
+import play.mvc.Result;
+import play.mvc.WebSocket;
+import scala.concurrent.duration.Duration;
+import views.html.index;
+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>() {
+            public void onReady(WebSocket.In<String> in, WebSocket.Out<String> out) {
+                final ActorRef pingActor = Akka.system().actorOf(Props.create(Pinger.class, in, out));
+                final Cancellable cancellable = Akka.system().scheduler().schedule(Duration.create(1, SECONDS),
+                                                   Duration.create(1, SECONDS),
+                                                   pingActor,
+                                                   "Tick",
+                                                   Akka.system().dispatcher(),
+                                                   null
+                                                   );
+
+                in.onClose(new Callback0() {
+                  @Override
+                  public void invoke() throws Throwable {
+                    cancellable.cancel();
+                  }
+                });
+            }
+
+        };
+    }
+
+    public static Result pingJs() {
+        return ok(views.js.ping.render());
+    }
+
+    public static Result index() {
+        return ok(index.render());
+    }
+}
+```
+RUBY
+
+    regex = Rundoc::Parser::CODEBLOCK_REGEX
+    match = contents.match(regex)
+    assert_equal 'java', match[:lang]
+    assert_equal '```', match[:fence]
+    assert_equal '`', match[:fence_char]
+
+    assert_equal contents.strip, match.to_s.strip
+  end
+
+end