motion-markdown-it 0.4.0.3.0

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

@@ -0,0 +1,286 @@
+# class Renderer
+#
+# Generates HTML from parsed token stream. Each instance has independent
+# copy of rules. Those can be rewritten with ease. Also, you can add new
+# rules if you create plugin and adds new token types.
+#------------------------------------------------------------------------------
+module MarkdownIt
+  class Renderer
+    include MarkdownIt::Common::Utils
+    extend  MarkdownIt::Common::Utils
+
+    # Default Rules
+    #------------------------------------------------------------------------------
+    def self.code_inline(tokens, idx)
+      return '<code>' + escapeHtml(tokens[idx].content) + '</code>'
+    end
+
+    #------------------------------------------------------------------------------
+    def self.code_block(tokens, idx)
+      return '<pre><code>' + escapeHtml(tokens[idx].content) + "</code></pre>\n"
+    end
+
+    #------------------------------------------------------------------------------
+    def self.fence(tokens, idx, options, env, renderer)
+      token     = tokens[idx]
+      langName  = ''
+
+      if !token.info.empty?
+        langName = unescapeAll(token.info.strip.split(/\s+/)[0])
+        token.attrPush([ 'class', options[:langPrefix] + langName ])
+      end
+
+      if options[:highlight]
+        highlighted = options[:highlight].call(token.content, langName) || escapeHtml(token.content)
+      else
+        highlighted = escapeHtml(token.content)
+      end
+
+      return  '<pre><code' + renderer.renderAttrs(token) + '>' + highlighted + "</code></pre>\n"
+    end
+
+    #------------------------------------------------------------------------------
+    def self.image(tokens, idx, options, env, renderer)
+      token = tokens[idx]
+
+      # "alt" attr MUST be set, even if empty. Because it's mandatory and
+      # should be placed on proper position for tests.
+      #
+      # Replace content with actual value
+
+      token.attrs[token.attrIndex('alt')][1] = renderer.renderInlineAsText(token.children, options, env)
+
+      return renderer.renderToken(tokens, idx, options);
+    end
+
+    #------------------------------------------------------------------------------
+    def self.hardbreak(tokens, idx, options)
+      return options[:xhtmlOut] ? "<br />\n" : "<br>\n"
+    end
+    def self.softbreak(tokens, idx, options)
+      return options[:breaks] ? (options[:xhtmlOut] ? "<br />\n" : "<br>\n") : "\n"
+    end
+
+    #------------------------------------------------------------------------------
+    def self.text(tokens, idx)
+      return escapeHtml(tokens[idx].content)
+    end
+
+    #------------------------------------------------------------------------------
+    def self.html_block(tokens, idx)
+      return tokens[idx].content
+    end
+    def self.html_inline(tokens, idx)
+      return tokens[idx].content
+    end
+
+
+    # new Renderer()
+    #
+    # Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
+    #------------------------------------------------------------------------------
+    def initialize
+      @default_rules = {
+        'code_inline' => lambda {|tokens, idx, options, env, renderer| Renderer.code_inline(tokens, idx)},
+        'code_block'  => lambda {|tokens, idx, options, env, renderer| Renderer.code_block(tokens, idx)},
+        'fence'       => lambda {|tokens, idx, options, env, renderer| Renderer.fence(tokens, idx, options, env, renderer)},
+        'image'       => lambda {|tokens, idx, options, env, renderer| Renderer.image(tokens, idx, options, env, renderer)},
+        'hardbreak'   => lambda {|tokens, idx, options, env, renderer| Renderer.hardbreak(tokens, idx, options)},
+        'softbreak'   => lambda {|tokens, idx, options, env, renderer| Renderer.softbreak(tokens, idx, options)},
+        'text'        => lambda {|tokens, idx, options, env, renderer| Renderer.text(tokens, idx)},
+        'html_block'  => lambda {|tokens, idx, options, env, renderer| Renderer.html_block(tokens, idx)},
+        'html_inline' => lambda {|tokens, idx, options, env, renderer| Renderer.html_inline(tokens, idx)}
+      }
+      
+      # Renderer#rules -> Object
+      #
+      # Contains render rules for tokens. Can be updated and extended.
+      #
+      # ##### Example
+      #
+      # ```javascript
+      # var md = require('markdown-it')();
+      #
+      # md.renderer.rules.strong_open  = function () { return '<b>'; };
+      # md.renderer.rules.strong_close = function () { return '</b>'; };
+      #
+      # var result = md.renderInline(...);
+      # ```
+      #
+      # Each rule is called as independed static function with fixed signature:
+      #
+      # ```javascript
+      # function my_token_render(tokens, idx, options, env, renderer) {
+      #   // ...
+      #   return renderedHTML;
+      # }
+      # ```
+      #
+      # See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
+      # for more details and examples.
+      @rules = assign({}, @default_rules)
+    end
+
+
+    # Renderer.renderAttrs(token) -> String
+    #
+    # Render token attributes to string.
+    #------------------------------------------------------------------------------
+    def renderAttrs(token)
+      return '' if !token.attrs
+
+      result = ''
+      0.upto(token.attrs.length - 1) do |i|
+        result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1].to_s) + '"'
+      end
+
+      return result
+    end
+
+
+    # Renderer.renderToken(tokens, idx, options) -> String
+    # - tokens (Array): list of tokens
+    # - idx (Numbed): token index to render
+    # - options (Object): params of parser instance
+    #
+    # Default token renderer. Can be overriden by custom function
+    # in [[Renderer#rules]].
+    #------------------------------------------------------------------------------
+    def renderToken(tokens, idx, options, env = nil, renderer = nil)
+      result = ''
+      needLf = false
+      token  = tokens[idx]
+
+      # Tight list paragraphs
+      return '' if token.hidden
+
+      # Insert a newline between hidden paragraph and subsequent opening
+      # block-level tag.
+      #
+      # For example, here we should insert a newline before blockquote:
+      #  - a
+      #    >
+      #
+      if token.block && token.nesting != -1 && idx && tokens[idx - 1].hidden
+        result += "\n"
+      end
+
+      # Add token name, e.g. `<img`
+      result += (token.nesting == -1 ? '</' : '<') + token.tag
+
+      # Encode attributes, e.g. `<img src="foo"`
+      result += renderAttrs(token)
+
+      # Add a slash for self-closing tags, e.g. `<img src="foo" /`
+      if token.nesting == 0 && options[:xhtmlOut]
+        result += ' /'
+      end
+
+      # Check if we need to add a newline after this tag
+      if token.block
+        needLf = true
+
+        if token.nesting == 1
+          if idx + 1 < tokens.length
+            nextToken = tokens[idx + 1]
+
+            if nextToken.type == 'inline' || nextToken.hidden
+              # Block-level tag containing an inline tag.
+              #
+              needLf = false
+
+            elsif nextToken.nesting == -1 && nextToken.tag == token.tag
+              # Opening tag + closing tag of the same type. E.g. `<li></li>`.
+              #
+              needLf = false
+            end
+          end
+        end
+      end
+
+      result += needLf ? ">\n" : '>'
+
+      return result
+    end
+
+
+    # Renderer.renderInline(tokens, options, env) -> String
+    # - tokens (Array): list on block tokens to renter
+    # - options (Object): params of parser instance
+    # - env (Object): additional data from parsed input (references, for example)
+    #
+    # The same as [[Renderer.render]], but for single token of `inline` type.
+    #------------------------------------------------------------------------------
+    def renderInline(tokens, options, env)
+      result  = ''
+      rules   = @rules
+
+      0.upto(tokens.length - 1) do |i|
+        type = tokens[i].type
+        
+        if rules[type] != nil
+          result += rules[type].call(tokens, i, options, env, self)
+        else
+          result += renderToken(tokens, i, options)
+        end
+      end
+
+      return result;
+    end
+
+
+    # internal
+    # Renderer.renderInlineAsText(tokens, options, env) -> String
+    # - tokens (Array): list on block tokens to renter
+    # - options (Object): params of parser instance
+    # - env (Object): additional data from parsed input (references, for example)
+    #
+    # Special kludge for image `alt` attributes to conform CommonMark spec.
+    # Don't try to use it! Spec requires to show `alt` content with stripped markup,
+    # instead of simple escaping.
+    #------------------------------------------------------------------------------
+    def renderInlineAsText(tokens, options, env)
+      result = ''
+      rules  = @rules
+
+      0.upto(tokens.length - 1) do |i|
+        if tokens[i].type == 'text'
+          result += rules['text'].call(tokens, i, options, env, self)
+        elsif tokens[i].type == 'image'
+          result += renderInlineAsText(tokens[i].children, options, env)
+        end
+      end
+
+      return result
+    end
+
+
+    # Renderer.render(tokens, options, env) -> String
+    # - tokens (Array): list on block tokens to renter
+    # - options (Object): params of parser instance
+    # - env (Object): additional data from parsed input (references, for example)
+    #
+    # Takes token stream and generates HTML. Probably, you will never need to call
+    # this method directly.
+    #------------------------------------------------------------------------------
+    def render(tokens, options, env)
+      result = ''
+      rules  = @rules
+
+      0.upto(tokens.length - 1) do |i|
+        type = tokens[i].type
+
+        if type == 'inline'
+          result += renderInline(tokens[i].children, options, env)
+        elsif rules[type] != nil
+          result += rules[tokens[i].type].call(tokens, i, options, env, self)
+        else
+          result += renderToken(tokens, i, options)
+        end
+      end
+
+      return result
+    end
+
+  end
+end

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

@@ -0,0 +1,327 @@
+# * class Ruler
+# *
+# * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
+# * [[MarkdownIt#inline]] to manage sequences of functions (rules):
+# *
+# * - keep rules in defined order
+# * - assign the name to each rule
+# * - enable/disable rules
+# * - add/replace rules
+# * - allow assign rules to additional named chains (in the same)
+# * - cacheing lists of active rules
+# *
+# * You will not need use this class directly until write plugins. For simple
+# * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
+# * [[MarkdownIt.use]].
+#------------------------------------------------------------------------------
+
+module MarkdownIt
+  class Ruler 
+
+    def initialize
+      # // List of added rules. Each element is:
+      # //
+      # // {
+      # //   name: XXX,
+      # //   enabled: Boolean,
+      # //   fn: Function(),
+      # //   alt: [ name2, name3 ]
+      # // }
+      @__rules__ = []
+
+      # // Cached rule chains.
+      # //
+      # // First level - chain name, '' for default.
+      # // Second level - diginal anchor for fast filtering by charcodes.
+      @__cache__ = nil
+    end
+
+    #------------------------------------------------------------------------------
+    # // Helper methods, should not be used directly
+
+
+    # // Find rule index by name
+    #------------------------------------------------------------------------------
+    def __find__(name)
+      @__rules__.each_with_index do |rule, index|
+        return index if (rule[:name] == name)
+      end
+      return -1
+    end
+
+
+    # // Build rules lookup cache
+    #------------------------------------------------------------------------------
+    def __compile__
+      chains = [ '' ]
+
+      # // collect unique names
+      @__rules__.each do |rule|
+        next if !rule[:enabled]
+
+        rule[:alt].each do |altName|
+          if !chains.include?(altName)
+            chains.push(altName)
+          end
+        end
+      end
+
+      @__cache__ = {}
+
+      chains.each do |chain|
+        @__cache__[chain] = []
+        @__rules__.each do |rule|
+          next if !rule[:enabled]
+          next if (chain && !rule[:alt].include?(chain))
+
+          @__cache__[chain].push(rule[:fn])
+        end
+      end
+    end
+
+
+    # * Ruler.at(name, fn [, options])
+    # * - name (String): rule name to replace.
+    # * - fn (Function): new rule function.
+    # * - options (Object): new rule options (not mandatory).
+    # *
+    # * Replace rule by name with new function & options. Throws error if name not
+    # * found.
+    # *
+    # * ##### Options:
+    # *
+    # * - __alt__ - array with names of "alternate" chains.
+    # *
+    # * ##### Example
+    # *
+    # * Replace existing typorgapher replacement rule with new one:
+    # *
+    # * ```javascript
+    # * var md = require('markdown-it')();
+    # *
+    # * md.core.ruler.at('replacements', function replace(state) {
+    # *   //...
+    # * });
+    # * ```
+    #------------------------------------------------------------------------------
+    def at(name, fn, opt = {})
+      index = __find__(name)
+
+      raise(StandardError, "Parser rule not found: #{name}") if index == -1
+      
+      @__rules__[index][:fn] = fn
+      @__rules__[index][:alt] = opt[:alt] || ['']
+      @__cache__ = nil
+    end
+
+
+    # * Ruler.before(beforeName, ruleName, fn [, options])
+    # * - beforeName (String): new rule will be added before this one.
+    # * - ruleName (String): name of added rule.
+    # * - fn (Function): rule function.
+    # * - options (Object): rule options (not mandatory).
+    # *
+    # * Add new rule to chain before one with given name. See also
+    # * [[Ruler.after]], [[Ruler.push]].
+    # *
+    # * ##### Options:
+    # *
+    # * - __alt__ - array with names of "alternate" chains.
+    # *
+    # * ##### Example
+    # *
+    # * ```javascript
+    # * var md = require('markdown-it')();
+    # *
+    # * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+    # *   //...
+    # * });
+    # * ```
+    #------------------------------------------------------------------------------
+    def before(beforeName, ruleName, fn, opt = {})
+      index = __find__(beforeName)
+
+      raise(StandardError, "Parser rule not found: #{beforeName}") if index == -1
+
+      @__rules__.insert(index, {
+        name: ruleName,
+        enabled: true,
+        fn: fn,
+        alt: (opt[:alt] || [''])
+      })
+
+      @__cache__ = nil
+    end
+
+
+    # * Ruler.after(afterName, ruleName, fn [, options])
+    # * - afterName (String): new rule will be added after this one.
+    # * - ruleName (String): name of added rule.
+    # * - fn (Function): rule function.
+    # * - options (Object): rule options (not mandatory).
+    # *
+    # * Add new rule to chain after one with given name. See also
+    # * [[Ruler.before]], [[Ruler.push]].
+    # *
+    # * ##### Options:
+    # *
+    # * - __alt__ - array with names of "alternate" chains.
+    # *
+    # * ##### Example
+    # *
+    # * ```javascript
+    # * var md = require('markdown-it')();
+    # *
+    # * md.inline.ruler.after('text', 'my_rule', function replace(state) {
+    # *   //...
+    # * });
+    # * ```
+    #------------------------------------------------------------------------------
+    def after(afterName, ruleName, fn, opt = {})
+      index = __find__(afterName)
+
+      raise(StandardError, "Parser rule not found: #{afterName}") if index == -1
+
+      @__rules__.insert(index + 1, {
+        name: ruleName,
+        enabled: true,
+        fn: fn,
+        alt: (opt[:alt] || [''])
+      })
+
+      @__cache__ = nil
+    end
+
+    # * Ruler.push(ruleName, fn [, options])
+    # * - ruleName (String): name of added rule.
+    # * - fn (Function): rule function.
+    # * - options (Object): rule options (not mandatory).
+    # *
+    # * Push new rule to the end of chain. See also
+    # * [[Ruler.before]], [[Ruler.after]].
+    # *
+    # * ##### Options:
+    # *
+    # * - __alt__ - array with names of "alternate" chains.
+    # *
+    # * ##### Example
+    # *
+    # * ```javascript
+    # * var md = require('markdown-it')();
+    # *
+    # * md.core.ruler.push('emphasis', 'my_rule', function replace(state) {
+    # *   //...
+    # * });
+    # * ```
+    #------------------------------------------------------------------------------
+    def push(ruleName, fn, opt = {})
+      @__rules__.push({
+        name: ruleName,
+        enabled: true,
+        fn: fn,
+        alt: (opt[:alt] ? [''] + opt[:alt] : [''])
+      })
+      @__cache__ = nil
+    end
+
+
+    # * Ruler.enable(list [, ignoreInvalid]) -> Array
+    # * - list (String|Array): list of rule names to enable.
+    # * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+    # *
+    # * Enable rules with given names. If any rule name not found - throw Error.
+    # * Errors can be disabled by second param.
+    # *
+    # * Returns list of found rule names (if no exception happened).
+    # *
+    # * See also [[Ruler.disable]], [[Ruler.enableOnly]].
+    #------------------------------------------------------------------------------
+    def enable(list, ignoreInvalid = false)
+      list = [ list ] if !list.is_a?(Array)
+      result = []
+
+      # // Search by name and enable
+      list.each do |name|
+        idx = __find__(name)
+
+        if idx < 0
+          next if ignoreInvalid
+          raise(StandardError, "Rules manager: invalid rule name #{name}")
+        end
+        @__rules__[idx][:enabled] = true
+        result.push(name)
+      end
+
+      @__cache__ = nil
+      return result
+    end
+
+
+    # * Ruler.enableOnly(list [, ignoreInvalid])
+    # * - list (String|Array): list of rule names to enable (whitelist).
+    # * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+    # *
+    # * Enable rules with given names, and disable everything else. If any rule name
+    # * not found - throw Error. Errors can be disabled by second param.
+    # *
+    # * See also [[Ruler.disable]], [[Ruler.enable]].
+    #------------------------------------------------------------------------------
+    def enableOnly(list, ignoreInvalid = false)
+      list = [ list ] if !list.is_a?(Array)
+
+      @__rules__.each { |rule| rule[:enabled] = false }
+
+      enable(list, ignoreInvalid)
+    end
+
+
+    # * Ruler.disable(list [, ignoreInvalid]) -> Array
+    # * - list (String|Array): list of rule names to disable.
+    # * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+    # *
+    # * Disable rules with given names. If any rule name not found - throw Error.
+    # * Errors can be disabled by second param.
+    # *
+    # * Returns list of found rule names (if no exception happened).
+    # *
+    # * See also [[Ruler.enable]], [[Ruler.enableOnly]].
+    #------------------------------------------------------------------------------
+    def disable(list, ignoreInvalid = false)
+      list = [ list ] if !list.is_a?(Array)
+      result = []
+
+      # // Search by name and disable
+      list.each do |name|
+        idx = __find__(name)
+
+        if idx < 0
+          next if ignoreInvalid
+          raise(StandardError, "Rules manager: invalid rule name #{name}")
+        end
+        @__rules__[idx][:enabled] = false
+        result.push(name)
+      end
+
+      @__cache__ = nil
+      return result
+    end
+
+
+    # * Ruler.getRules(chainName) -> Array
+    # *
+    # * Return array of active functions (rules) for given chain name. It analyzes
+    # * rules configuration, compiles caches if not exists and returns result.
+    # *
+    # * Default chain name is `''` (empty string). It can't be skipped. That's
+    # * done intentionally, to keep signature monomorphic for high speed.
+    #------------------------------------------------------------------------------
+    def getRules(chainName)
+      if @__cache__ == nil
+        __compile__
+      end
+
+      # // Chain can be empty, if rules disabled. But we still have to return Array.
+      return @__cache__[chainName] || []
+    end
+  end
+end