rundoc 0.0.2 → 1.1.2

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]
@@ -42,8 +43,9 @@ module Rundoc
       result = []
       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,7 +57,7 @@ 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 }
 
         tmp_result = []
         tmp_result << code_line   if code_command.render_command?
@@ -65,10 +67,17 @@ module Rundoc
         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
@@ -82,83 +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 /\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}"
+      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

@@ -10,10 +10,11 @@ module Rundoc
 
     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