rundoc 0.0.1 → 1.1.1

data/lib/rundoc/code_command/website/screenshot.rb

@@ -0,0 +1,28 @@
+class Rundoc::CodeCommand::Website
+  class Screenshot < Rundoc::CodeCommand
+    def initialize(name: , upload: false)
+      @driver = Rundoc::CodeCommand::Website::Driver.find(name)
+      @upload = upload
+    end
+
+    def to_md(env = {})
+      ""
+    end
+
+    def call(env = {})
+      puts "Taking screenshot: #{@driver.current_url}"
+      filename = @driver.screenshot(upload: @upload)
+      env[:replace] = "![Screenshot of #{@driver.current_url}](#{filename})"
+      ""
+    end
+
+    # def hidden?
+    #   true
+    # end
+
+    # def not_hidden?
+    #   !hidden?
+    # end
+  end
+end
+Rundoc.register_code_command(:"website.screenshot", Rundoc::CodeCommand::Website::Screenshot)

data/lib/rundoc/code_command/website/visit.rb

@@ -0,0 +1,47 @@
+class Rundoc::CodeCommand::Website
+  class Visit < Rundoc::CodeCommand
+    def initialize(name: , url: nil, scroll: nil, height: 720, width: 1024, visible: false)
+      @name = name
+      @url  = url
+      @scroll = scroll
+      @driver = Driver.new(
+        name: name,
+        url: url,
+        height: height,
+        width: width,
+        visible: visible
+      )
+      Driver.add(@name, @driver)
+    end
+
+    def to_md(env = {})
+      ""
+    end
+
+    def call(env = {})
+      message = String.new("Visting: #{@url}")
+      message << "and executing:\n#{contents}" unless contents.nil? || contents.empty?
+
+      puts message
+
+      @driver.visit(@url) if @url
+      @driver.scroll(@scroll) if @scroll
+
+
+      return "" if contents.nil? || contents.empty?
+      @driver.safe_eval(contents)
+
+      return ""
+    end
+
+    def hidden?
+      true
+    end
+
+    def not_hidden?
+      !hidden?
+    end
+  end
+end
+
+Rundoc.register_code_command(:"website.visit", Rundoc::CodeCommand::Website::Visit)

data/lib/rundoc/code_command/write.rb

@@ -1,6 +1,23 @@
 module Rundoc
   class CodeCommand
+    module FileUtil
+      def filename
+        files = Dir.glob(@filename)
+        if files.length > 1
+          raise "Filename glob #{@filename.inspect} matched more than one file. Be more specific to only match one file. Matches:\n" + files.join("  \n")
+        end
+        files.first || @filename
+      end
+
+      def mkdir_p
+        dir = File.expand_path("../", filename)
+        FileUtils.mkdir_p(dir)
+      end
+    end
+
     class Write < Rundoc::CodeCommand
+      include FileUtil
+
       def initialize(filename)
         @filename = filename
       end
@@ -8,16 +25,14 @@ module Rundoc
       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}"
+        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|
+        puts "Writing to: '#{filename}'"
+        mkdir_p
+        File.open(filename, "w") do |f|
           f.write(contents)
         end
         contents
@@ -31,4 +46,4 @@ 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'
+require 'rundoc/code_command/file_command/remove'

data/lib/rundoc/code_section.rb

@@ -32,6 +32,7 @@ module Rundoc
       @commands = []
       @stack    = []
       @keyword  = options[:keyword] or raise "keyword is required"
+      @document_path = options[:document_path]
       @fence    = match[:fence]
       @lang     = match[:lang]
       @code     = match[:contents]
@@ -40,10 +41,11 @@ module Rundoc
 
     def render
       result = []
-      env = {}
+      env    = {}
       env[:commands] = []
-      env[:before]   = "#{fence}#{lang}"
-      env[:after]    = "#{fence}"
+      env[:before]   = String.new("#{fence}#{lang}")
+      env[:after]    = String.new(fence)
+      env[:document_path] = @document_path
 
       @stack.each do |s|
         unless s.respond_to?(:call)
@@ -55,19 +57,27 @@ module Rundoc
         code_output  = code_command.call(env)  || ""
         code_line    = code_command.to_md(env) || ""
 
-        env[:commands] << { object: code_command, output: code_output, command: code_line}
+        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
+        tmp_result = []
+        tmp_result << code_line   if code_command.render_command?
+        tmp_result << code_output if code_command.render_result?
+
+        result << tmp_result unless code_command.hidden?
+        result
       end
 
+      return env[:replace] if env[:replace]
+
       return "" if hidden?
 
       array = [env[:before], result, env[:after]]
-      return array.flatten.compact.map(&:rstrip).reject(&:empty?).join("\n") << "\n"
+      array.flatten!
+      array.compact!
+      array.map!(&:rstrip)
+      array.reject!(&:empty?)
+
+      return array.join("\n") << "\n"
     end
 
     # all of the commands are hidden
@@ -81,65 +91,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
-      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
+      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
-
-      @stack   << "\n" if commands.last.is_a?(Rundoc::CodeCommand)
-      @stack   << code_command
-      commands << code_command
-      code_command
+    rescue ::Parslet::ParseFailed => e
+      raise "Could not compile code:\n#{@code}\nReason: #{e.message}"
     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/parser.rb

@@ -5,15 +5,16 @@ module Rundoc
     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>.*)$/
+                             /^#{keyword}(?<tag>(\s|=|-|>)?(=|-|>)?)\s*(?<command>(\S)+)\s+(?<statement>.*)$/
                             }
 
     attr_reader :contents, :keyword, :stack
 
-    def initialize(contents, options = {})
+    def initialize(contents, keyword: DEFAULT_KEYWORD, document_path: nil)
+      @document_path = document_path
       @contents = contents
       @original = contents.dup
-      @keyword  = options[:keyword] || DEFAULT_KEYWORD
+      @keyword  = keyword
       @stack    = []
       partition
     end
@@ -42,7 +43,7 @@ module Rundoc
         @stack << head                  unless head.empty?
         unless code.empty?
           match = code.match(CODEBLOCK_REGEX)
-          @stack << CodeSection.new(match, keyword: keyword)
+          @stack << CodeSection.new(match, keyword: keyword, document_path: @document_path)
         end
         @contents = tail
       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.maybe #>> 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