markascend 0.1

data/lib/markascend/builtin_macros.rb

@@ -0,0 +1,154 @@
+module Markascend
+  class Macro
+    %w[del underline sub sup].each do |m|
+      eval <<-RUBY
+        def parse_#{m}
+          "<#{m}>\#{::Markascend.escape_html content}</#{m}>"
+        end
+      RUBY
+    end
+
+    def parse_img
+      s = ::StringScanner.new content
+      unless src = s.scan(/(\\\ |\S)+/)
+        env.warn "require src for \\img"
+        return
+      end
+      alt = Macro.scan_attr s, 'alt'
+      s.skip /\s+/
+      href = Macro.scan_attr s, 'href'
+      s.skip /\s+/
+      if alt2 = Macro.scan_attr(s, 'alt')
+        alt = alt2
+      end
+      unless s.eos?
+        env.warn "parse error for content of \\img"
+        return
+      end
+
+      alt = ::Markascend.escape_attr alt
+      if env.inline_img
+        begin
+          if env.pwd
+            Dir.chdir env.pwd do
+              data = open src, 'rb', &:read
+            end
+          else
+            data = open src, 'rb', &:read
+          end
+          mime = ::Markascend.mime data
+          src = "data:#{mime};base64,#{::Base64.strict_encode64 data}"
+        rescue
+          env.warn $!.message
+        end
+      end
+
+      img = %Q|<img src="#{src}" alt="#{alt}"/>|
+      if href
+        href = ::Markascend.escape_attr href
+        %Q|<a href="#{href}">#{img}</a>|
+      else
+        img
+      end
+    end
+
+    def parse_html
+      # TODO sanitize in strict mode
+      content
+    end
+
+    def parse_slim
+      ::Slim::Template.new(){content}.render env.scope
+    end
+
+    def parse_csv
+      Macro.generate_csv content, false
+    end
+
+    def parse_headless_csv
+      Macro.generate_csv content, true
+    end
+
+    def parse_latex
+      %Q|<code class="latex">#{content}</code>|
+    end
+
+    def parse_options
+      yaml = ::YAML.load(content) rescue nil
+      if yaml.is_a?(Hash)
+        env.options.merge! yaml
+      else
+        env.warn '\options content should be a yaml hash'
+      end
+      ''
+    end
+
+    def parse_hi
+      # TODO validate syntax name
+      env.hi = content == 'none' ? nil : content
+      ''
+    end
+
+    def parse_dot
+      err, out, code = nil
+      ::Open3.popen3 'dot', '-Tpng' do |i, o, e, t|
+        i.puts content
+        i.close
+        err = e.read
+        out = o.read
+        code = t.value.to_i
+        e.close
+        o.close
+      end
+      if code != 0
+        env.warn err
+        return
+      end
+
+      data = ::Base64.strict_encode64 out
+      %Q|<img src="data:image/png;base64,#{data}" alt="#{Markascend.escape_attr content}"/>|
+    end
+
+    def Macro.generate_csv content, headless
+      rows = ::CSV.parse(content)
+      return if rows.empty?
+
+      table = "<table>"
+      unless headless
+        table << "<thead>"
+        head = rows.shift
+        head.map!{|e| "<th>#{::Markascend.escape_html e}</th>" }
+        table << "<tr>#{head.join}</tr>"
+        table << "</thead>"
+      end
+
+      table << "<tbody>"
+      rows.each do |row|
+        row.map!{|e| "<td>#{::Markascend.escape_html e}</td>" }
+        table << "<tr>#{row.join}</tr>"
+      end
+      table << "</tbody></table>"
+    end
+
+    def Macro.scan_attr strscan, attr_name
+      pos = strscan.pos
+      strscan.skip /\s+/
+      unless strscan.peek(attr_name.size) == attr_name
+        strscan.pos = pos
+        return
+      end
+      strscan.pos += attr_name.size
+
+      if strscan.scan(/\s*=\s*/)
+        # http://www.w3.org/TR/html5/syntax.html#attributes-0
+        if v = strscan.scan(/(["']).*?\1/)
+          v[1...-1]
+        else
+          strscan.scan(/\w+/)
+        end
+      else
+        attr_name
+      end
+    end
+  end
+end

data/lib/markascend/env.rb

@@ -0,0 +1,68 @@
+module Markascend
+  class Env
+    attr_reader :autolink, :inline_img, :sandbox, :toc, :pwd
+    attr_reader :macros, :line_units, :scope, :options, :footnotes, :srcs, :warnings
+    attr_accessor :hi
+
+    def initialize(autolink: %w[http https ftp mailto], inline_img: false, sandbox: false, toc: false, **opts)
+      @autolink = autolink
+      @inline_img = inline_img
+      @sandbox = sandbox
+      @toc = toc ? {} : false # {id => [x, header_content]}
+
+      if opts[:path]
+        pwd = File.dirname opts[:path]
+        if File.directory?(pwd)
+          @pwd = pwd
+        end
+      end
+
+      if opts[:macros]
+        @macros = {}
+        opts[:macros].each do |m|
+          meth = "parse_#{m}"
+          if Macro.respond_to?(meth)
+            @macros[m] = meth
+          else
+            raise ArgumentError, "macro processor #{meth} not defined"
+          end
+        end
+      elsif @sandbox
+        @macros = SANDBOX_MACROS
+      else
+        @macros = DEFAULT_MACROS
+      end
+
+      if opts[:line_units]
+        @line_units = opts[:line_units].map do |m|
+          meth = "parse_#{m}"
+          if LineUnit.respond_to?(meth)
+            meth
+          else
+            raise ArgumentError, "line-unit parser #{meth} not defined"
+          end
+        end
+      else
+        @line_units = DEFAULT_LINE_UNITS
+      end
+
+      @scope = opts[:scope] || Object.new.send(:binding)
+      @options = {}   # for \options macro
+      @footnotes = {} # {abbrev => details}. for [.] and [:] elements
+      @srcs = []      # recursive parser stack, everyone has the contiguous right one scanned
+      @warnings = {}  # {line => message}
+      @hi = nil       # current syntax hiliter
+    end
+
+    def warn msg
+      if @srcs.size
+        current_src = @srcs.last
+        line = @srcs.first.string.count("\n") - current_src.string[(current_src.pos)..-1].count("\n")
+        @warnings[line] = msg
+      else
+        # warnings without source is set to line 0
+        @warnings[0] = msg
+      end
+    end
+  end
+end

data/lib/markascend/line_unit.rb

@@ -0,0 +1,226 @@
+module Markascend
+  LineUnit = ::Struct.new :env, :line, :block
+  # process a line with (maybe) a followed up indented block
+  class LineUnit
+    def parse out=nil
+      @out = []
+      @src = ::StringScanner.new line
+      parsers = env.line_units
+      while parsers.any?{|p| send p}
+      end
+
+      if out
+        @out.each do |token|
+          out << token
+        end
+      else
+        @out.join
+      end
+    end
+
+    # the same as markdown
+    def parse_inline_code
+      if s = @src.scan(/
+          (`{1,})(\ ?)
+          .*?
+          \2\1
+        /x)
+        s =~ /^
+          (`{1,})(\ ?)
+          (.*?)
+          \2\1
+        $/x
+        @out << (::Markascend.hilite $3, env.hi, true)
+        true
+      end
+    end
+
+    # no escape chars, but \\ and \$ are treated as atomic parsing units
+    def parse_math
+      if (s = @src.scan /\$(?:\\[\\\$]|[^\$])*\$/)
+        @out << '<code class="math">'
+        @out << (::Markascend.escape_html s[1...-1])
+        @out << '</code>'
+        true
+      end
+    end
+
+    def parse_auto_link
+      # TODO make protocol configurable
+      if (s = @src.scan /(https|http|ftp|mailto)\:\/\/\S+/)
+        s.gsub! /"/, '\\"'
+        @out << '<a href="#{s}">'
+        @out << (::Markascend.escape_html s)
+        @out << '</a>'
+        true
+      end
+    end
+
+    def parse_macro
+      start = @src.pos
+      return unless macro = @src.scan(/\\(?!\d)\w+/)
+      macro = macro[1..-1]
+      if block = scan_lexical_parens
+        inline_content = @src.string[start..(@src.pos)]
+      elsif block = scan_recursive_braces
+        inline_content = @src.string[start..(@src.pos)]
+      else
+        block = self.block
+      end
+      @out << ::Markascend::Macro.new(env, block, inline_content).parse(macro)
+      true
+    end
+
+    def parse_link
+      pos = @src.pos
+      return unless @src.scan(/\[/)
+
+      footnote = @src.scan(/[\.\:]/)
+      content = ''
+      loop do
+        if res = @src.scan(/\]/)
+          break
+        elsif res = parse_char(false)
+          content << res
+        else
+          # failed
+          @src.pos = pos
+          return
+        end
+      end
+
+      if footnote and env.sandbox
+        scan_lexical_parens || scan_recursive_braces
+        @out << ::Markascend.escape_html(@src.string[pos..(@src.pos)])
+        return true
+      end
+
+      case footnote
+      when '.'
+        unless explain = scan_lexical_parens || scan_recursive_braces
+          @src.pos = pos
+          return
+        end
+
+        footnotes = env.footnotes
+        if content =~ /\A\s*\z/
+          content = footnotes.size + 1
+        end
+        raise "Already defined footnote: #{content}" if footnotes.has_key?(content)
+        footnotes[content] = explain
+        # TODO id prefix configurable
+        @out << %Q|<a href="#footnote-#{footnotes.size}">#{content}</a>|
+        true
+      when ':'
+        footnotes = env.footnotes
+        if content =~ /\A\s*(\d+)\s*\z/
+          @out << [:footnote_id_ref, $1.to_i]
+        else
+          content.strip!
+          @out << [:footnote_acronym_ref, content]
+        end
+        true
+      else
+        if addr = scan_lexical_parens || scan_recursive_braces
+          # TODO smarter addr to recognize things like a.b.com
+          addr = ::Markascend.escape_attr addr
+          @out << %Q|<a href="#{addr}">#{content}</a>|
+          true
+        else
+          @src.pos = pos
+          nil
+        end
+      end
+    end
+
+    def parse_bold_italic emit=true
+      pos = @src.pos
+      if s = @src.scan(/\*\*/)
+        term = /\*\*/
+        out = ['<b>']
+        out_end = '</b>'
+      elsif s = @src.scan(/\*/)
+        term = /\*/
+        out = ['<i>']
+        out_end = '</i>'
+      else
+        return
+      end
+
+      loop do
+        if res = @src.scan(/\\[\\\*]/)
+          out << res[1]
+        elsif @src.scan(term)
+          out << out_end
+          break
+        elsif res = parse_bold_italic(false)
+          out << res
+        elsif res = parse_char(false)
+          out << res
+        else
+          # failed
+          @src.pos = pos
+          return
+        end
+      end
+
+      if emit
+        @out << out.join
+        true
+      else
+        out.join
+      end
+    end
+
+    def parse_char emit=true
+      # entity list generated by:
+      # ruby -rregexp_optimized_union -e'puts Regexp.optimized_union($stdin.read.scan(/(?<=ENTITY )\w+/)).source' < tools/html4_entities.dtd
+      # dtd from http://www.w3.org/TR/html4/sgml/entities.html
+      if c = @src.scan(/
+          &(?:
+            n(?:bsp|ot|tilde)|i(?:excl|quest|grave|acute|circ|uml)|c(?:e(?:nt|dil)|urren|opy|cedil)|p(?:ound|lusmn|ara)|y(?:en|acute|uml)|brvbar|s(?:ect|hy|up[123]|zlig)|u(?:ml|grave|acute|circ|uml)|o(?:rd[fm]|grave|acute|circ|tilde|uml|slash)|laquo|r(?:eg|aquo)|m(?:acr|i(?:cro|ddot))|d(?:eg|ivide)|a(?:c(?:ute|irc)|grave|acute|tilde|uml|ring|elig)|frac(?:1[24]|34)|A(?:grave|acute|circ|tilde|uml|ring|Elig)|Ccedil|E(?:grave|acute|circ|uml|TH)|I(?:grave|acute|circ|uml)|Ntilde|O(?:grave|acute|circ|tilde|uml|slash)|t(?:imes|horn)|U(?:grave|acute|circ|uml)|Yacute|THORN|e(?:grave|acute|circ|uml|th)
+            |\#\d{4}
+            |\#x\h{4}
+          );
+        /x)
+      elsif c = @src.scan(/\\\W/)
+        c = ::Markascend.escape_html c[1]
+      elsif c = @src.scan(/\n/)
+        c = :'<br>'
+      elsif c = @src.scan(/./)
+        c = ::Markascend.escape_html c
+      else
+        return
+      end
+
+      if emit
+        @out << c
+        true
+      else
+        c
+      end
+    end
+
+    # {...}
+    def scan_recursive_braces
+      if s = @src.scan(/
+          (?<braces> \{
+            ([^\{]+ | \g<braces>)*  # recursive rule
+          \})
+        /x)
+        s[1...-1]
+      end
+    end
+
+    # (...)
+    def scan_lexical_parens
+      if s = @src.scan(/
+          \(
+            (?: \\ [\\\)] | [^\)] )+  # lexical rule
+          \)
+        /x)
+        s[1...-1].gsub(/\\[\)\\]/){|x| x[1]}
+      end
+    end
+  end
+end

data/lib/markascend/macro.rb

@@ -0,0 +1,13 @@
+module Markascend
+  # inline contains the src for fallback
+  Macro = ::Struct.new :env, :content, :inline
+  class Macro
+    def parse name
+      self.content ||= ''
+      if meth = env.macros[name]
+        res = send meth
+      end
+      res or (inline ? ::Markascend.escape_html(inline) : "\\#{name}")
+    end
+  end
+end