rundoc 0.0.2 → 1.0.0

data/lib/rundoc/code_command/background/stop.rb

@@ -0,0 +1,17 @@
+class Rundoc::CodeCommand::Background
+  class Stop < Rundoc::CodeCommand
+    def initialize(name: )
+      @spawn = Rundoc::CodeCommand::Background::ProcessSpawn.find(name)
+    end
+
+    def to_md(env = {})
+      ""
+    end
+
+    def call(env = {})
+      @spawn.stop
+      ""
+    end
+  end
+end
+Rundoc.register_code_command(:"background.stop", Rundoc::CodeCommand::Background::Stop)

data/lib/rundoc/code_command/background/wait.rb

@@ -0,0 +1,19 @@
+class Rundoc::CodeCommand::Background
+  class Wait < Rundoc::CodeCommand
+    def initialize(name: , wait:, timeout: 5)
+      @spawn = Rundoc::CodeCommand::Background::ProcessSpawn.find(name)
+      @wait  = wait
+      @timeout_value = Integer(timeout)
+    end
+
+    def to_md(env = {})
+      ""
+    end
+
+    def call(env = {})
+      @spawn.wait(@wait, @timeout_value)
+      ""
+    end
+  end
+end
+Rundoc.register_code_command(:"background.wait", Rundoc::CodeCommand::Background::Wait)

data/lib/rundoc/code_command/bash.rb

@@ -43,7 +43,7 @@ class Rundoc::CodeCommand::Bash < Rundoc::CodeCommand
       result = sanitize_escape_chars io.read
     end
     unless $?.success?
-      raise "Command `#{@line}` exited with non zero status: #{result}" unless keyword.include?("fail")
+      raise "Command `#{@line}` exited with non zero status: #{result}" unless keyword.to_s.include?("fail")
     end
     return result
   end

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

@@ -5,7 +5,7 @@ class Rundoc::CodeCommand::Bash
   class Cd < Rundoc::CodeCommand::Bash
 
     def initialize(line)
-      @line     = line
+      @line = line
     end
 
     def call(env)

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

@@ -12,6 +12,8 @@ class Rundoc::CodeCommand::FileCommand
     end
 
     def to_md(env)
+      return unless render_command?
+
       raise "must call write in its own code section" unless env[:commands].empty?
       before = env[:before]
       if @line_number

data/lib/rundoc/code_command/raw.rb

@@ -0,0 +1,18 @@
+module Rundoc
+  class CodeCommand
+    class Raw < CodeCommand
+      def initialize(contents, visible: true)
+        @contents = contents
+        @render_result = visible
+      end
+
+      def call(env = {})
+        contents.to_s
+      end
+
+      def to_md(env = {})
+        contents.to_s
+      end
+    end
+  end
+end

data/lib/rundoc/code_command/rundoc_command.rb

@@ -2,7 +2,8 @@ module ::Rundoc
   class CodeCommand
     class ::RundocCommand < ::Rundoc::CodeCommand
 
-      def initialize(line)
+      def initialize(contents = "")
+        @contents = contents
       end
 
       def to_md(env = {})

data/lib/rundoc/code_section.rb

@@ -82,83 +82,30 @@ module Rundoc
       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
+      parser = Rundoc::PegParser.new.code_block
+      tree = parser.parse(@code)
+      actual = Rundoc::PegTransformer.new.apply(tree)
+      actual = [actual] unless actual.is_a?(Array)
+      actual.each do |code_command|
+        @stack   << "\n" if commands.last.is_a?(Rundoc::CodeCommand)
+        @stack   << code_command
+        commands << code_command
       end
+    rescue ::Parslet::ParseFailed => e
+      raise "Could not compile code:\n#{@code}\nReason: #{e.message}"
     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 /\A>>/ # show command, show result
-        code_command.render_command = true
-        code_command.render_result  = true
-      when /(\A>\-)|(\A>[^\-]?)/ # show command, not result
-        code_command.render_command = true
-        code_command.render_result  = false
-      when /\A\->/ # hide command, show result
-        code_command.render_command = false
-        code_command.render_result  = true
-      when /(\A\-)|(\A\-\-)/ # hide command, hide result
-        code_command.render_command = false
-        code_command.render_result  = false
-      # ========= DEPRECATED ==========
-      when /\=/
-        puts "Deprecated: `:::=` is deprecated use `:::>>` instead"
-        puts "  :::>> #{command} #{statement}"
-        code_command.render_command = true
-        code_command.render_result  = true
-      when /\s/
-        puts "Deprecated: `:::` is deprecated use `:::>` instead"
-        puts "  :::> #{command} #{statement}"
-        code_command.render_command = true
-        code_command.render_result  = false
-      else
-        raise "Tag is invalid #{tag.inspect}"
-      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
+    # 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

data/lib/rundoc/peg_parser.rb

@@ -0,0 +1,282 @@
+require 'parslet'
+
+module Rundoc
+  class PegParser < Parslet::Parser
+    rule(:spaces)  { match('\s').repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+    rule(:comma)   { spaces? >> str(',') >> spaces? }
+    rule(:digit)   { match('[0-9]') }
+    rule(:lparen)  { str('(') >> spaces? }
+    rule(:rparen)  { str(')') }
+    rule(:newline)     { str("\r").maybe >> str("\n") }
+
+    rule(:singlequote_string) {
+      str("'") >> (
+        str("'").absnt? >> any
+      ).repeat.as(:string) >>
+      str("'") >> spaces?
+    }
+    rule(:doublequote_string) {
+      str('"') >> (
+        str('"').absnt? >> any
+      ).repeat.as(:string) >>
+      str('"') >> spaces?
+    }
+    rule(:string) { doublequote_string | singlequote_string }
+
+    rule(:number) {
+      (
+        str('-').maybe >> (
+          str('0') | (match('[1-9]') >> digit.repeat)
+        ) >> (
+          str('.') >> digit.repeat(1)
+        ).maybe >> (
+          match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+        ).maybe
+      ).as(:number)
+    }
+
+    rule(:value) {
+      string |
+      number |
+      str('true').as(:true) |
+      str('false').as(:false) |
+      str('nil').as(:nil)
+    }
+
+    rule(:key) {
+      spaces? >> (
+        str(':').absent? >> match('\s').absent? >> any
+      ).repeat.as(:key) >> str(':') >> spaces?
+    }
+
+    rule(:key_value) {
+      (
+        key >> value.as(:val)
+      ).as(:key_value) >> spaces?
+    }
+
+    rule(:named_args) {
+      spaces? >> (
+        key_value >> (comma >> key_value).repeat
+      ).as(:named_args) >>
+      spaces?
+    }
+
+    rule(:unquoted_string) {
+      (newline.absent? >> any).repeat.as(:string) #>> newline
+    }
+
+    rule(:positional_args) {
+      spaces? >> value.as(:val) >> (comma >> value.as(:val)).repeat >>
+      comma.maybe >> named_args.maybe
+    }
+
+    rule(:args) {
+      (positional_args | named_args | string | unquoted_string)
+    }
+
+    rule(:funcall) {
+      spaces? >> (newline.absent? >> match('[^ \(\)]')).repeat(1).as(:funcall)
+    }
+
+    rule(:parens_method) {
+      funcall >> lparen >>
+      args.as(:args) >>
+      rparen
+    }
+
+    rule(:seattle_method) {
+      funcall >> spaces >>
+      (args).as(:args)
+    }
+
+    rule(:no_args_method) {
+      spaces? >> ( lparen.absent? >> rparen.absent? >> spaces.absent? >> any).repeat(1)
+    }
+
+    rule(:method_call) {
+      (parens_method | seattle_method | no_args_method).as(:method_call)
+    }
+
+    # >>
+    # >-
+    # ->
+    # --
+    rule(:visability) {
+      (
+        match('>|-').maybe.as(:vis_command) >> match('>|-').maybe.as(:vis_result)
+      ).as(:visability)
+    }
+
+    # :::
+    rule(:start_command) {
+      match(/\A:/) >> str('::')
+    }
+
+    # :::>> $ cat foo.rb
+    rule(:command) {
+      (
+        start_command >>
+        visability.as(:cmd_visability) >> spaces? >>
+        method_call.as(:cmd_method_call) >> newline #>> match(/\z/)
+      ).as(:command)
+    }
+
+    # :::>> file.write hello.txt
+    # world
+    rule(:command_with_stdin) {
+      command >>
+        (
+          start_command.absent? >>
+          code_fence.absent? >>
+          any
+        ).repeat(1).as(:stdin) |
+        command
+    }
+
+
+    # :::>> file.write hello.txt
+    # world
+    # :::>> file.write foo.txt
+    # bar
+    rule(:multiple_commands) {
+      (command_with_stdin | command).repeat
+    }
+
+    rule(:code_fence) {
+      match(/\A`/) >> str("``")
+    }
+
+    rule(:fenced_commands) {
+      code_fence >>
+        match('\S').repeat >>
+        newline >>
+      multiple_commands >>
+      code_fence >> newline
+    }
+
+    rule(:raw_code) {
+      (start_command.absent? >> command.absent? >> any).repeat(1).as(:raw_code) >>
+      multiple_commands.maybe
+    }
+
+    rule(:code_block) {
+      raw_code | multiple_commands
+    }
+  end
+end
+
+
+module Rundoc
+  class PegTransformer < Parslet::Transform
+    rule(nill:   simple(:nu)) { nil }
+    rule(true:   simple(:tr)) { true }
+    rule(false:  simple(:fa)) { false }
+    rule(string: simple(:st)) { st.to_s }
+
+    rule(:number => simple(:nb)) {
+      nb.match(/[eE\.]/) ? Float(nb) : Integer(nb)
+    }
+
+    def self.convert_named_args(na)
+      (na.is_a?(Array) ? na : [ na ]).each_with_object({}) { |element, hash|
+        key = element[:key_value][:key].to_sym
+        val = element[:key_value][:val]
+        hash[key] = val
+      }
+    end
+
+    rule(:named_args => subtree(:na)) {
+      PegTransformer.convert_named_args(na)
+    }
+
+    rule(val: simple(:val)) {
+      val
+    }
+
+    # Handle the case where there is only one value
+    rule(val: simple(:val), named_args: subtree(:na)) {
+      [val, PegTransformer.convert_named_args(na)]
+    }
+
+    rule(method_call: subtree(:mc)) {
+      if mc.is_a?(::Parslet::Slice)
+        keyword = mc.to_sym
+        args = nil
+      else
+        keyword = mc[:funcall].to_sym
+        args    = mc[:args]
+      end
+
+      Rundoc.code_command_from_keyword(keyword, args)
+    }
+
+    class Visability
+      attr_reader :command, :result
+      alias :command? :command
+      alias :result? :result
+      def initialize(command:, result:)
+        @command = command
+        @result  = result
+      end
+    end
+
+    class TransformError < ::StandardError
+      attr_reader :line_and_column
+      def initialize(message: , line_and_column:)
+        @line_and_column = line_and_column || [1, 1]
+        super message
+      end
+    end
+
+    rule(:visability => {
+            vis_command: simple(:command),
+            vis_result:  simple(:result)
+        }) {
+      if result.nil? || command.nil?
+        line_and_column = command&.line_and_column
+        line_and_column ||= result&.line_and_column
+
+        message = +""
+        message << "You attempted to use a command that does not begin with two visibility indicators. Please replace: "
+        message << "`:::#{command}#{result}` with `:::#{command || '-'}#{result || '-'}`"
+        raise TransformError.new(message: message, line_and_column: line_and_column)
+      end
+      Visability.new(
+        command: command.to_s == '>'.freeze,
+        result:  result.to_s  == '>'.freeze
+      )
+    }
+
+    rule(
+      cmd_visability: simple(:cmd_vis),      # Visibility#new
+      cmd_method_call: simple(:code_command) # Rundoc::CodeCommand#new
+        ) {
+      code_command.render_command = cmd_vis.command?
+      code_command.render_result  = cmd_vis.result?
+      code_command
+    }
+
+    rule(command: simple(:code_command)) {
+      code_command
+    }
+
+    rule(command: simple(:code_command), stdin: simple(:str)) {
+      code_command << str
+      code_command
+    }
+
+    # The lines before a CodeCommand are rendered
+    # without running any code
+    rule(raw_code: simple(:raw_code)) {
+      CodeCommand::Raw.new(raw_code)
+    }
+
+    # Sometimes
+    rule(raw_code: sequence(:raw_code)) {
+      hidden = raw_code.nil? || raw_code.empty?
+      CodeCommand::Raw.new(raw_code, visible: !hidden)
+    }
+  end
+end