motion-markdown-it 0.4.0.3.0

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

@@ -0,0 +1,113 @@
+# internal
+# class ParserBlock
+#
+# Block-level tokenizer.
+#------------------------------------------------------------------------------
+module MarkdownIt
+  class ParserBlock
+
+    attr_accessor   :ruler
+    
+    RULES = [
+      # First 2 params - rule name & source. Secondary array - list of rules,
+      # which can be terminated by this one.
+      [ 'code',         lambda { |state, startLine, endLine, silent| RulesBlock::Code.code(state, startLine, endLine, silent) } ],
+      [ 'fence',        lambda { |state, startLine, endLine, silent| RulesBlock::Fence.fence(state, startLine, endLine, silent) },      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
+      [ 'blockquote',   lambda { |state, startLine, endLine, silent| RulesBlock::Blockquote.blockquote(state, startLine, endLine, silent) }, [ 'paragraph', 'reference', 'list' ] ],
+      [ 'hr',           lambda { |state, startLine, endLine, silent| RulesBlock::Hr.hr(state, startLine, endLine, silent) },         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],
+      [ 'list',         lambda { |state, startLine, endLine, silent| RulesBlock::List.list(state, startLine, endLine, silent) },       [ 'paragraph', 'reference', 'blockquote' ] ],
+      [ 'reference',    lambda { |state, startLine, endLine, silent| RulesBlock::Reference.reference(state, startLine, endLine, silent) } ],
+      [ 'heading',      lambda { |state, startLine, endLine, silent| RulesBlock::Heading.heading(state, startLine, endLine, silent) },    [ 'paragraph', 'reference', 'blockquote' ] ],
+      [ 'lheading',     lambda { |state, startLine, endLine, silent| RulesBlock::Lheading.lheading(state, startLine, endLine, silent) } ],
+      [ 'html_block',   lambda { |state, startLine, endLine, silent| RulesBlock::HtmlBlock.html_block(state, startLine, endLine, silent) }, [ 'paragraph', 'reference', 'blockquote' ] ],
+      [ 'table',        lambda { |state, startLine, endLine, silent| RulesBlock::Table.table(state, startLine, endLine, silent) },      [ 'paragraph', 'reference' ] ],
+      [ 'paragraph',    lambda { |state, startLine, endLine, silent| RulesBlock::Paragraph.paragraph(state, startLine) } ]
+    ]
+
+
+    # new ParserBlock()
+    #------------------------------------------------------------------------------
+    def initialize
+      # ParserBlock#ruler -> Ruler
+      #
+      # [[Ruler]] instance. Keep configuration of block rules.
+      @ruler = Ruler.new
+
+      RULES.each do |rule|
+        @ruler.push(rule[0], rule[1], {alt: (rule[2] || []) })
+      end
+    end
+
+
+    # Generate tokens for input range
+    #------------------------------------------------------------------------------
+    def tokenize(state, startLine, endLine, ignored = false)
+      rules         = @ruler.getRules('')
+      len           = rules.length
+      line          = startLine
+      hasEmptyLines = false
+      maxNesting    = state.md.options[:maxNesting]
+      
+      while line < endLine
+        state.line = line = state.skipEmptyLines(line)
+        break if line >= endLine
+
+        # Termination condition for nested calls.
+        # Nested calls currently used for blockquotes & lists
+        break if state.tShift[line] < state.blkIndent
+
+        # If nesting level exceeded - skip tail to the end. That's not ordinary
+        # situation and we should not care about content.
+        if state.level >= maxNesting
+          state.line = endLine
+          break
+        end
+
+        # Try all possible rules.
+        # On success, rule should:
+        #
+        # - update `state.line`
+        # - update `state.tokens`
+        # - return true
+        0.upto(len - 1) do |i|
+          ok = rules[i].call(state, line, endLine, false)
+          break if ok
+        end
+
+        # set state.tight iff we had an empty line before current tag
+        # i.e. latest empty line should not count
+        state.tight = !hasEmptyLines
+
+        # paragraph might "eat" one newline after it in nested lists
+        if state.isEmpty(state.line - 1)
+          hasEmptyLines = true
+        end
+
+        line = state.line
+
+        if line < endLine && state.isEmpty(line)
+          hasEmptyLines = true
+          line += 1
+
+          # two empty lines should stop the parser in list mode
+          break if line < endLine && state.parentType == 'list' && state.isEmpty(line)
+          state.line = line
+        end
+      end
+    end
+
+    # ParserBlock.parse(src, md, env, outTokens)
+    #
+    # Process input string and push block tokens into `outTokens`
+    #------------------------------------------------------------------------------
+    def parse(src, md, env, outTokens)
+
+      reutrn [] if !src
+
+      state = RulesBlock::StateBlock.new(src, md, env, outTokens)
+
+      tokenize(state, state.line, state.lineMax)
+    end
+
+  end
+end

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

@@ -0,0 +1,46 @@
+# internal
+# class Core
+#
+# Top-level rules executor. Glues block/inline parsers and does intermediate
+# transformations.
+#------------------------------------------------------------------------------
+module MarkdownIt
+  class ParserCore
+
+    attr_accessor   :ruler
+    
+    RULES = [
+      [ 'normalize',      lambda { |state| RulesCore::Normalize.inline(state) }         ],
+      [ 'block',          lambda { |state| RulesCore::Block.block(state) }              ],
+      [ 'inline',         lambda { |state| RulesCore::Inline.inline(state) }            ],
+      [ 'linkify',        lambda { |state| RulesCore::Linkify.linkify(state) }          ],
+      [ 'replacements',   lambda { |state| RulesCore::Replacements.replace(state) }     ],
+      [ 'smartquotes',    lambda { |state| RulesCore::Smartquotes.smartquotes(state) }  ],
+    ]
+
+
+    # new Core()
+    #------------------------------------------------------------------------------
+    def initialize
+      # Core#ruler -> Ruler
+      #
+      # [[Ruler]] instance. Keep configuration of core rules.
+      @ruler = Ruler.new
+
+      RULES.each do |rule|
+        @ruler.push(rule[0], rule[1])
+      end
+    end
+
+    # Core.process(state)
+    #
+    # Executes core chain rules.
+    #------------------------------------------------------------------------------
+    def process(state)
+      rules = @ruler.getRules('')
+      rules.each do |rule|
+        rule.call(state)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# internal
+# class ParserInline
+#
+# Tokenizes paragraph content.
+#------------------------------------------------------------------------------
+module MarkdownIt
+  class ParserInline
+    
+    attr_accessor   :ruler
+    
+    #------------------------------------------------------------------------------
+    # Parser rules
+
+    RULES = [
+      [ 'text',            lambda { |state, startLine| RulesInline::Text.text(state, startLine) } ],
+      [ 'newline',         lambda { |state, startLine| RulesInline::Newline.newline(state, startLine) } ],
+      [ 'escape',          lambda { |state, startLine| RulesInline::Escape.escape(state, startLine) } ],
+      [ 'backticks',       lambda { |state, startLine| RulesInline::Backticks.backtick(state, startLine) } ],
+      [ 'strikethrough',   lambda { |state, startLine| RulesInline::Strikethrough.strikethrough(state, startLine) } ],
+      [ 'emphasis',        lambda { |state, startLine| RulesInline::Emphasis.emphasis(state, startLine) } ],
+      [ 'link',            lambda { |state, startLine| RulesInline::Link.link(state, startLine) } ],
+      [ 'image',           lambda { |state, startLine| RulesInline::Image.image(state, startLine) } ],
+      [ 'autolink',        lambda { |state, startLine| RulesInline::Autolink.autolink(state, startLine) } ],
+      [ 'html_inline',     lambda { |state, startLine| RulesInline::HtmlInline.html_inline(state, startLine) } ],
+      [ 'entity',          lambda { |state, startLine| RulesInline::Entity.entity(state, startLine) } ],
+    ]
+
+
+    #------------------------------------------------------------------------------
+    def initialize
+      # ParserInline#ruler -> Ruler
+      #
+      # [[Ruler]] instance. Keep configuration of inline rules.
+      @ruler = Ruler.new
+
+      RULES.each do |rule|
+        @ruler.push(rule[0], rule[1])
+      end
+    end
+
+    # Skip single token by running all rules in validation mode;
+    # returns `true` if any rule reported success
+    #------------------------------------------------------------------------------
+    def skipToken(state)
+      pos        = state.pos
+      rules      = @ruler.getRules('')
+      len        = rules.length
+      maxNesting = state.md.options[:maxNesting]
+      cache      = state.cache
+
+
+      if cache[pos] != nil
+        state.pos = cache[pos]
+        return
+      end
+
+      # istanbul ignore else
+      if state.level < maxNesting
+        0.upto(len -1) do |i|
+          if rules[i].call(state, true)
+            cache[pos] = state.pos
+            return
+          end
+        end
+      end
+
+      state.pos += 1
+      cache[pos] = state.pos
+    end
+
+
+    # Generate tokens for input range
+    #------------------------------------------------------------------------------
+    def tokenize(state)
+      rules      = @ruler.getRules('')
+      len        = rules.length
+      end_pos    = state.posMax
+      maxNesting = state.md.options[:maxNesting]
+
+      while state.pos < end_pos
+        # Try all possible rules.
+        # On success, rule should:
+        #
+        # - update `state.pos`
+        # - update `state.tokens`
+        # - return true
+
+        ok = false
+        if state.level < maxNesting
+          0.upto(len - 1) do |i|
+            ok = rules[i].call(state, false)
+            break if ok
+          end
+        end
+
+        if ok
+          break if state.pos >= end_pos
+          next
+        end
+
+        state.pending += state.src[state.pos]
+        state.pos     += 1
+      end
+
+      unless state.pending.empty?
+        state.pushPending
+      end
+    end
+
+    # ParserInline.parse(str, md, env, outTokens)
+    #
+    # Process input string and push inline tokens into `outTokens`
+    #------------------------------------------------------------------------------
+    def parse(str, md, env, outTokens)
+      state = RulesInline::StateInline.new(str, md, env, outTokens)
+
+      tokenize(state)
+    end
+
+  end
+end

data/lib/motion-markdown-it/presets/commonmark.rb

@@ -0,0 +1,76 @@
+# Commonmark default options
+
+module MarkdownIt
+  module Presets
+    class Commonmark
+      def self.options
+        {
+          options: {
+            html:         true,         # Enable HTML tags in source
+            xhtmlOut:     true,         # Use '/' to close single tags (<br />)
+            breaks:       false,        # Convert '\n' in paragraphs into <br>
+            langPrefix:   'language-',  # CSS language prefix for fenced blocks
+            linkify:      false,        # autoconvert URL-like texts to links
+
+            # Enable some language-neutral replacements + quotes beautification
+            typographer:  false,
+
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.
+            quotes: "\u201c\u201d\u2018\u2019", # “”‘’
+
+            # Highlighter function. Should return escaped HTML,
+            # or '' if input not changed
+            #
+            # function (/*str, lang*/) { return ''; }
+            #
+            highlight: nil,
+
+            maxNesting:   20            # Internal protection, recursion limit
+          },
+
+          components: {
+
+            core: {
+              rules: [
+                'normalize',
+                'block',
+                'inline'
+              ]
+            },
+
+            block: {
+              rules: [
+                'blockquote',
+                'code',
+                'fence',
+                'heading',
+                'hr',
+                'html_block',
+                'lheading',
+                'list',
+                'reference',
+                'paragraph'
+              ]
+            },
+
+            inline: {
+              rules: [
+                'autolink',
+                'backticks',
+                'emphasis',
+                'entity',
+                'escape',
+                'html_inline',
+                'image',
+                'link',
+                'newline',
+                'text'
+              ]
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/motion-markdown-it/presets/default.rb

@@ -0,0 +1,42 @@
+# markdown-it default options
+
+module MarkdownIt
+  module Presets
+    class Default
+      def self.options
+        {
+          options: {
+            html:         false,        # Enable HTML tags in source
+            xhtmlOut:     false,        # Use '/' to close single tags (<br />)
+            breaks:       false,        # Convert '\n' in paragraphs into <br>
+            langPrefix:   'language-',  # CSS language prefix for fenced blocks
+            linkify:      false,        # autoconvert URL-like texts to links
+
+            # Enable some language-neutral replacements + quotes beautification
+            typographer:  false,
+
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.
+            quotes: "\u201c\u201d\u2018\u2019", # “”‘’ 
+
+            # Highlighter function. Should return escaped HTML,
+            # or '' if input not changed
+            #
+            # function (/*str, lang*/) { return ''; }
+            #
+            highlight: nil,
+
+            maxNesting:   20            # Internal protection, recursion limit
+          },
+
+          components: {
+
+            core: {},
+            block: {},
+            inline: {}
+          }
+        }
+      end
+    end
+  end
+end

data/lib/motion-markdown-it/presets/zero.rb

@@ -0,0 +1,59 @@
+# "Zero" preset, with nothing enabled. Useful for manual configuring of simple
+# modes. For example, to parse bold/italic only.
+
+module MarkdownIt
+  module Presets
+    class Zero
+      def self.options
+        {
+          options: {
+            html:         false,        # Enable HTML tags in source
+            xhtmlOut:     false,        # Use '/' to close single tags (<br />)
+            breaks:       false,        # Convert '\n' in paragraphs into <br>
+            langPrefix:   'language-',  # CSS language prefix for fenced blocks
+            linkify:      false,        # autoconvert URL-like texts to links
+
+            # Enable some language-neutral replacements + quotes beautification
+            typographer:  false,
+
+            # Double + single quotes replacement pairs, when typographer enabled,
+            # and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.
+            quotes: "\u201c\u201d\u2018\u2019", # “”‘’
+
+            # Highlighter function. Should return escaped HTML,
+            # or '' if input not changed
+            #
+            # function (/*str, lang*/) { return ''; }
+            #
+            highlight: nil,
+
+            maxNesting:   20            # Internal protection, recursion limit
+          },
+
+          components: {
+
+            core: {
+              rules: [
+                'normalize',
+                'block',
+                'inline'
+              ]
+            },
+
+            block: {
+              rules: [
+                'paragraph'
+              ]
+            },
+
+            inline: {
+              rules: [
+                'text'
+              ]
+            }
+          }
+        }
+      end
+    end
+  end
+end