rundoc 0.0.1

data/lib/rundoc.rb

@@ -0,0 +1,76 @@
+require 'fileutils'
+require 'pathname'
+require 'rundoc/version'
+
+module Rundoc
+  extend self
+
+  def code_command_from_keyword(keyword, args)
+    klass      = code_command(keyword.to_sym) || Rundoc::CodeCommand::NoSuchCommand
+    cc         = klass.new(args)
+    cc.keyword = keyword
+    cc
+  end
+
+  def parser_options
+    @parser_options ||= {}
+  end
+
+  def code_lookup
+    @code_lookup ||= {}
+  end
+
+  def code_command(keyword)
+    code_lookup[:"#{keyword}"]
+  end
+
+  def known_commands
+    code_lookup.keys
+  end
+
+  def register_code_command(keyword, klass)
+    code_lookup[keyword] = klass
+  end
+
+  def configure(&block)
+    yield self
+  end
+
+  def run_after_build
+    @after_build_block ||= []
+    @after_build_block.each(&:call)
+  end
+
+  def after_build(&block)
+    @after_build_block ||= []
+    @after_build_block << block
+  end
+
+  def config
+    yield self
+  end
+
+  def register_repl(*args, &block)
+    ReplRunner.register_commands(*args, &block)
+  end
+
+  def filter_sensitive(sensitive)
+    raise "Expecting #{sensitive} to be a hash" unless sensitive.is_a?(Hash)
+    @sensitive ||= {}
+    @sensitive.merge!(sensitive)
+  end
+
+  def sanitize(doc)
+    return doc if @sensitive.nil?
+    @sensitive.each do |sensitive, replace|
+      doc.gsub!(sensitive.to_s, replace)
+    end
+    return doc
+  end
+
+  attr_accessor :project_root
+end
+
+require 'rundoc/parser'
+require 'rundoc/code_section'
+require 'rundoc/code_command'

data/lib/rundoc/code_command.rb

@@ -0,0 +1,32 @@
+module Rundoc
+  class CodeCommand
+    attr_accessor :hidden, :render_result, :command, :contents, :keyword
+    alias :hidden? :hidden
+    alias :render_result? :render_result
+
+    def initialize(arg)
+    end
+
+    def not_hidden?
+      !hidden?
+    end
+
+    def push(contents)
+      @contents ||= ""
+      @contents << contents
+    end
+    alias :<< :push
+
+    # executes command to build project
+    def call(env = {})
+      raise "not implemented"
+    end
+  end
+end
+
+require 'rundoc/code_command/bash'
+require 'rundoc/code_command/pipe'
+require 'rundoc/code_command/write'
+require 'rundoc/code_command/repl'
+require 'rundoc/code_command/rundoc_command'
+require 'rundoc/code_command/no_such_command'

data/lib/rundoc/code_command/bash.rb

@@ -0,0 +1,57 @@
+class Rundoc::CodeCommand::Bash < Rundoc::CodeCommand
+
+  # line = "cd ..""
+  # line = "pwd"
+  # line = "ls"
+  def initialize(line)
+    @line     = line
+    @contents = ""
+    @delegate = case @line.split(' ').first.downcase
+    when 'cd'
+      Cd.new(@line)
+    else
+      false
+    end
+  end
+
+  def to_md(env = {})
+    return @delegate.to_md(env) if @delegate
+
+    "$ #{@line}"
+  end
+
+  def call(env = {})
+    return @delegate.call(env) if @delegate
+
+    shell(@line, @contents)
+  end
+
+  # markdown doesn't understand bash color codes
+  def sanitize_escape_chars(input)
+    input.gsub(/\e\[(\d+)m/, '')
+  end
+
+  def shell(cmd, stdin = nil)
+    msg  = "Running: $ '#{cmd}'"
+    msg  << " with stdin: '#{stdin.inspect}'" if stdin && !stdin.empty?
+    puts msg
+
+    result = ""
+    IO.popen("#{cmd} 2>&1", "w+") do |io|
+      io << stdin if stdin
+      io.close_write
+      result = sanitize_escape_chars io.read
+    end
+    unless $?.success?
+      raise "Command `#{@line}` exited with non zero status: #{result}" unless keyword.include?("fail")
+    end
+    return result
+  end
+end
+
+
+Rundoc.register_code_command(:bash, Rundoc::CodeCommand::Bash)
+Rundoc.register_code_command(:'$',  Rundoc::CodeCommand::Bash)
+Rundoc.register_code_command(:'fail.$',  Rundoc::CodeCommand::Bash)
+
+require 'rundoc/code_command/bash/cd'

data/lib/rundoc/code_command/bash/cd.rb

@@ -0,0 +1,18 @@
+class Rundoc::CodeCommand::Bash
+  # special purpose class to persist cd behavior across the entire program
+  # we change the directory of the parent program (rundoc) rather than
+  # changing the directory of a spawned child (via exec, ``, system, etc.)
+  class Cd < Rundoc::CodeCommand::Bash
+
+    def initialize(line)
+      @line     = line
+    end
+
+    def call(env)
+      line = @line.sub('cd', '').strip
+      puts "running $ cd #{line}"
+      Dir.chdir(line)
+      nil
+    end
+  end
+end

data/lib/rundoc/code_command/file_command/append.rb

@@ -0,0 +1,74 @@
+class Rundoc::CodeCommand::FileCommand
+  class Append < Rundoc::CodeCommand
+
+    def initialize(filename)
+      @filename, line = filename.split('#')
+      @line_number    = Integer(line) if line
+    end
+
+    def to_md(env)
+      raise "must call write in its own code section" unless env[:commands].empty?
+      before = env[:before]
+      if @line_number
+        env[:before] = "In file `#{@filename}`, on line #{@line_number} add:\n\n#{before}"
+      else
+        env[:before] = "At the end of `#{@filename}` add:\n\n#{before}"
+      end
+      nil
+    end
+
+    def last_char_of(string)
+      string[-1,1]
+    end
+
+    def ends_in_newline?(string)
+      last_char_of(string) == "\n"
+    end
+
+    def concat_with_newline(str1, str2)
+      result = ""
+      result << str1
+      result << "\n" unless ends_in_newline?(result)
+      result << str2
+      result << "\n" unless ends_in_newline?(result)
+      result
+    end
+
+    def insert_contents_into_at_line(doc)
+      lines = doc.lines
+      raise "Expected #{@filename} to have at least #{@line_number} but only has #{lines.count}" if lines.count < @line_number
+      result = []
+      lines.each_with_index do |line, index|
+        line_number = index.next
+        if line_number == @line_number
+          result << contents
+          result << "\n" unless ends_in_newline?(contents)
+        end
+        result << line
+      end
+      doc = result.flatten.join("")
+    end
+
+    def call(env = {})
+      dir = File.expand_path("../", @filename)
+      FileUtils.mkdir_p(dir)
+
+      doc = File.read(@filename)
+      if @line_number
+        puts "Writing to: '#{@filename}' line #{@line_number} with: #{contents.inspect}"
+        doc = insert_contents_into_at_line(doc)
+      else
+        puts "Appending to file: '#{@filename}' with: #{contents.inspect}"
+        doc = concat_with_newline(doc, contents)
+      end
+
+      File.open(@filename, "w") do |f|
+        f.write(doc)
+      end
+      contents
+    end
+  end
+end
+
+
+Rundoc.register_code_command(:'file.append',  Rundoc::CodeCommand::FileCommand::Append)

data/lib/rundoc/code_command/file_command/remove.rb

@@ -0,0 +1,32 @@
+class Rundoc::CodeCommand::FileCommand
+  class Remove < Rundoc::CodeCommand
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def to_md(env)
+      raise "must call write in its own code section" unless env[:commands].empty?
+      before = env[:before]
+      env[:before] = "In file `#{@filename}` remove:\n\n#{before}"
+      nil
+    end
+
+    def call(env = {})
+      puts "Deleting '#{contents.strip}' from #{@filename}"
+      raise "#{@filename} does not exist" unless File.exist?(@filename)
+
+      regex = /^\s*#{Regexp.quote(contents)}/
+      doc   = File.read(@filename)
+      doc.sub!(regex, '')
+
+      File.open(@filename, "w") do |f|
+        f.write(doc)
+      end
+      contents
+    end
+  end
+end
+
+
+Rundoc.register_code_command(:'file.remove',  Rundoc::CodeCommand::FileCommand::Remove)

data/lib/rundoc/code_command/no_such_command.rb

@@ -0,0 +1,6 @@
+module Rundoc
+  class CodeCommand
+    class NoSuchCommand < Rundoc::CodeCommand
+    end
+  end
+end

data/lib/rundoc/code_command/pipe.rb

@@ -0,0 +1,37 @@
+module Rundoc
+  class CodeCommand
+    class Pipe < Rundoc::CodeCommand
+
+      # ::: ls
+      # ::: | tail -n 2
+      # => "test\ntmp.file\n"
+      def initialize(line)
+        line_array = line.split(" ")
+        @first     = line_array.shift.strip
+        @delegate  = Rundoc.code_command_from_keyword(@first, line_array.join(" "))
+        @delegate  = Rundoc::CodeCommand::Bash.new(line) if @delegate.kind_of?(Rundoc::CodeCommand::NoSuchCommand)
+      end
+
+      # before: "",
+      # after:  "",
+      # commands:
+      #   [[cmd, output], [cmd, output]]
+      def call(env = {})
+        last_command = env[:commands].last
+        puts "Piping: results of '#{last_command[:command]}' to '#{@delegate}'"
+
+        @delegate.push(last_command[:output])
+        @delegate.call(env)
+      end
+
+      def to_md(env = {})
+        ""
+      end
+    end
+  end
+end
+
+
+Rundoc.register_code_command(:pipe, Rundoc::CodeCommand::Pipe)
+Rundoc.register_code_command(:|,    Rundoc::CodeCommand::Pipe)
+

data/lib/rundoc/code_command/repl.rb

@@ -0,0 +1,37 @@
+require 'repl_runner'
+
+module Rundoc
+  class CodeCommand
+    class Repl < Rundoc::CodeCommand
+      def initialize(command)
+        @command     = command
+        @contents = ""
+      end
+
+      def keyword=(keyword)
+        @keyword = keyword
+        if keyword.to_s == "repl"
+          command_array = @command.split(" ")
+          @keyword      = command_array.first
+        else
+          @command = "#{keyword} #{@command}"
+        end
+      end
+
+      def call(env = {})
+        puts "Running '#{@command}'' with repl: #{keyword}"
+        repl    = ReplRunner.new(:"#{keyword}", @command)
+        @result = repl.zip(contents.strip).flatten.join("\n")
+        return @result
+      end
+
+      def to_md(env = {})
+        return "$ #{@command}"
+      end
+    end
+  end
+end
+
+
+Rundoc.register_code_command(:repl, Rundoc::CodeCommand::Repl)
+Rundoc.register_code_command(:irb,  Rundoc::CodeCommand::Repl)

data/lib/rundoc/code_command/rundoc_command.rb

@@ -0,0 +1,22 @@
+module ::Rundoc
+  class CodeCommand
+    class ::RundocCommand < ::Rundoc::CodeCommand
+
+      def initialize(line)
+      end
+
+      def to_md(env = {})
+        ""
+      end
+
+      def call(env = {})
+        puts "Running: #{contents}"
+        eval(contents)
+        ""
+      end
+    end
+  end
+end
+
+
+Rundoc.register_code_command(:rundoc, ::Rundoc::CodeCommand::RundocCommand)

data/lib/rundoc/code_command/write.rb

@@ -0,0 +1,34 @@
+module Rundoc
+  class CodeCommand
+    class Write < Rundoc::CodeCommand
+      def initialize(filename)
+        @filename = filename
+      end
+
+      def to_md(env)
+        raise "must call write in its own code section" unless env[:commands].empty?
+        before = env[:before]
+        env[:before] = "In file `#{@filename}` write:\n\n#{before}"
+        nil
+      end
+
+      def call(env = {})
+        puts "Writing to: '#{@filename}'"
+
+        dir = File.expand_path("../", @filename)
+        FileUtils.mkdir_p(dir)
+        File.open(@filename, "w") do |f|
+          f.write(contents)
+        end
+        contents
+      end
+    end
+  end
+end
+
+
+Rundoc.register_code_command(:write,        Rundoc::CodeCommand::Write)
+Rundoc.register_code_command(:'file.write', Rundoc::CodeCommand::Write)
+
+require 'rundoc/code_command/file_command/append'
+require 'rundoc/code_command/file_command/remove'

data/lib/rundoc/code_section.rb

@@ -0,0 +1,145 @@
+module Rundoc
+  # holds code, parses and creates CodeCommand
+  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
+    attr_accessor :original, :fence, :lang, :code, :commands, :keyword
+
+    def initialize(match, options = {})
+      @original = match.to_s
+      @commands = []
+      @stack    = []
+      @keyword  = options[:keyword] or raise "keyword is required"
+      @fence    = match[:fence]
+      @lang     = match[:lang]
+      @code     = match[:contents]
+      parse_code_command
+    end
+
+    def render
+      result = []
+      env = {}
+      env[:commands] = []
+      env[:before]   = "#{fence}#{lang}"
+      env[:after]    = "#{fence}"
+
+      @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}
+
+        if code_command.render_result?
+          result << [code_line, code_output]
+        else
+          result << code_line unless code_command.hidden?
+        end
+      end
+
+      return "" if hidden?
+
+      array = [env[:before], result, env[:after]]
+      return array.flatten.compact.map(&:rstrip).reject(&:empty?).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 command_regex
+      COMMAND_REGEX.call(keyword)
+    end
+
+    def add_code(match, line)
+      add_match_to_code_command(match, commands)
+      check_parse_error(line, code)
+    end
+
+    def add_contents(line)
+      if commands.empty?
+        @stack << line
+      else
+        commands.last << line
+      end
+    end
+
+    def parse_code_command
+      code.lines.each do |line|
+        if match = line.match(command_regex)
+          add_code(match, line)
+        else
+          add_contents(line)
+        end
+      end
+    end
+
+    def add_match_to_code_command(match, commands)
+      command      = match[:command]
+      tag          = match[:tag]
+      statement    = match[:statement]
+
+      code_command = Rundoc.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?(Rundoc::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?(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