docdown 0.0.1

data/lib/docdown/parser.rb

@@ -0,0 +1,138 @@
+module Docdown
+  class Parser
+    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: #{Docdown.known_commands.inspect}\n\n"
+        msg << block
+        msg << "\n"
+        super msg
+      end
+
+    end
+
+    DEFAULT_KEYWORD    = ":::"
+    INDENT_BLOCK       = '(?<before_indent>(^\s*$\n|\A)(^(?:[ ]{4}|\t))(?<indent_contents>.*)(?<after_indent>[^\s].*$\n?(?:(?:^\s*$\n?)*^(?:[ ]{4}|\t).*[^\s].*$\n?)*))'
+    GITHUB_BLOCK       = '^(?<fence>(?<fence_char>~|`){3,})\s*?(?<lang>\w+)?\s*?\n(?<contents>.*?)^\g<fence>\g<fence_char>*\s*?\n'
+    CODEBLOCK_REGEX    = /(#{GITHUB_BLOCK})/m
+    COMMAND_REGEX      = ->(keyword) {
+                             /^#{keyword}(?<tag>(\s|=|-)?)\s*(?<command>(\S)+)\s+(?<statement>.*)$/
+                            }
+
+    attr_reader :contents, :keyword, :stack
+
+    def initialize(contents, options = {})
+      @contents = contents
+      @original = contents.dup
+      @keyword  = options[:keyword] || DEFAULT_KEYWORD
+      @stack    = []
+      partition
+    end
+
+
+    def to_md
+      @stack.map do |s|
+        if s.respond_to?(:render)
+          s.render
+        else
+          s
+        end
+      end.join("")
+    end
+
+    # split into [before_code, code, after_code], process code, and re-run until tail is empty
+    def partition
+      until contents.empty?
+        head, code, tail = contents.partition(CODEBLOCK_REGEX)
+        @stack << head        unless head.empty?
+        add_fenced_code(code) unless code.empty?
+        @contents = tail
+      end
+    end
+
+    def add_fenced_code(fenced_code_str)
+      fenced_code_str.match(CODEBLOCK_REGEX) do |m|
+        fence = m[:fence]
+        lang  = m[:lang]
+        code  = m[:contents]
+        @stack << "#{fence}#{lang}\n"
+        add_code_commands(code)
+        @stack << "#{fence}\n"
+      end
+    end
+
+    def add_match_to_code_commands(match, commands)
+      command      = match[:command]
+      tag          = match[:tag]
+      statement    = match[:statement]
+
+      code_command = Docdown.code_command_from_keyword(command, statement)
+
+      case tag
+      when /\-/
+        code_command.hidden        = true
+      when /\=/
+        code_command.render_result = true
+      when /\s/
+        # default do nothing
+      end
+
+      @stack   << "\n" if commands.last.is_a?(Docdown::CodeCommand)
+      @stack   << code_command
+      commands << code_command
+      code_command
+    end
+
+    def check_parse_error(command, code_block)
+      return unless code_command = @stack.last
+      return unless code_command.is_a?(Docdown::CodeCommands::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
+
+    def add_code_commands(code)
+      commands = []
+      code.lines.each do |line|
+        if match = line.match(command_regex)
+          add_match_to_code_commands(match, commands)
+          check_parse_error(line, code)
+        else
+          unless commands.empty?
+            commands.last << line
+            next
+          end
+          @stack << line
+        end
+      end
+    end
+
+    def contents_to_array
+      partition
+    end
+
+    def command_regex
+      COMMAND_REGEX.call(keyword)
+    end
+  end
+end
+
+
+# convert string of markdown to array of strings and code_commands

data/lib/docdown/version.rb

@@ -0,0 +1,3 @@
+module Docdown
+  VERSION = "0.0.1"
+end

data/test/docdown/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 = Docdown::Parser.new(contents)
+        actual = parsed.to_md
+        assert_equal expected, actual
+
+        parsed = Docdown::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\n```\nIn file `foo/code.rb` add:\na = 1 + 1\nb = a * 2\n```\nyo\n"
+        parsed = Docdown::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 = "\n```\nIn file `foo/newb.rb` add:\nputs 'hello world'\n\n$ cat foo/newb.rb \nputs 'hello world'\n```\n"
+        parsed = Docdown::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 = Docdown::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\r```\n"
+        assert_equal expected, actual
+      end
+    end
+
+  end
+
+end

data/test/docdown/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  = Docdown::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  = Docdown::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  = Docdown::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    = Docdown::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    = Docdown::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 = Docdown::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

data/test/docdown/test_parse_java.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class ParseJavaTest < Test::Unit::TestCase
+
+  def setup
+
+  end
+end