motion-markdown-it-plugins 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 932bce733bfd0e1070663a7b560a5e255817c85c
+  data.tar.gz: 54572d459acb95df6d00fd0736ee71f5ecc3691d
+SHA512:
+  metadata.gz: 1bf53209e1279e1467415f9c9b8b91f59e57ec526edac36cad5b287993a8ea6b7409202490e84017b9487d98915e359a4012f59f232aaf568335546c5f9632b3
+  data.tar.gz: 9b67f602c172395eb74d7d9c2a114a6315df287eb3ae404c821eeb253c11fe0cd828e705bf2f2c17b59827ea47279d277a6882aa8cda0a6753b8d2d9769cbc91

data/README.md

@@ -0,0 +1,18 @@
+# motion-markdown-it-plugins
+
+[![Gem Version](https://badge.fury.io/rb/motion-markdown-it-plugins.svg)](http://badge.fury.io/rb/motion-markdown-it-plugins)
+
+Various useful plugins for use with `motion-markdown-it`. Works with Ruby and RubyMotion.
+
+## Plugins
+
+Each one has a README with details
+
+* [Abbreviations](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/abbr)
+* [Checkbox/Tasklists](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/checkbox_replace)
+* [Containers](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/container)
+* [Definition Lists](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/deflist)
+* [Insert](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/ins)
+* [Mark](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/mark)
+* [Subscript](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/sub)
+* [Superscript](https://github.com/digitalmoksha/motion-markdown-it-plugins/tree/master/lib/motion-markdown-it-plugins/sup)

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+if defined?(Motion::Project::Config)
+  
+  lib_dir_path = File.dirname(File.expand_path(__FILE__))
+  Motion::Project::App.setup do |app|
+    app.files.unshift(Dir.glob(File.join(lib_dir_path, "motion-markdown-it-plugins/**/*.rb")))
+  end
+
+  require 'motion-markdown-it'
+  
+else
+  
+  require 'motion-markdown-it'
+  require 'motion-markdown-it-plugins/checkbox_replace/checkbox_replace'
+  require 'motion-markdown-it-plugins/deflist/deflist'
+  require 'motion-markdown-it-plugins/abbr/abbr'
+  require 'motion-markdown-it-plugins/ins/ins'
+  require 'motion-markdown-it-plugins/mark/mark'
+  require 'motion-markdown-it-plugins/sub/sub'
+  require 'motion-markdown-it-plugins/sup/sup'
+  require 'motion-markdown-it-plugins/container/container'
+  
+end

data/lib/motion-markdown-it-plugins/abbr/abbr.rb

@@ -0,0 +1,130 @@
+# Enclose abbreviations in <abbr> tags
+#
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-abbr
+#------------------------------------------------------------------------------
+include MarkdownIt::Common::Utils
+
+module MotionMarkdownItPlugins
+  class Abbr
+    PUNCT_CHARS         = ' \n()[]\'".,!?-'
+    PUNCT_CAHRS_ESCAPED = PUNCT_CHARS.chars.map {|c| escapeRE(c)}.join
+    
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md)
+      md.block.ruler.before('reference', 'abbr_def', 
+          lambda { |state, startLine, endLine, silent| Abbr.abbr_def(state, startLine, endLine, silent) },
+          {alt: ['', 'paragraph', 'reference']})
+      md.core.ruler.after('inline', 'abbr_replace', lambda { |state| Abbr.abbr_replace(state) })
+    end
+
+    #------------------------------------------------------------------------------
+    def self.abbr_def(state, startLine, endLine, silent)
+      pos = state.bMarks[startLine] + state.tShift[startLine]
+      max = state.eMarks[startLine]
+
+      return false if (pos + 2 >= max)
+      return false if (state.src.charCodeAt(pos) != 0x2A)  # '*'
+      pos += 1
+      return false if (state.src.charCodeAt(pos) != 0x5B)  # '['
+      pos += 1
+
+      labelStart = pos
+
+      while pos < max
+        ch = state.src.charCodeAt(pos)
+        if (ch == 0x5B)  # '['
+          return false
+        elsif (ch == 0x5D)  #  ']'
+          labelEnd = pos
+          break
+        elsif (ch == 0x5C)  #  '\'
+          pos += 1
+        end
+        pos += 1
+      end
+
+      return false if (labelEnd < 0 || state.src.charCodeAt(labelEnd + 1) != 0x3A)  # ':'
+      return true  if (silent)
+
+      label = state.src.slice(labelStart...labelEnd).gsub(/\\(.)/, '\1')
+      title = state.src.slice((labelEnd + 2)...max).strip
+      return false if (title.length == 0)
+
+      state.env[:abbreviations] = {} if (!state.env[:abbreviations])
+      state.env[:abbreviations][label] = title if state.env[:abbreviations][label].nil?
+
+      state.line = startLine + 1
+      return true
+    end
+
+    #------------------------------------------------------------------------------
+    def self.abbr_replace(state)
+      blockTokens = state.tokens
+
+      return if (!state.env[:abbreviations])
+      if (!state.env[:abbrRegExp])
+        regText = "(^|[#{PUNCT_CAHRS_ESCAPED}])("
+        regText << state.env[:abbreviations].keys.sort {|a, b| b.length <=> a.length}.map {|x| escapeRE(x)}.join('|')
+        regText << ")($|[#{PUNCT_CAHRS_ESCAPED}])"
+
+        state.env[:abbrRegExp] = Regexp.new(regText)
+      end
+      reg = state.env[:abbrRegExp]
+
+      j = 0
+      l = blockTokens.length
+      while j < l
+        j += 1 and next if (blockTokens[j].type != 'inline')
+        tokens = blockTokens[j].children
+
+        # We scan from the end, to keep position when new tags added.
+        i = tokens.length - 1
+        while i >= 0
+          currentToken = tokens[i]
+          i -= 1 and next if (currentToken.type != 'text')
+
+          pos       = 0
+          text      = currentToken.content
+          lastIndex = 0
+          nodes     = []
+
+          while ((m = reg.match(text, lastIndex)))
+            lastIndex = m.end(0)
+            if (lastIndex > pos)
+              token         = MarkdownIt::Token.new('text', '', 0)
+              token.content = text.slice(pos...(m.begin(0) + m[1].length))
+              nodes.push(token)
+            end
+
+            token         = MarkdownIt::Token.new('abbr_open', 'abbr', 1)
+            token.attrs   = [ [ 'title', state.env[:abbreviations][m[2]] ] ]
+            nodes.push(token)
+
+            token         = MarkdownIt::Token.new('text', '', 0)
+            token.content = m[2]
+            nodes.push(token)
+
+            token         = MarkdownIt::Token.new('abbr_close', 'abbr', -1)
+            nodes.push(token)
+
+            pos = lastIndex - m[3].length
+          end
+
+          i -= 1 and next if nodes.empty?
+
+          if (pos < text.length)
+            token         = MarkdownIt::Token.new('text', '', 0)
+            token.content = text.slice(pos..-1)
+            nodes.push(token)
+          end
+
+          # replace current node
+          blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)
+          i -= 1
+        end
+        j += 1
+      end
+    end
+
+  end
+end

data/lib/motion-markdown-it-plugins/checkbox_replace/checkbox_replace.rb

@@ -0,0 +1,103 @@
+# Based on Javascript version: https://github.com/mcecot/markdown-it-checkbox
+#------------------------------------------------------------------------------
+include MarkdownIt::Common::Utils
+
+module MotionMarkdownItPlugins
+  class CheckboxReplace
+    PATTERN = /\[(X|\s|\_|\-)\]\s(.*)/i
+    
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md, options)
+      check = CheckboxReplace.new(md, options)
+      md.core.ruler.push('checkbox', lambda { |state| check.checkbox(state) } )
+    end
+
+    #------------------------------------------------------------------------------
+    def initialize(md, options)
+      @lastId  = 0
+      defaults = {divWrap: false, divClass: 'checkbox', idPrefix: 'checkbox'}
+      @options = defaults.merge(options)
+    end
+
+    #------------------------------------------------------------------------------
+    def createTokens(checked, label)
+      nodes = []
+
+      # <div class="checkbox">
+      if @options[:divWrap]
+        token = MarkdownIt::Token.new("checkbox_open", "div", 1)
+        token.attrs = [["class", @options[:divClass]]]
+        nodes.push token
+      end
+
+      # <input type="checkbox" id="checkbox{n}" checked="true">
+      id          = "#{@options[:idPrefix]}#{@lastId}"
+      @lastId    += 1
+      token       = MarkdownIt::Token.new("checkbox_input", "input", 0)
+      token.attrs = [["type","checkbox"],["id",id]]
+      if (checked == true)
+        token.attrs.push ["checked","true"]
+      end
+      nodes.push token
+
+      # <label for="checkbox{n}">
+      token       = MarkdownIt::Token.new("label_open", "label", 1)
+      token.attrs = [["for",id]]
+      nodes.push token
+
+      # content of label tag
+      token         = MarkdownIt::Token.new("text", "", 0)
+      token.content = label
+      nodes.push token
+
+      # closing tags
+      nodes.push MarkdownIt::Token.new("label_close", "label", -1)
+      if @options[:divWrap]
+        nodes.push MarkdownIt::Token.new("checkbox_close", "div", -1)
+      end
+
+      return nodes
+    end
+  
+    #------------------------------------------------------------------------------
+    def splitTextToken(original)
+
+      text      = original.content
+      matches   = text.match(PATTERN)
+
+      return original if matches == nil
+
+      value     = matches[1]
+      label     = matches[2]
+      checked   = false
+      checked   = true if (value == "X" || value == "x")
+
+      return createTokens(checked, label)
+    end
+
+    #------------------------------------------------------------------------------
+    def checkbox(state)
+      blockTokens = state.tokens
+      j = 0
+      l = blockTokens.length
+      while j < l
+        if blockTokens[j].type != "inline"
+          j += 1
+          next
+        end
+        tokens = blockTokens[j].children
+
+        # 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
+          token = tokens[i]
+          blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, splitTextToken(token))
+          i -= 1
+        end
+        j += 1
+      end
+    end
+  end
+end
+

data/lib/motion-markdown-it-plugins/container/container.rb

@@ -0,0 +1,154 @@
+# Process block-level custom containers
+#
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-container
+#------------------------------------------------------------------------------
+
+module MotionMarkdownItPlugins
+  class Container
+    extend MarkdownIt::Common::Utils
+
+    attr_accessor   :render
+    
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md, name, options = {})
+      container_obj = Container.new(md, name, options)
+      md.block.ruler.before('fence', "container_#{name}", 
+          lambda { |state, startLine, endLine, silent| container_obj.container(state, startLine, endLine, silent) },
+          {alt: [ '', 'paragraph', 'reference', 'blockquote', 'list' ]})
+
+      md.renderer.rules["container_#{name}_open"]  = container_obj.render
+      md.renderer.rules["container_#{name}_close"] = container_obj.render
+    end
+
+    #------------------------------------------------------------------------------
+    def initialize(md, name, options)
+      @options     = options || {}
+      @name        = name
+      @min_markers = 3
+      @marker_str  = @options[:marker] || ':'
+      @marker_char = @marker_str.charCodeAt(0)
+      @marker_len  = @marker_str.length
+      @validate    = @options[:validate] || lambda {|params| validateDefault(params) }
+      @render      = @options[:render]   || lambda {|tokens, idx, _options, env, renderer| renderDefault(tokens, idx, _options, env, renderer) }
+    end
+
+    #------------------------------------------------------------------------------
+    def validateDefault(params)
+      return params.strip.split(' ', 2)[0] == @name
+    end
+
+    #------------------------------------------------------------------------------
+    def renderDefault(tokens, idx, _options, env, renderer)
+
+      # add a class to the opening tag
+      if (tokens[idx].nesting == 1)
+        tokens[idx].attrPush([ 'class', @name ])
+      end
+
+      return renderer.renderToken(tokens, idx, _options, env, renderer)
+    end
+
+    #------------------------------------------------------------------------------
+    def container(state, startLine, endLine, silent)
+      auto_closed = false
+      start       = state.bMarks[startLine] + state.tShift[startLine]
+      max         = state.eMarks[startLine]
+
+      # Check out the first character quickly,
+      # this should filter out most of non-containers
+      return false if (@marker_char != state.src.charCodeAt(start))
+
+      # Check out the rest of the marker string
+      pos = start + 1
+      while pos <= max
+        break if (@marker_str[(pos - start) % @marker_len] != state.src[pos])
+        pos += 1
+      end
+
+      marker_count = ((pos - start) / @marker_len).floor
+      return false if (marker_count < @min_markers)
+      pos -= (pos - start) % @marker_len
+
+      markup = state.src.slice(start...pos)
+      params = state.src.slice(pos...max)
+      return false if (!@validate.call(params))
+
+      # Since start is found, we can report success here in validation mode
+      return true if (silent)
+
+      # Search for the end of the block
+      nextLine = startLine
+
+      while true
+        nextLine += 1
+        if (nextLine >= endLine)
+          # unclosed block should be autoclosed by end of document.
+          # also block seems to be autoclosed by end of parent
+          break
+        end
+
+        start = state.bMarks[nextLine] + state.tShift[nextLine]
+        max   = state.eMarks[nextLine]
+
+        if (start < max && state.tShift[nextLine] < state.blkIndent)
+          # non-empty line with negative indent should stop the list:
+          # - ```
+          #  test
+          break
+        end
+
+        next if (@marker_char != state.src.charCodeAt(start))
+
+        if (state.tShift[nextLine] - state.blkIndent >= 4)
+          # closing fence should be indented less than 4 spaces
+          next
+        end
+
+        pos = start + 1
+        while pos <= max
+          break if (@marker_str[(pos - start) % @marker_len] != state.src[pos])
+          pos += 1
+        end
+
+        # closing code fence must be at least as long as the opening one
+        next if (((pos - start).floor / @marker_len) < marker_count)
+
+        # make sure tail has spaces only
+        pos -= (pos - start) % @marker_len
+        pos  = state.skipSpaces(pos)
+
+        next if (pos < max)
+
+        # found!
+        auto_closed = true
+        break
+      end
+
+      old_parent       = state.parentType
+      old_line_max     = state.lineMax
+      state.parentType = 'container'
+
+      # this will prevent lazy continuations from ever going past our end marker
+      state.lineMax = nextLine
+
+      token        = state.push("container_#{@name}_open", 'div', 1)
+      token.markup = markup
+      token.block  = true
+      token.info   = params
+      token.map    = [ startLine, nextLine ]
+
+      state.md.block.tokenize(state, startLine + 1, nextLine)
+
+      token        = state.push("container_#{@name}_close", 'div', -1)
+      token.markup = state.src.slice(start...pos)
+      token.block  = true
+
+      state.parentType = old_parent
+      state.lineMax    = old_line_max
+      state.line       = nextLine + (auto_closed ? 1 : 0)
+
+      return true
+    end
+
+  end
+end

data/lib/motion-markdown-it-plugins/deflist/deflist.rb

@@ -0,0 +1,185 @@
+# Process definition lists
+#
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-deflist
+#------------------------------------------------------------------------------
+include MarkdownIt::Common::Utils
+
+module MotionMarkdownItPlugins
+  class Deflist
+
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md)
+      md.block.ruler.before('paragraph', 'deflist', 
+          lambda { |state, startLine, endLine, silent| Deflist.deflist(state, startLine, endLine, silent) },
+          {alt: ['', 'paragraph', 'reference']})
+    end
+
+    # Search `[:~][\n ]`, returns next pos after marker on success
+    # or -1 on fail.
+    #------------------------------------------------------------------------------
+    def self.skipMarker(state, line)
+      start = state.bMarks[line] + state.tShift[line]
+      max   = state.eMarks[line]
+
+      return -1 if (start >= max)
+
+      # Check bullet
+      marker = state.src.charCodeAt(start)
+      start += 1
+      return -1 if (marker != 0x7E && marker != 0x3A) #  '~'  ':'
+
+      pos = state.skipSpaces(start)
+
+      # require space after ":"
+      return -1 if (start == pos)
+
+      # no empty definitions, e.g. "  : "
+      return -1 if (pos >= max)
+
+      return pos
+    end
+
+    #------------------------------------------------------------------------------
+    def self.markTightParagraphs(state, idx)
+      level = state.level + 2
+      i     = idx + 2
+      l     = state.tokens.length - 2
+      while i < l
+        if (state.tokens[i].level == level && state.tokens[i].type == 'paragraph_open')
+          state.tokens[i + 2].hidden = true
+          state.tokens[i].hidden     = true
+          i += 2
+        end
+        i += 1
+      end
+    end
+
+    #------------------------------------------------------------------------------
+    def self.deflist(state, startLine, endLine, silent)
+      if silent
+        # quirk: validation mode validates a dd block only, not a whole deflist
+        return false if (state.ddIndent < 0)
+        return skipMarker(state, startLine) >= 0
+      end
+
+      nextLine = startLine + 1
+      if (state.isEmpty(nextLine))
+        nextLine += 1
+        return false if (nextLine > endLine)
+      end
+
+      return false if (state.tShift[nextLine] < state.blkIndent)
+      contentStart = skipMarker(state, nextLine)
+      return false if (contentStart < 0)
+
+      # Start list
+      listTokIdx = state.tokens.length
+      token      = state.push('dl_open', 'dl', 1)
+      token.map  = listLines = [ startLine, 0 ]
+
+      #--- Iterate list items
+
+      dtLine = startLine
+      ddLine = nextLine
+
+      # One definition list can contain multiple DTs,
+      # and one DT can be followed by multiple DDs.
+      #
+      # Thus, there is two loops here, and label is
+      # needed to break out of the second one
+      # OUTER:
+      while true
+        break_outer    = false
+        tight          = true
+        prevEmptyEnd   = false
+
+        token          = state.push('dt_open', 'dt', 1)
+        token.map      = [ dtLine, dtLine ]
+
+        token          = state.push('inline', '', 0)
+        token.map      = [ dtLine, dtLine ]
+        token.content  = state.getLines(dtLine, dtLine + 1, state.blkIndent, false).strip
+        token.children = []
+
+        token          = state.push('dt_close', 'dt', -1)
+
+        while true
+          token     = state.push('dd_open', 'dd', 1)
+          token.map = itemLines = [ nextLine, 0 ]
+
+          oldTight             = state.tight
+          oldDDIndent          = state.ddIndent
+          oldIndent            = state.blkIndent
+          oldTShift            = state.tShift[ddLine]
+          oldParentType        = state.parentType
+          state.blkIndent      = state.ddIndent = state.tShift[ddLine] + 2
+          state.tShift[ddLine] = contentStart - state.bMarks[ddLine]
+          state.tight          = true
+          state.parentType     = 'deflist'
+
+          state.md.block.tokenize(state, ddLine, endLine, true)
+
+          # If any of list item is tight, mark list as tight
+          if (!state.tight || prevEmptyEnd)
+            tight = false
+          end
+          # Item become loose if finish with empty line,
+          # but we should filter last element, because it means list finish
+          prevEmptyEnd = (state.line - ddLine) > 1 && state.isEmpty(state.line - 1)
+
+          state.tShift[ddLine] = oldTShift
+          state.tight          = oldTight
+          state.parentType     = oldParentType
+          state.blkIndent      = oldIndent
+          state.ddIndent       = oldDDIndent
+
+          token = state.push('dd_close', 'dd', -1)
+
+          itemLines[1] = nextLine = state.line
+
+          break_outer = true and break if (nextLine >= endLine)
+          break_outer = true and break if (state.tShift[nextLine] < state.blkIndent)
+          contentStart = skipMarker(state, nextLine)
+          break if (contentStart < 0)
+
+          ddLine = nextLine
+
+          # go to the next loop iteration:
+          # insert DD tag and repeat checking
+        end
+        break if break_outer
+        
+        break if (nextLine >= endLine)
+        dtLine = nextLine
+
+        break if (state.isEmpty(dtLine))
+        break if (state.tShift[dtLine] < state.blkIndent)
+
+        ddLine = dtLine + 1
+        break if (ddLine >= endLine)
+        ddLine += 1 if (state.isEmpty(ddLine))
+        break if (ddLine >= endLine)
+
+        break if (state.tShift[ddLine] < state.blkIndent)
+        contentStart = skipMarker(state, ddLine)
+        break if (contentStart < 0)
+
+        # go to the next loop iteration:
+        # insert DT and DD tags and repeat checking
+      end
+
+      # Finilize list
+      token        = state.push('dl_close', 'dl', -1)
+      listLines[1] = nextLine
+      state.line   = nextLine
+
+      # mark paragraphs tight if needed
+      if (tight)
+        markTightParagraphs(state, listTokIdx)
+      end
+
+      return true
+    end
+
+  end
+end