motion-markdown-it 0.4.0.3.0

data/lib/motion-markdown-it/rules_inline/newline.rb

@@ -0,0 +1,47 @@
+# Proceess '\n'
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesInline
+    class Newline
+
+      #------------------------------------------------------------------------------
+      def self.newline(state, silent)
+        pos = state.pos
+        return false if state.src.charCodeAt(pos) != 0x0A  # \n
+
+        pmax  = state.pending.length - 1
+        max   = state.posMax
+
+        # '  \n' -> hardbreak
+        # Lookup in pending chars is bad practice! Don't copy to other rules!
+        # Pending string is stored in concat mode, indexed lookups will cause
+        # convertion to flat mode.
+        if !silent
+          if pmax >= 0 && state.pending.charCodeAt(pmax) == 0x20
+            if pmax >= 1 && state.pending.charCodeAt(pmax - 1) == 0x20
+              state.pending = state.pending.sub(/ +$/, '')
+              state.push('hardbreak', 'br', 0)
+            else
+              state.pending = state.pending.slice(0...-1)
+              state.push('softbreak', 'br', 0)
+            end
+
+          else
+            state.push('softbreak', 'br', 0)
+          end
+        end
+
+        pos += 1
+
+        # skip heading spaces for next line
+        while pos < max && state.src.charCodeAt(pos) == 0x20
+          pos += 1
+        end
+
+        state.pos = pos
+        return true
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_inline/state_inline.rb

@@ -0,0 +1,57 @@
+# Inline parser state
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesInline
+    class StateInline
+
+      attr_accessor   :src, :env, :md, :tokens, :pos, :posMax, :level
+      attr_accessor   :pending, :pendingLevel, :cache
+
+      #------------------------------------------------------------------------------
+      def initialize(src, md, env, outTokens)
+        @src          = src
+        @env          = env
+        @md           = md
+        @tokens       = outTokens
+
+        @pos          = 0
+        @posMax       = @src.length
+        @level        = 0
+        @pending      = ''
+        @pendingLevel = 0
+
+        @cache        = {}      # Stores { start: end } pairs. Useful for backtrack
+                                # optimization of pairs parse (emphasis, strikes).
+      end
+
+
+      # Flush pending text
+      #------------------------------------------------------------------------------
+      def pushPending
+        token         = Token.new('text', '', 0)
+        token.content = @pending
+        token.level   = @pendingLevel
+        @tokens.push(token)
+        @pending      = ''
+        return token
+      end
+
+      # Push new token to "stream".
+      # If pending text exists - flush it as text token
+      #------------------------------------------------------------------------------
+      def push(type, tag, nesting)
+        pushPending unless @pending.empty?
+
+        token       = Token.new(type, tag, nesting);
+        @level     -= 1 if nesting < 0
+        token.level = @level
+        @level     += 1 if nesting > 0
+
+        @pendingLevel = @level
+        @tokens.push(token)
+        return token
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_inline/strikethrough.rb

@@ -0,0 +1,130 @@
+# ~~strike through~~
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesInline
+    class Strikethrough
+      extend Common::Utils
+      
+      # parse sequence of markers,
+      # "start" should point at a valid marker
+      def self.scanDelims(state, start)
+        pos       = start
+        can_open  = true
+        can_close = true
+        max       = state.posMax
+        marker    = state.src.charCodeAt(start)
+
+        # treat beginning of the line as a whitespace
+        lastChar = start > 0 ? state.src.charCodeAt(start - 1) : 0x20
+
+        while (pos < max && state.src.charCodeAt(pos) == marker)
+          pos += 1
+        end
+
+        if (pos >= max)
+          can_open = false
+        end
+
+        count = pos - start
+
+        # treat end of the line as a whitespace
+        nextChar = pos < max ? state.src.charCodeAt(pos) : 0x20
+
+        isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(lastChar.chr)
+        isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr)
+
+        isLastWhiteSpace = isWhiteSpace(lastChar)
+        isNextWhiteSpace = isWhiteSpace(nextChar)
+
+        if (isNextWhiteSpace)
+          can_open = false
+        elsif (isNextPunctChar)
+          if (!(isLastWhiteSpace || isLastPunctChar))
+            can_open = false
+          end
+        end
+
+        if (isLastWhiteSpace)
+          can_close = false
+        elsif (isLastPunctChar)
+          if (!(isNextWhiteSpace || isNextPunctChar))
+            can_close = false
+          end
+        end
+
+        return { can_open: can_open, can_close: can_close, delims: count }
+      end
+
+      #------------------------------------------------------------------------------
+      def self.strikethrough(state, silent)
+        max    = state.posMax
+        start  = state.pos
+        marker = state.src.charCodeAt(start)
+
+        return false if (marker != 0x7E) # ~
+        return false if (silent)  # don't run any pairs in validation mode
+
+        res        = scanDelims(state, start)
+        startCount = res[:delims]
+        if (!res[:can_open])
+          state.pos += startCount
+          # Earlier we checked !silent, but this implementation does not need it
+          state.pending += state.src.slice(start...state.pos)
+          return true
+        end
+
+        stack = (startCount / 2).floor
+        return false if (stack <= 0)
+        state.pos = start + startCount
+
+        while (state.pos < max)
+          if (state.src.charCodeAt(state.pos) == marker)
+            res      = scanDelims(state, state.pos)
+            count    = res[:delims]
+            tagCount = (count / 2).floor
+            if (res[:can_close])
+              if (tagCount >= stack)
+                state.pos += count - 2
+                found = true
+                break
+              end
+              stack     -= tagCount
+              state.pos += count
+              next
+            end
+
+            stack += tagCount if (res[:can_open])
+            state.pos += count
+            next
+          end
+
+          state.md.inline.skipToken(state)
+        end
+
+        if (!found)
+          # parser failed to find ending tag, so it's not valid emphasis
+          state.pos = start
+          return false
+        end
+
+        # found!
+        state.posMax = state.pos
+        state.pos    = start + 2
+
+        # Earlier we checked !silent, but this implementation does not need it
+        token        = state.push('s_open', 's', 1)
+        token.markup = '~~'
+
+        state.md.inline.tokenize(state)
+
+        token        = state.push('s_close', 's', -1)
+        token.markup = '~~'
+
+        state.pos    = state.posMax + 2
+        state.posMax = max
+        return true
+      end
+
+    end
+  end
+end

data/lib/motion-markdown-it/rules_inline/text.rb

@@ -0,0 +1,94 @@
+# Skip text characters for text token, place those to pending buffer
+# and increment current pos
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesInline
+    class Text
+
+      # Rule to skip pure text
+      # '{}$%@~+=:' reserved for extentions
+
+      # !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
+
+      # !!!! Don't confuse with "Markdown ASCII Punctuation" chars
+      # http://spec.commonmark.org/0.15/#ascii-punctuation-character
+      #------------------------------------------------------------------------------
+      def self.isTerminatorChar(ch)
+        case ch
+        when 0x0A,    # \n
+             0x21,    # !
+             0x23,    # #
+             0x24,    # $
+             0x25,    # %
+             0x26,    # &
+             0x2A,    # *
+             0x2B,    # +
+             0x2D,    # -
+             0x3A,    # :
+             0x3C,    # <
+             0x3D,    # =
+             0x3E,    # >
+             0x40,    # @
+             0x5B,    # [
+             0x5C,    # \
+             0x5D,    # ]
+             0x5E,    # ^
+             0x5F,    # _
+             0x60,    # `
+             0x7B,    # {
+             0x7D,    # }
+             0x7E     # ~
+          return true
+        else
+          return false
+        end
+      end
+
+      #------------------------------------------------------------------------------
+      def self.text(state, silent)
+        pos = state.pos
+
+        while pos < state.posMax && !self.isTerminatorChar(state.src.charCodeAt(pos))
+          pos += 1
+        end
+
+        return false if pos == state.pos
+
+        state.pending += state.src.slice(state.pos...pos) if !silent
+        state.pos      = pos
+        return true
+      end
+
+      # // Alternative implementation, for memory.
+      # //
+      # // It costs 10% of performance, but allows extend terminators list, if place it
+      # // to `ParcerInline` property. Probably, will switch to it sometime, such
+      # // flexibility required.
+      #
+      # /*
+      # var TERMINATOR_RE = /[\n!#$%&*+\-:<=>@[\\\]^_`{}~]/;
+      #
+      # module.exports = function text(state, silent) {
+      #   var pos = state.pos,
+      #       idx = state.src.slice(pos).search(TERMINATOR_RE);
+      #
+      #   // first char is terminator -> empty text
+      #   if (idx === 0) { return false; }
+      #
+      #   // no terminator -> text till end of string
+      #   if (idx < 0) {
+      #     if (!silent) { state.pending += state.src.slice(pos); }
+      #     state.pos = state.src.length;
+      #     return true;
+      #   }
+      #
+      #   if (!silent) { state.pending += state.src.slice(pos, pos + idx); }
+      #
+      #   state.pos += idx;
+      #
+      #   return true;
+      # };*/
+
+    end
+  end
+end

data/lib/motion-markdown-it/token.rb

@@ -0,0 +1,134 @@
+# Token class
+#------------------------------------------------------------------------------
+module MarkdownIt
+  class Token
+
+    attr_accessor   :type, :tag, :attrs, :map, :nesting, :level, :children
+    attr_accessor   :content, :markup, :info, :meta, :block, :hidden
+
+    # new Token(type, tag, nesting)
+    #
+    # Create new token and fill passed properties.
+    #------------------------------------------------------------------------------
+    def initialize(type, tag, nesting)
+      #  * Token#type -> String
+      #  *
+      #  * Type of the token (string, e.g. "paragraph_open")
+      @type     = type
+
+       # * Token#tag -> String
+       # *
+       # * html tag name, e.g. "p"
+      @tag      = tag
+
+       # * Token#attrs -> Array
+       # *
+       # * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
+      @attrs    = nil
+
+       # * Token#map -> Array
+       # *
+       # * Source map info. Format: `[ line_begin, line_end ]`
+      @map      = nil
+
+       # * Token#nesting -> Number
+       # *
+       # * Level change (number in {-1, 0, 1} set), where:
+       # *
+       # * -  `1` means the tag is opening
+       # * -  `0` means the tag is self-closing
+       # * - `-1` means the tag is closing
+      @nesting  = nesting
+
+       # * Token#level -> Number
+       # *
+       # * nesting level, the same as `state.level`
+      @level    = 0
+
+       # * Token#children -> Array
+       # *
+       # * An array of child nodes (inline and img tokens)
+      @children = nil
+
+       # * Token#content -> String
+       # *
+       # * In a case of self-closing tag (code, html, fence, etc.),
+       # * it has contents of this tag.
+      @content  = ''
+
+       # * Token#markup -> String
+       # *
+       # * '*' or '_' for emphasis, fence string for fence, etc.
+      @markup   = ''
+
+       # * Token#info -> String
+       # *
+       # * fence infostring
+      @info     = ''
+
+       # * Token#meta -> Object
+       # *
+       # * A place for plugins to store an arbitrary data
+      @meta     = nil
+
+       # * Token#block -> Boolean
+       # *
+       # * True for block-level tokens, false for inline tokens.
+       # * Used in renderer to calculate line breaks
+      @block    = false
+
+       # * Token#hidden -> Boolean
+       # *
+       # * If it's true, ignore this element when rendering. Used for tight lists
+       # * to hide paragraphs.
+      @hidden   = false
+    end
+
+
+    # * Token.attrIndex(name) -> Number
+    # *
+    # * Search attribute index by name.
+    #------------------------------------------------------------------------------
+    def attrIndex(name)
+      return -1 if !@attrs
+
+      attrs = @attrs
+
+      attrs.each_with_index do |attr_, index|
+        return index if attr_[0] == name
+      end
+      return -1
+    end
+
+    # * Token.attrPush(attrData)
+    # *
+    # * Add `[ name, value ]` attribute to list. Init attrs if necessary
+    #------------------------------------------------------------------------------
+    def attrPush(attrData)
+      if @attrs
+        @attrs.push(attrData)
+      else
+        @attrs = [ attrData ]
+      end
+    end
+    
+    #------------------------------------------------------------------------------
+    def to_json
+      {
+        type: @type,
+        tag: @tag,
+        attrs: @attrs,
+        map: @map,
+        nesting: @nesting,
+        level: @level,
+        children: @children.nil? ? nil : @children.each {|t| t.to_json},
+        content: @content,
+        markup: @markup,
+        info: @info,
+        meta: @meta,
+        block: @block,
+        hidden: @hidden
+      }
+    end
+  end
+end