motion-kramdown 0.5.0

data/lib/kramdown/converter/syntax_highlighter/coderay.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+module Kramdown::Converter::SyntaxHighlighter
+
+  # Uses Coderay to highlight code blocks and code spans.
+  module Coderay
+
+    begin
+      # RM require 'coderay'
+
+      # Highlighting via coderay is available if this constant is +true+.
+      # RM AVAILABLE = true
+    # RM rescue LoadError
+      AVAILABLE = false  # :nodoc:
+    end
+
+    def self.call(converter, text, lang, type, _unused_opts)
+      return nil unless converter.options[:enable_coderay]
+
+      if type == :span && lang
+        ::CodeRay.scan(text, lang.to_sym).html(options(converter, :span)).chomp
+      elsif type == :block && (lang || options(converter, :default_lang))
+        lang = (lang || options(converter, :default_lang)).to_sym
+        ::CodeRay.scan(text, lang).html(options(converter, :block)).chomp << "\n"
+      else
+        nil
+      end
+    end
+
+    def self.options(converter, type)
+      prepare_options(converter)
+      converter.data[:syntax_highlighter_coderay][type]
+    end
+
+    def self.prepare_options(converter)
+      return if converter.data.key?(:syntax_highlighter_coderay)
+
+      cache = converter.data[:syntax_highlighter_coderay] = {}
+
+      opts = converter.options[:syntax_highlighter_opts].dup
+      span_opts = (opts.delete(:span) || {}).dup
+      block_opts = (opts.delete(:block) || {}).dup
+      [span_opts, block_opts].each do |hash|
+        hash.keys.each do |k|
+          hash[k.kind_of?(String) ? Kramdown::Options.str_to_sym(k) : k] = hash.delete(k)
+        end
+      end
+
+      cache[:default_lang] = converter.options[:coderay_default_lang] || opts.delete(:default_lang)
+      cache[:span] = {
+        :css => converter.options[:coderay_css]
+      }.update(opts).update(span_opts).update(:wrap => :span)
+      cache[:block] = {
+        :wrap => converter.options[:coderay_wrap],
+        :line_numbers => converter.options[:coderay_line_numbers],
+        :line_number_start => converter.options[:coderay_line_number_start],
+        :tab_width => converter.options[:coderay_tab_width],
+        :bold_every => converter.options[:coderay_bold_every],
+        :css => converter.options[:coderay_css]
+      }.update(opts).update(block_opts)
+
+      [:css, :wrap, :line_numbers].each do |key|
+        [:block, :span].each do |type|
+          cache[type][key] = cache[type][key].to_sym if cache[type][key].kind_of?(String)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/kramdown/converter/syntax_highlighter/rouge.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+module Kramdown::Converter::SyntaxHighlighter
+
+  # Uses Rouge which is CSS-compatible to Pygments to highlight code blocks and code spans.
+  module Rouge
+
+    begin
+      # RM require 'rouge'
+
+      # Highlighting via Rouge is available if this constant is +true+.
+      # RM AVAILABLE = true
+    # RM rescue LoadError, SyntaxError
+      AVAILABLE = false  # :nodoc:
+    end
+
+    def self.call(converter, text, lang, type, _unused_opts)
+      opts = converter.options[:syntax_highlighter_opts].dup
+      lexer = ::Rouge::Lexer.find_fancy(lang || opts[:default_lang], text)
+      return nil unless lexer
+
+      opts[:wrap] = false if type == :span
+
+      formatter = ::Rouge::Formatters::HTML.new(opts)
+      formatter.format(lexer.lex(text))
+    end
+
+  end
+
+end

data/lib/kramdown/converter/toc.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+# RM require 'rexml/parsers/baseparser'
+
+module Kramdown
+
+  module Converter
+
+    # Converts a Kramdown::Document to an element tree that represents the table of contents.
+    #
+    # The returned tree consists of Element objects of type :toc where the root element is just used
+    # as container object. Each :toc element contains as value the wrapped :header element and under
+    # the attribute key :id the header ID that should be used (note that this ID may not exist in
+    # the wrapped element).
+    #
+    # Since the TOC tree consists of special :toc elements, one cannot directly feed this tree to
+    # other converters!
+    class Toc < Base
+
+      def initialize(root, options)
+        super
+        @toc = Element.new(:toc)
+        @stack = []
+        @options[:template] = ''
+      end
+
+      def convert(el)
+        if el.type == :header && in_toc?(el)
+          attr = el.attr.dup
+          attr['id'] = generate_id(el.options[:raw_text]) if @options[:auto_ids] && !attr['id']
+          add_to_toc(el, attr['id']) if attr['id']
+        else
+          el.children.each {|child| convert(child)}
+        end
+        @toc
+      end
+
+      private
+
+      def add_to_toc(el, id)
+        toc_element = Element.new(:toc, el, :id => id)
+
+        success = false
+        while !success
+          if @stack.empty?
+            @toc.children << toc_element
+            @stack << toc_element
+            success = true
+          elsif @stack.last.value.options[:level] < el.options[:level]
+            @stack.last.children << toc_element
+            @stack << toc_element
+            success = true
+          else
+            @stack.pop
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/kramdown/converter.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+# RM require 'kramdown/utils'
+
+module Kramdown
+
+  # This module contains all available converters, i.e. classes that take a root Element and convert
+  # it to a specific output format. The result is normally a string. For example, the
+  # Converter::Html module converts an element tree into valid HTML.
+  #
+  # Converters use the Base class for common functionality (like applying a template to the output)
+  # \- see its API documentation for how to create a custom converter class.
+  module Converter
+
+    # RM autoload :Base, 'kramdown/converter/base'
+    # RM autoload :Html, 'kramdown/converter/html'
+    # RM autoload :Latex, 'kramdown/converter/latex'
+    # RM autoload :Kramdown, 'kramdown/converter/kramdown'
+    # RM autoload :Toc, 'kramdown/converter/toc'
+    # RM autoload :RemoveHtmlTags, 'kramdown/converter/remove_html_tags'
+    # RM autoload :Pdf, 'kramdown/converter/pdf'
+
+    extend ::Kramdown::Utils::Configurable
+
+    configurable(:syntax_highlighter)
+
+    # RM ["Coderay", "Rouge"].each do |klass_name|
+    # RM   kn_down = klass_name.downcase.intern
+    # RM   add_syntax_highlighter(kn_down) do |converter, text, lang, type, opts|
+    # RM     require "kramdown/converter/syntax_highlighter/#{kn_down}"
+    # RM     klass = ::Kramdown::Utils.deep_const_get("::Kramdown::Converter::SyntaxHighlighter::#{klass_name}")
+    # RM     if klass::AVAILABLE
+    # RM       add_syntax_highlighter(kn_down, klass)
+    # RM     else
+    # RM       add_syntax_highlighter(kn_down) {|*args| nil}
+    # RM     end
+    # RM     syntax_highlighter(kn_down).call(converter, text, lang, type, opts)
+    # RM   end
+    # RM end
+    # RM 
+    # RM configurable(:math_engine)
+    # RM 
+    # RM require 'kramdown/converter/math_engine/mathjax'
+    # RM add_math_engine(:mathjax, ::Kramdown::Converter::MathEngine::Mathjax)
+    # RM 
+    # RM ["Ritex", "Itex2MML"].each do |klass_name|
+    # RM   kn_down = klass_name.downcase.intern
+    # RM   add_math_engine(kn_down) do |converter, el, opts|
+    # RM     require "kramdown/converter/math_engine/#{kn_down}"
+    # RM     klass = ::Kramdown::Utils.deep_const_get("::Kramdown::Converter::MathEngine::#{klass_name}")
+    # RM     if klass::AVAILABLE
+    # RM       add_math_engine(kn_down, klass)
+    # RM     else
+    # RM       add_math_engine(kn_down) {|*args| nil}
+    # RM     end
+    # RM     math_engine(kn_down).call(converter, el, opts)
+    # RM   end
+    # RM end
+
+  end
+
+end

data/lib/kramdown/document.rb

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2014 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+# = kramdown
+#
+# kramdown is yet-another-markdown-parser but fast, pure Ruby, using a strict syntax definition and
+# supporting several common extensions.
+#
+# The kramdown library is mainly written to support the kramdown-to-HTML conversion chain. However,
+# due to its flexibility it supports other input and output formats as well. Here is a list of the
+# supported formats:
+#
+# * input formats: kramdown (a Markdown superset), Markdown, HTML
+# * output formats: HTML, kramdown, LaTeX (and therefore PDF)
+#
+# All the documentation on the available input and output formats is available at
+# http://kramdown.gettalong.org.
+#
+# == Usage
+#
+# kramdown has a basic *Cloth API, so using kramdown is as easy as
+#
+#     require 'kramdown'
+#
+#     Kramdown::Document.new(text).to_html
+#
+# For detailed information have a look at the Kramdown::Document class.
+#
+# == License
+#
+# MIT - see the COPYING file.
+
+
+# RM require 'kramdown/compatibility'
+#
+# RM require 'kramdown/version'
+# RM require 'kramdown/element'
+# RM require 'kramdown/error'
+# RM require 'kramdown/parser'
+# RM require 'kramdown/converter'
+# RM require 'kramdown/options'
+# RM require 'kramdown/utils'
+
+module Kramdown
+
+  # Return the data directory for kramdown.
+  def self.data_dir
+    unless defined?(@@data_dir)
+      # RM require 'rbconfig'
+      @@data_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'kramdown'))
+      @@data_dir = File.expand_path(File.join(Config::CONFIG["datadir"], "kramdown")) if !File.exists?(@@data_dir)
+      raise "kramdown data directory not found! This is a bug, please report it!" unless File.directory?(@@data_dir)
+    end
+    @@data_dir
+  end
+
+
+  # The main interface to kramdown.
+  #
+  # This class provides a one-stop-shop for using kramdown to convert text into various output
+  # formats. Use it like this:
+  #
+  #   require 'kramdown'
+  #   doc = Kramdown::Document.new('This *is* some kramdown text')
+  #   puts doc.to_html
+  #
+  # The #to_html method is a shortcut for using the Converter::Html class. See #method_missing for
+  # more information.
+  #
+  # The second argument to the ::new method is an options hash for customizing the behaviour of the
+  # used parser and the converter. See ::new for more information!
+  class Document
+
+    # The root Element of the element tree. It is immediately available after the ::new method has
+    # been called.
+    attr_accessor :root
+
+    # The options hash which holds the options for parsing/converting the Kramdown document.
+    attr_reader :options
+
+    # An array of warning messages. It is filled with warnings during the parsing phase (i.e. in
+    # ::new) and the conversion phase.
+    attr_reader :warnings
+
+
+    # Create a new Kramdown document from the string +source+ and use the provided +options+. The
+    # options that can be used are defined in the Options module.
+    #
+    # The special options key :input can be used to select the parser that should parse the
+    # +source+. It has to be the name of a class in the Kramdown::Parser module. For example, to
+    # select the kramdown parser, one would set the :input key to +Kramdown+. If this key is not
+    # set, it defaults to +Kramdown+.
+    #
+    # The +source+ is immediately parsed by the selected parser so that the root element is
+    # immediately available and the output can be generated.
+    def initialize(source, options = {})
+      @options = Options.merge(options).freeze
+      parser = (options[:input] || 'kramdown').to_s
+      parser = parser[0..0].upcase + parser[1..-1]
+      try_require('parser', parser)
+      if Parser.const_defined?(parser)
+        @root, @warnings = Parser.const_get(parser).parse(source, @options)
+      else
+        raise Kramdown::Error.new("kramdown has no parser to handle the specified input format: #{options[:input]}")
+      end
+    end
+
+    # Check if a method is invoked that begins with +to_+ and if so, try to instantiate a converter
+    # class (i.e. a class in the Kramdown::Converter module) and use it for converting the document.
+    #
+    # For example, +to_html+ would instantiate the Kramdown::Converter::Html class.
+    def method_missing(id, *attr, &block)
+      if id.to_s =~ /^to_(\w+)$/ && (name = Utils.camelize($1)) &&
+          try_require('converter', name) && Converter.const_defined?(name)
+        output, warnings = Converter.const_get(name).convert(@root, @options)
+        @warnings.concat(warnings)
+        output
+      else
+        super
+      end
+    end
+
+    def inspect #:nodoc:
+      "<KD:Document: options=#{@options.inspect} root=#{@root.inspect} warnings=#{@warnings.inspect}>"
+    end
+
+    # Try requiring a parser or converter class and don't raise an error if the file is not found.
+    def try_require(type, name)
+    # RM  require("kramdown/#{type}/#{Utils.snake_case(name)}")
+    # RM  true
+    # RM rescue LoadError
+      true
+    end
+    protected :try_require
+
+  end
+
+end
+