motion-markdown-it-plugins 1.0.0

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

@@ -0,0 +1,136 @@
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-ins
+#------------------------------------------------------------------------------
+
+module MotionMarkdownItPlugins
+  class Ins
+    extend MarkdownIt::Common::Utils
+
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md)
+      md.inline.ruler.before('emphasis', 'ins', lambda { |state, silent| Ins.insert(state, silent) })
+    end
+
+    # 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(Encoding::UTF_8))
+      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr(Encoding::UTF_8))
+
+      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.insert(state, silent)
+      max    = state.posMax
+      start  = state.pos
+      marker = state.src.charCodeAt(start)
+
+      return false if (marker != 0x2B) # '+'
+      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('ins_open', 'ins', 1)
+      token.markup = marker.chr * 2
+
+      state.md.inline.tokenize(state);
+
+      token        = state.push('ins_close', 'ins', -1);
+      token.markup = marker.chr * 2
+
+      state.pos    = state.posMax + 2
+      state.posMax = max
+      return true
+    end
+
+  end
+end

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

@@ -0,0 +1,136 @@
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-mark
+#------------------------------------------------------------------------------
+
+module MotionMarkdownItPlugins
+  class Mark
+    extend MarkdownIt::Common::Utils
+
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md)
+      md.inline.ruler.before('emphasis', 'mark', lambda { |state, silent| Mark.mark(state, silent) })
+    end
+
+    # 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(Encoding::UTF_8))
+      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr(Encoding::UTF_8))
+
+      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.mark(state, silent)
+      max    = state.posMax
+      start  = state.pos
+      marker = state.src.charCodeAt(start)
+
+      return false if (marker != 0x3D) #  '='
+      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('mark_open', 'mark', 1)
+      token.markup = marker.chr * 2
+
+      state.md.inline.tokenize(state)
+
+      token        = state.push('mark_close', 'mark', -1)
+      token.markup = marker.chr * 2
+
+      state.pos    = state.posMax + 2
+      state.posMax = max
+      return true
+    end
+
+  end
+end

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

@@ -0,0 +1,70 @@
+# Process ~subscript~
+#
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-sub
+#------------------------------------------------------------------------------
+
+module MotionMarkdownItPlugins
+  class Sub
+    extend MarkdownIt::Common::Utils
+
+    # same as UNESCAPE_MD_RE plus a space
+    UNESCAPE_RE = /\\([ \!\"\#\$\%\&\'\(\)\*\+\,\-.\/:;<=>?@\[\\\]^_`{|}~])/
+
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md)
+      md.inline.ruler.after('emphasis', 'sub', lambda { |state, silent| Sub.subscript(state, silent) })
+    end
+
+    #------------------------------------------------------------------------------
+    def self.subscript(state, silent)
+      max   = state.posMax
+      start = state.pos
+
+      return false if (state.src.charCodeAt(start) != 0x7E)  # '~'
+      return false if (silent) # don't run any pairs in validation mode
+      return false if (start + 2 >= max)
+
+      state.pos = start + 1
+
+      while (state.pos < max)
+        if (state.src.charCodeAt(state.pos) == 0x7E)  # '~'
+          found = true
+          break
+        end
+
+        state.md.inline.skipToken(state)
+      end
+
+      if (!found || start + 1 == state.pos)
+        state.pos = start
+        return false
+      end
+
+      content = state.src.slice((start + 1)...state.pos)
+
+      # don't allow unescaped spaces/newlines inside
+      if (content.match(/(^|[^\\])(\\\\)*\s/))
+        state.pos = start
+        return false
+      end
+
+      # found!
+      state.posMax = state.pos
+      state.pos    = start + 1
+
+      # Earlier we checked !silent, but this implementation does not need it
+      token         = state.push('sub_open', 'sub', 1)
+      token.markup  = '~'
+
+      token         = state.push('text', '', 0)
+      token.content = content.gsub(UNESCAPE_RE, '\1')
+
+      token         = state.push('sub_close', 'sub', -1)
+      token.markup  = '~'
+
+      state.pos    = state.posMax + 1
+      state.posMax = max
+      return true
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# Process ^superscript^
+#
+# Based on Javascript version: https://github.com/markdown-it/markdown-it-sup
+#------------------------------------------------------------------------------
+
+module MotionMarkdownItPlugins
+  class Sup
+    extend MarkdownIt::Common::Utils
+
+    # same as UNESCAPE_MD_RE plus a space
+    UNESCAPE_RE = /\\([ \!\"\#\$\%\&\'\(\)\*\+\,\-.\/:;<=>?@\[\\\]^_`{|}~])/
+
+    #------------------------------------------------------------------------------
+    def self.init_plugin(md)
+      md.inline.ruler.after('emphasis', 'sup', lambda { |state, silent| Sup.superscript(state, silent) })
+    end
+
+    #------------------------------------------------------------------------------
+    def self.superscript(state, silent)
+      max   = state.posMax
+      start = state.pos
+
+      return false if (state.src.charCodeAt(start) != 0x5E)  #  '^'
+      return false if (silent)  # don't run any pairs in validation mode
+      return false if (start + 2 >= max)
+
+      state.pos = start + 1
+
+      while (state.pos < max)
+        if (state.src.charCodeAt(state.pos) == 0x5E)  # '^'
+          found = true
+          break
+        end
+
+        state.md.inline.skipToken(state)
+      end
+
+      if (!found || start + 1 == state.pos)
+        state.pos = start
+        return false
+      end
+
+      content = state.src.slice((start + 1)...state.pos)
+
+      # don't allow unescaped spaces/newlines inside
+      if (content.match(/(^|[^\\])(\\\\)*\s/))
+        state.pos = start
+        return false
+      end
+
+      # found!
+      state.posMax = state.pos
+      state.pos    = start + 1
+
+      # Earlier we checked !silent, but this implementation does not need it
+      token         = state.push('sup_open', 'sup', 1)
+      token.markup  = '^'
+
+      token         = state.push('text', '', 0)
+      token.content = content.gsub(UNESCAPE_RE, '\1')
+
+      token         = state.push('sup_close', 'sup', -1)
+      token.markup  = '^'
+
+      state.pos     = state.posMax + 1
+      state.posMax  = max
+      return true
+    end
+  end
+end
+

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

@@ -0,0 +1,5 @@
+module MotionMarkdownItPlugins
+
+  VERSION = '1.0.0'
+
+end

data/spec/abbr/abbr_spec.rb

@@ -0,0 +1,8 @@
+fixture_dir  = fixture_path('abbr/fixtures')
+
+#------------------------------------------------------------------------------
+describe 'markdown-it-abbr' do
+  md = MarkdownIt::Parser.new
+  md.use(MotionMarkdownItPlugins::Abbr)
+  generate(File.join(fixture_dir, 'abbr.txt'), md)
+end

data/spec/checkbox_replace/checkbox_replace_spec.rb

@@ -0,0 +1,64 @@
+fixture_dir  = fixture_path('checkbox_replace/fixtures')
+
+describe 'markdown-it-checkbox' do
+
+  #------------------------------------------------------------------------------
+  describe 'markdown-it-checkbox()' do
+    md = MarkdownIt::Parser.new
+    md.use(MotionMarkdownItPlugins::CheckboxReplace, {divWrap: false})
+    specfile  = File.join(fixture_dir, 'checkbox.txt')
+    tests     = get_tests(specfile)
+    tests.each do |t|
+      define_test(t, md)
+    end
+
+    #------------------------------------------------------------------------------
+    it 'should pass irrelevant markdown' do
+      md  = MarkdownIt::Parser.new
+      res = md.render('# test')
+      expect(res).to eq "<h1>test</h1>\n"
+    end
+  end
+
+  #------------------------------------------------------------------------------
+  describe 'markdown-it-checkbox(options)' do
+
+    #------------------------------------------------------------------------------
+    it 'should should optionally wrap arround a div layer' do
+      md = MarkdownIt::Parser.new
+      md.use(MotionMarkdownItPlugins::CheckboxReplace, {divWrap: true})
+      res = md.render('[X] test written')
+      expect(res).to eq '<p>' +
+        '<div class="checkbox">' +
+        '<input type="checkbox" id="checkbox0" checked="true">' +
+        '<label for="checkbox0">test written</label>' +
+        '</div>' +
+        "</p>\n"
+    end
+
+    #------------------------------------------------------------------------------
+    it 'should should optionally change class of div layer' do
+      md = MarkdownIt::Parser.new
+      md.use(MotionMarkdownItPlugins::CheckboxReplace, {divWrap: true, divClass: 'cb'})
+      res = md.render('[X] test written')
+      expect(res).to eq '<p>' +
+        '<div class="cb">' +
+        '<input type="checkbox" id="checkbox0" checked="true">' +
+        '<label for="checkbox0">test written</label>' +
+        '</div>' +
+        "</p>\n"
+    end
+
+    #------------------------------------------------------------------------------
+    it 'should should optionally change the id' do
+      md = MarkdownIt::Parser.new
+      md.use(MotionMarkdownItPlugins::CheckboxReplace, {idPrefix: 'cb'})
+      res = md.render('[X] test written')
+      expect(res).to eq '<p>' +
+        '<input type="checkbox" id="cb0" checked="true">' +
+        '<label for="cb0">test written</label>' +
+        "</p>\n"
+    end
+  end
+
+end