motion-markdown-it 0.4.0.3.0

data/lib/motion-markdown-it/rules_block/state_block.rb

@@ -0,0 +1,184 @@
+# Parser state class
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class StateBlock
+
+      attr_accessor     :src, :md, :env, :tokens, :bMarks, :eMarks, :tShift
+      attr_accessor     :blkIndent, :line, :lineMax, :tight, :parentType, :ddIndent
+      attr_accessor     :level, :result
+      
+      #------------------------------------------------------------------------------
+      def initialize(src, md, env, tokens)
+        @src = src
+
+        # link to parser instance
+        @md  = md
+        @env = env
+
+        #--- Internal state variables
+
+        @tokens = tokens
+
+        @bMarks = []  # line begin offsets for fast jumps
+        @eMarks = []  # line end offsets for fast jumps
+        @tShift = []  # indent for each line
+
+        # block parser variables
+        @blkIndent  = 0       # required block content indent (for example, if we are in list)
+        @line       = 0       # line index in src
+        @lineMax    = 0       # lines count
+        @tight      = false   # loose/tight mode for lists
+        @parentType = 'root'  # if `list`, block parser stops on two newlines
+        @ddIndent   = -1      # indent of the current dd block (-1 if there isn't any)
+
+        @level = 0
+
+        # renderer
+        @result = ''
+
+        # Create caches
+        # Generate markers.
+        s            = @src
+        indent       = 0
+        indent_found = false
+
+        start = pos = indent = 0
+        len = s.length
+        start.upto(len - 1) do |pos|
+        # !!!!!!
+        # for (start = pos = indent = 0, len = s.length pos < len pos++) {
+          ch = s.charCodeAt(pos)
+
+          if !indent_found
+            if ch == 0x20  # space
+              indent += 1
+              next
+            else
+              indent_found = true
+            end
+          end
+
+          if ch == 0x0A || pos == (len - 1)
+            pos += 1 if ch != 0x0A
+            @bMarks.push(start)
+            @eMarks.push(pos)
+            @tShift.push(indent)
+
+            indent_found = false
+            indent       = 0
+            start        = pos + 1
+          end
+        end
+
+        # Push fake entry to simplify cache bounds checks
+        @bMarks.push(s.length)
+        @eMarks.push(s.length)
+        @tShift.push(0)
+
+        @lineMax = @bMarks.length - 1 # don't count last fake line
+      end
+
+      # Push new token to "stream".
+      #------------------------------------------------------------------------------
+      def push(type, tag, nesting)
+        token       = Token.new(type, tag, nesting)
+        token.block = true
+
+        @level -= 1 if nesting < 0
+        token.level = @level
+        @level += 1 if nesting > 0
+
+        @tokens.push(token)
+        return token
+      end
+
+      #------------------------------------------------------------------------------
+      def isEmpty(line)
+        return @bMarks[line] + @tShift[line] >= @eMarks[line]
+      end
+
+      #------------------------------------------------------------------------------
+      def skipEmptyLines(from)
+        while from < @lineMax
+          break if (@bMarks[from] + @tShift[from] < @eMarks[from])
+          from += 1
+        end
+        return from
+      end
+
+      # Skip spaces from given position.
+      #------------------------------------------------------------------------------
+      def skipSpaces(pos)
+        max = @src.length
+        while pos < max
+          break if @src.charCodeAt(pos) != 0x20 # space
+          pos += 1
+        end
+        return pos
+      end
+
+      # Skip char codes from given position
+      #------------------------------------------------------------------------------
+      def skipChars(pos, code)
+        max = @src.length
+        while pos < max
+          break if (@src.charCodeAt(pos) != code)
+          pos += 1
+        end
+        return pos
+      end
+
+      # Skip char codes reverse from given position - 1
+      #------------------------------------------------------------------------------
+      def skipCharsBack(pos, code, min)
+        return pos if pos <= min
+
+        while (pos > min)
+          return (pos + 1) if code != @src.charCodeAt(pos -= 1)
+        end
+        return pos
+      end
+
+      # cut lines range from source.
+      #------------------------------------------------------------------------------
+      def getLines(line_begin, line_end, indent, keepLastLF)
+        line = line_begin
+
+        return '' if line_begin >= line_end
+
+        # Opt: don't use push queue for single line
+        if (line + 1) == line_end
+          first = @bMarks[line] + [@tShift[line], indent].min
+          last = keepLastLF ? @bMarks[line_end] : @eMarks[line_end - 1]
+          return @src.slice(first...last)
+        end
+
+        queue = Array.new(line_end - line_begin)
+
+        i = 0
+        while line < line_end
+          shift = @tShift[line]
+          shift = indent if shift > indent
+          shift = 0 if shift < 0
+
+          first = @bMarks[line] + shift
+
+          if line + 1 < line_end || keepLastLF
+            # No need for bounds check because we have fake entry on tail.
+            last = @eMarks[line] + 1
+          else
+            last = @eMarks[line]
+          end
+
+          queue[i] = @src.slice(first...last)
+          line += 1
+          i    += 1
+        end
+
+        return queue.join('')
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_block/table.rb

@@ -0,0 +1,161 @@
+# GFM table, non-standard
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Table
+
+      #------------------------------------------------------------------------------
+      def self.getLine(state, line)
+        pos = state.bMarks[line] + state.blkIndent
+        max = state.eMarks[line]
+
+        return state.src[pos, max - pos]
+      end
+
+      #------------------------------------------------------------------------------
+      def self.escapedSplit(str)
+        result  = []
+        pos     = 0
+        max     = str.length
+        escapes = 0
+        lastPos = 0
+        ch      = str.charCodeAt(pos)
+
+        while (pos < max)
+          if (ch == 0x7c && (escapes % 2 == 0))     # '|'
+            result.push(str[lastPos...pos])
+            lastPos = pos + 1
+          elsif (ch == 0x5c)   # '\'
+            escapes += 1
+          else
+            escapes = 0
+          end
+
+          pos += 1
+          ch   = str.charCodeAt(pos)
+        end
+
+        result.push(str.slice_to_end(lastPos))
+
+        return result
+      end
+
+
+      #------------------------------------------------------------------------------
+      def self.table(state, startLine, endLine, silent)
+        # should have at least three lines
+        return false if (startLine + 2 > endLine)
+
+        nextLine = startLine + 1
+
+        return false if (state.tShift[nextLine] < state.blkIndent)
+
+        # first character of the second line should be '|' or '-'
+        pos = state.bMarks[nextLine] + state.tShift[nextLine]
+        return false if (pos >= state.eMarks[nextLine])
+
+        ch = state.src.charCodeAt(pos)
+        return false if (ch != 0x7C && ch != 0x2D && ch != 0x3A) # != '|' && '-' && ':'
+
+        lineText = getLine(state, startLine + 1)
+        return false if (/^[-:| ]+$/ =~ lineText).nil?
+
+        rows = lineText.split('|')
+        return false if (rows.length < 2)
+        aligns = []
+        (0...rows.length).each do |i|
+          t = rows[i].strip
+          if t.empty?
+            # allow empty columns before and after table, but not in between columns
+            # e.g. allow ` |---| `, disallow ` ---||--- `
+            if (i == 0 || i == rows.length - 1)
+              next
+            else
+              return false
+            end
+          end
+
+          return false if (/^:?-+:?$/ =~ t).nil?
+          if (t.charCodeAt(t.length - 1) == 0x3A)  # ':'
+            aligns.push(t.charCodeAt(0) == 0x3A ? 'center' : 'right')
+          elsif (t.charCodeAt(0) == 0x3A)
+            aligns.push('left')
+          else
+            aligns.push('')
+          end
+        end
+
+        lineText = getLine(state, startLine).strip
+        return false if !lineText.include?('|')
+        rows = self.escapedSplit(lineText.gsub(/^\||\|$/, ''))
+        return false if (aligns.length != rows.length)
+        return true  if silent
+
+        token     = state.push('table_open', 'table', 1)
+        token.map = tableLines = [ startLine, 0 ]
+
+        token     = state.push('thead_open', 'thead', 1)
+        token.map = [ startLine, startLine + 1 ]
+
+        token     = state.push('tr_open', 'tr', 1)
+        token.map = [ startLine, startLine + 1 ]
+
+        (0...rows.length).each do |i|
+          token          = state.push('th_open', 'th', 1)
+          token.map      = [ startLine, startLine + 1 ]
+          unless aligns[i].empty?
+            token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ]
+          end
+
+          token          = state.push('inline', '', 0)
+          token.content  = rows[i].strip
+          token.map      = [ startLine, startLine + 1 ]
+          token.children = []
+
+          token          = state.push('th_close', 'th', -1)
+        end
+
+        token     = state.push('tr_close', 'tr', -1)
+        token     = state.push('thead_close', 'thead', -1)
+
+        token     = state.push('tbody_open', 'tbody', 1)
+        token.map = tbodyLines = [ startLine + 2, 0 ]
+
+        nextLine = startLine + 2
+        while nextLine < endLine
+          break if (state.tShift[nextLine] < state.blkIndent)
+
+          lineText = getLine(state, nextLine).strip
+          break if !lineText.include?('|')
+          rows = self.escapedSplit(lineText.gsub(/^\||\|$/, ''))
+
+          # set number of columns to number of columns in header row
+          rows_length = aligns.length
+
+          token = state.push('tr_open', 'tr', 1)
+          (0...rows_length).each do |i|
+            token          = state.push('td_open', 'td', 1)
+            unless aligns[i].empty?
+              token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ]
+            end
+
+            token          = state.push('inline', '', 0)
+            token.content  = rows[i] ? rows[i].strip : ''
+            token.children = []
+
+            token          = state.push('td_close', 'td', -1)
+          end
+          token = state.push('tr_close', 'tr', -1)
+          nextLine += 1
+        end
+        token = state.push('tbody_close', 'tbody', -1)
+        token = state.push('table_close', 'table', -1)
+
+        tableLines[1] = tbodyLines[1] = nextLine
+        state.line = nextLine
+        return true
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_core/block.rb

@@ -0,0 +1,20 @@
+module MarkdownIt
+  module RulesCore
+    class Block
+
+      #------------------------------------------------------------------------------
+      def self.block(state)
+        if state.inlineMode
+          token          = Token.new('inline', '', 0)
+          token.content  = state.src
+          token.map      = [ 0, 1 ]
+          token.children = []
+          state.tokens.push(token)
+        else
+          state.md.block.parse(state.src, state.md, state.env, state.tokens)
+        end
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_core/inline.rb

@@ -0,0 +1,20 @@
+module MarkdownIt
+  module RulesCore
+    class Inline
+
+      #------------------------------------------------------------------------------
+      def self.inline(state)
+        tokens = state.tokens
+
+        # Parse inlines
+        0.upto(tokens.length - 1) do |i|
+          tok = tokens[i]
+          if tok.type == 'inline'
+            state.md.inline.parse(tok.content, state.md, state.env, tok.children)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_core/linkify.rb

@@ -0,0 +1,138 @@
+# Replace link-like texts with link nodes.
+#
+# Currently restricted by `md.validateLink()` to http/https/ftp
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesCore
+    class Linkify
+
+      #------------------------------------------------------------------------------
+      def self.isLinkOpen(str)
+        return !(/^<a[>\s]/i =~ str).nil?
+      end
+      def self.isLinkClose(str)
+        return !(/^<\/a\s*>/i =~ str).nil?
+      end
+
+      #------------------------------------------------------------------------------
+      def self.linkify(state)
+        blockTokens = state.tokens
+
+          return if (!state.md.options[:linkify])
+
+          (0...blockTokens.length).each do |j|
+            if (blockTokens[j].type != 'inline' || !state.md.linkify.pretest(blockTokens[j].content))
+              next
+            end
+
+            tokens = blockTokens[j].children
+
+            htmlLinkLevel = 0
+
+            # We scan from the end, to keep position when new tags added.
+            # Use reversed logic in links start/end match
+            i = tokens.length - 1
+            while i >= 0
+              currentToken = tokens[i]
+
+              # Skip content of markdown links
+              if (currentToken.type == 'link_close')
+                i -= 1
+                while (tokens[i].level != currentToken.level && tokens[i].type != 'link_open')
+                  i -= 1
+                end
+                next
+              end
+
+              # Skip content of html tag links
+              if (currentToken.type == 'html_inline')
+                if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0)
+                  htmlLinkLevel -= 1
+                end
+                if (isLinkClose(currentToken.content))
+                  htmlLinkLevel -= 1
+                end
+              end
+              next if (htmlLinkLevel > 0)
+
+              if (currentToken.type == 'text' && state.md.linkify =~ currentToken.content)
+
+                text = currentToken.content
+                links = state.md.linkify.match(text)
+
+                # Now split string to nodes
+                nodes   = []
+                level   = currentToken.level
+                lastPos = 0
+                
+                (0...links.length).each do |ln|
+                  url = links[ln].url
+                  fullUrl = state.md.normalizeLink.call(url)
+                  next if (!state.md.validateLink.call(fullUrl))
+
+                  urlText = links[ln].text
+
+                  # Linkifier might send raw hostnames like "example.com", where url
+                  # starts with domain name. So we prepend http:// in those cases,
+                  # and remove it afterwards.
+                  #
+
+# TODO work on this when clearer
+puts "Linkify requires work"
+                  # if (!links[ln].schema)
+                  #   urlText = state.md.normalizeLinkText.call('http://' + urlText).replace(/^http:\/\//, '')
+                  # elsif (links[ln].schema == 'mailto:' && !Regexp.new('^mailto:/i') =~ urlText)
+                  #   urlText = state.md.normalizeLinkText.call('mailto:' + urlText).replace(/^mailto:/, '');
+                  # } else {
+                  #   urlText = state.md.normalizeLinkText.call(urlText);
+                  # }
+
+                  pos = links[ln].index
+
+                  if (pos > lastPos)
+                    token         = Token.new('text', '', 0)
+                    token.content = text.slice(lastPos...pos)
+                    token.level   = level
+                    nodes.push(token)
+                  end
+
+                  token         = Token.new('link_open', 'a', 1)
+                  token.attrs   = [ [ 'href', fullUrl ] ]
+                  token.level   = level
+                  level        += 1
+                  token.markup  = 'linkify'
+                  token.info    = 'auto'
+                  nodes.push(token)
+
+                  token         = Token.new('text', '', 0)
+                  token.content = urlText
+                  token.level   = level
+                  nodes.push(token)
+
+                  token         = Token.new('link_close', 'a', -1)
+                  level        -= 1
+                  token.level   = level
+                  token.markup  = 'linkify'
+                  token.info    = 'auto'
+                  nodes.push(token)
+
+                  lastPos = links[ln].lastIndex
+                end
+                if (lastPos < text.length)
+                  token         = Token.new('text', '', 0)
+                  token.content = text.slice_to_end(lastPos)
+                  token.level   = level
+                  nodes.push(token)
+                end
+
+                # replace current node
+                blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)
+              end
+              i -= 1
+            end
+          end
+      end
+
+    end
+  end
+end