kramdown 0.5.0 → 0.6.0

data/doc/tests.page

@@ -39,7 +39,8 @@ BlueCloth and rdiscount:
 </code>
 </pre>
 
-And here are some graphs which show the execution times on different Ruby interpreters:
+And here are some graphs which show the execution times of the various kramdown releases on
+different Ruby interpreters:
 
 ![ruby 1.8.6]({relocatable: img/graph-ruby-1.8.6.png})
 ![ruby 1.8.7]({relocatable: img/graph-ruby-1.8.7.png})

data/lib/kramdown/converter/html.rb

@@ -206,14 +206,15 @@ module Kramdown
       end
 
       def convert_a(el, indent, opts)
-        if el.options[:attr]['href'] =~ /^mailto:/
+        do_obfuscation = el.options[:attr]['href'] =~ /^mailto:/
+        if do_obfuscation
           el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
           href = obfuscate(el.options[:attr]['href'].sub(/^mailto:/, ''))
           mailto = obfuscate('mailto')
           el.options[:attr]['href'] = "#{mailto}:#{href}"
         end
         res = inner(el, indent, opts)
-        res = obfuscate(res) if el.options[:obfuscate_text]
+        res = obfuscate(res) if do_obfuscation
         "<a#{options_for_element(el)}>#{res}</a>"
       end
 
@@ -258,6 +259,16 @@ module Kramdown
         "&#{el.value};"
       end
 
+      def convert_math(el, indent, opts)
+        el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
+        el.options[:attr] ||= {}
+        el.options[:attr]['class'] ||= ''
+        el.options[:attr]['class'] += (el.options[:attr]['class'].empty? ? '' : ' ') + 'math'
+        type = 'span'
+        type = 'div' if el.options[:type] == :block
+        "<#{type}#{options_for_element(el)}>#{escape_html(el.value, :text)}</#{type}>#{type == 'div' ? "\n" : ''}"
+      end
+
       def convert_root(el, indent, opts)
         inner(el, indent, opts) << footnote_content
       end
@@ -268,6 +279,7 @@ module Kramdown
         text.each_byte do |b|
           result += (b > 128 ? b.chr : "&#%03d;" % b)
         end
+        result.force_encoding(text.encoding) if RUBY_VERSION >= '1.9'
         result
       end
 

data/lib/kramdown/converter/latex.rb

@@ -20,6 +20,8 @@
 #++
 #
 
+require 'set'
+
 module Kramdown
 
   module Converter
@@ -35,7 +37,7 @@ module Kramdown
         super
         #TODO: set the footnote counter at the beginning of the document
         @doc.options[:footnote_nr]
-        @doc.conversion_infos[:packages] = []
+        @doc.conversion_infos[:packages] = Set.new
       end
 
       def convert(el, opts = {})
@@ -138,13 +140,16 @@ module Kramdown
 
       def convert_html_element(el, opts)
         @doc.warnings << "Can't convert HTML element"
+        ''
       end
 
       def convert_html_text(el, opts)
         @doc.warnings << "Can't convert HTML text"
+        ''
       end
 
       def convert_xml_comment(el, opts)
+        @doc.warnings << "Can't convert XML comment/PI"
         ''
       end
       alias :convert_xml_pi :convert_xml_comment
@@ -496,6 +501,19 @@ EOF
         SMART_QUOTE_SYMS[el.value]
       end
 
+      def convert_math(el, opts)
+        @doc.conversion_infos[:packages] += %w[amssymb amsmath amsthm amsfonts]
+        if el.options[:type] == :block
+          if el.value =~ /\A\s*\\begin\{/
+            el.value
+          else
+            latex_environment('displaymath', el.value)
+          end
+        else
+          "$#{el.value}$"
+        end
+      end
+
       ESCAPE_MAP = {
         "^"  => "\\^{}",
         "\\" => "\\textbackslash{}",

data/lib/kramdown/document.rb

@@ -54,7 +54,7 @@ module Kramdown
   # The #to_html method is a shortcut for using the Converter::Html class.
   #
   # The second argument to the #new method is an options hash for customizing the behaviour of the
-  # kramdown parser and the converters.
+  # used parser and the converter. See Document#new for more information!
   class Document
 
     # The element tree of the document. It is immediately available after the #new method has been
@@ -63,7 +63,7 @@ module Kramdown
 
     # The options hash which holds the options for parsing/converting the Kramdown document. It is
     # possible that these values get changed during the parsing phase.
-    attr_accessor :options
+    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.
@@ -73,25 +73,33 @@ module Kramdown
     attr_reader :parse_infos
 
     # Holds conversion information which is dependent on the used converter. A converter clears this
-    # variable before duing the conversion.
+    # variable before doing the conversion.
     attr_reader :conversion_infos
 
 
-    # Create a new Kramdown document from the string +source+ and use the provided +options+. The
-    # +source+ is immediately parsed by the kramdown parser sothat after this call the output can be
-    # generated.
+    # Create a new Kramdown document from the string +source+ and use the provided +options+.
+    #
+    # The special options key <tt>:input</tt> 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 <tt>:input</tt> key to +Kramdown+. If this key
+    # is not set, it defaults to +Kramdown+.
+    #
+    # The +source+ is immediately parsed by the selected parser so that after this call the document
+    # tree is available and the output can be generated.
     def initialize(source, options = {})
       @options = Options.merge(options)
       @warnings = []
       @parse_infos = {}
       @conversion_infos = {}
-      @tree = Parser::Kramdown.parse(source, self)
+      @tree = Parser.const_get((options[:input] || 'kramdown').to_s.capitalize).parse(source, self)
+    rescue NameError
+      raise Kramdown::Error.new("Invalid input format selected: #{options[:input]}")
     end
 
     # Check if a method is invoked that begins with +to_+ and if so, try to instantiate a converter
-    # class and use it for converting the document.
+    # class (i.e. a class in the Kramdown::Converter module) and use it for converting the document.
     #
-    # For example, +to_html+ would instantiate the Converter::Html class.
+    # For example, +to_html+ would instantiate the Kramdown::Converter::Html class.
     def method_missing(id, *attr, &block)
       if id.to_s =~ /^to_(\w+)$/
         Converter.const_get($1.capitalize).convert(self)

data/lib/kramdown/parser/kramdown.rb

@@ -85,8 +85,8 @@ module Kramdown
 
       BLOCK_PARSERS = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :table, :atx_header,
                        :setext_header, :horizontal_rule, :list, :definition_list, :link_definition, :block_html,
-                       :footnote_definition, :ald, :block_ial, :extension_block, :eob_marker, :paragraph]
-      SPAN_PARSERS =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link, :smart_quotes,
+                       :footnote_definition, :ald, :block_ial, :block_math, :extension_block, :eob_marker, :paragraph]
+      SPAN_PARSERS =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link, :smart_quotes, :inline_math,
                        :span_ial, :html_entity, :typographic_syms, :line_break, :escaped_chars]
 
       # Adapt the object to allow parsing like specified in the options.
@@ -151,7 +151,7 @@ module Kramdown
 
       # Parse all span level elements in the source string.
       def parse_spans(el, stop_re = nil, parsers = nil, text_type = :text)
-        @stack.push([@tree, @text_type])
+        @stack.push([@tree, @text_type]) unless @tree.nil?
         @tree, @text_type = el, text_type
 
         span_start = @span_start
@@ -284,6 +284,7 @@ module Kramdown
       require 'kramdown/parser/kramdown/codespan'
       require 'kramdown/parser/kramdown/emphasis'
       require 'kramdown/parser/kramdown/smart_quotes'
+      require 'kramdown/parser/kramdown/math'
 
     end
 

data/lib/kramdown/parser/kramdown/autolink.rb

@@ -24,14 +24,19 @@ module Kramdown
   module Parser
     class Kramdown
 
-      AUTOLINK_START = /<((mailto|https?|ftps?):.*?|\S*?@\S*?)>/
+      if RUBY_VERSION == '1.8.5'
+        ACHARS = '\x80-\xFF'
+      else
+        ACHARS = ''
+      end
+      AUTOLINK_START = /<((mailto|https?|ftps?):.+?|[-.\w#{ACHARS}]+@[-\w#{ACHARS}]+(\.[-\w#{ACHARS}]+)*\.[a-z]+)>/u
 
       # Parse the autolink at the current location.
       def parse_autolink
         @src.pos += @src.matched_size
         href = @src[1]
         href= "mailto:#{href}" if @src[2].nil?
-        el = Element.new(:a, nil, {:attr => {'href' => href}, :obfuscate_text => (@src[2].nil? || @src[2] == 'mailto')})
+        el = Element.new(:a, nil, {:attr => {'href' => href}})
         add_text(@src[1].sub(/^mailto:/, ''), el)
         @tree.children << el
       end

data/lib/kramdown/parser/kramdown/emphasis.rb

@@ -33,7 +33,8 @@ module Kramdown
         type = (result =~ /_/ ? '_' : '*')
         reset_pos = @src.pos
 
-        if (type == '_' && @src.pre_match =~ /[[:alpha:]]\z/ && @src.check(/[[:alpha:]]/)) || @src.check(/\s/)
+        if (type == '_' && @src.pre_match =~ /[[:alpha:]]\z/ && @src.check(/[[:alpha:]]/)) || @src.check(/\s/) ||
+            @tree.type == element || @stack.any? {|el, _| el.type == element}
           add_text(result)
           return
         end
@@ -50,7 +51,7 @@ module Kramdown
         end
 
         found, el, stop_re = sub_parse.call(result, element)
-        if !found && element == :strong
+        if !found && element == :strong && @tree.type != :em
           @src.pos = reset_pos - 1
           found, el, stop_re = sub_parse.call(type, :em)
         end

data/lib/kramdown/parser/kramdown/escaped_chars.rb

@@ -24,7 +24,7 @@ module Kramdown
   module Parser
     class Kramdown
 
-      ESCAPED_CHARS = /\\([\\.*_+`()\[\]{}#!:|"'-])/
+      ESCAPED_CHARS = /\\([\\.*_+`()\[\]{}#!:|"'\$-])/
 
       # Parse the backslash-escaped character at the current location.
       def parse_escaped_chars

data/lib/kramdown/parser/kramdown/list.rb

@@ -112,7 +112,8 @@ module Kramdown
           next if it.children.size == 0
 
           if it.children.first.type == :p && (it.children.length < 2 || it.children[1].type != :blank ||
-                                                (it == list.children.last && it.children.length == 2 && !eob_found))
+                                              (it == list.children.last && it.children.length == 2 && !eob_found)) &&
+              (list.children.last != it || list.children.size == 1 || list.children[0..-2].any? {|cit| cit.children.first.type != :p})
             text = it.children.shift.children.first
             text.value += "\n" if !it.children.empty? && it.children[0].type != :blank
             it.children.unshift(text)

data/lib/kramdown/parser/kramdown/math.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown.
+#
+# kramdown is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      BLOCK_MATH_START = /^#{OPT_SPACE}(\\)?\$\$(.*?)\$\$\s*?\n/m
+
+      # Parse the math block at the current location.
+      def parse_block_math
+        if @src[1]
+          @src.scan(/^#{OPT_SPACE}\\/)
+          return false
+        end
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:math, @src[2], :type => :block)
+        true
+      end
+      define_parser(:block_math, BLOCK_MATH_START)
+
+
+      INLINE_MATH_START = /\$\$(.*?)\$\$/
+
+      # Parse the inline math at the current location.
+      def parse_inline_math
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:math, @src[1], :type => :inline)
+      end
+      define_parser(:inline_math, INLINE_MATH_START, '\$')
+
+    end
+  end
+end

data/lib/kramdown/version.rb

@@ -23,6 +23,6 @@
 module Kramdown
 
   # The kramdown version.
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 
 end

data/man/man1/kramdown.1

@@ -0,0 +1,189 @@
+.TH "KRAMDOWN" 1 "February 2010"
+.SH NAME
+kramdown \- a fast, pure-Ruby Markdown-superset converter
+.SH SYNOPSIS
+.B kramdown
+[\fIoptions\fR]
+[\fIFILE\fR ...]
+.SH DESCRIPTION
+kramdown parses a superset of Markdown and converts it to different output formats. It is supports
+standard Markdown (with some minor modifications) and various extensions like tables and definition
+lists.
+
+If \fIFILE\fR is not specified, kramdown reads from the standard input. The result is written to the
+standard output.
+
+There are two sets of options that kramdown accepts: The first one includes the options that are
+used directly by the kramdown binary. The second set of options controls how kramdown parses and
+converts its input.
+.SH OPTIONS
+.TP
+.B \-f, \-\-format ARG
+Specify the output format. Available output formats: html (this is the default) or latex.
+.TP
+.B \-v, \-\-version
+Show the version of kramdown.
+.TP
+.B \-h, \-\-help
+Show the help.
+
+.SH KRAMDOWN OPTIONS
+
+.TP
+.B \-\-coderay_line_numbers ARG
+
+Defines how and if line numbers should be shown
+
+The possible values are :table, :inline, :list or nil. If this option is
+nil, no line numbers are shown.
+
+Default: :inline
+Used by: HTML converter
+
+
+.TP
+.B \-\-[no\-]parse_block_html
+
+Process kramdown syntax in block HTML tags
+
+If this option is `true`, the kramdown parser processes the content of
+block HTML tags as text containing block level elements. Since this is
+not wanted normally, the default is `false`. It is normally better to
+selectively enable kramdown processing via the markdown attribute.
+
+Default: false
+Used by: kramdown parser
+
+
+.TP
+.B \-\-coderay_line_number_start ARG
+
+The start value for the line numbers
+
+Default: 1
+Used by: HTML converter
+
+
+.TP
+.B \-\-[no\-]parse_span_html
+
+Process kramdown syntax in span HTML tags
+
+If this option is `true`, the kramdown parser processes the content of
+span HTML tags as text containing span level elements.
+
+Default: true
+Used by: kramdown parser
+
+
+.TP
+.B \-\-coderay_tab_width ARG
+
+The tab width used in highlighted code
+
+Used by: HTML converter
+
+
+.TP
+.B \-\-footnote_nr ARG
+
+The number of the first footnote
+
+This option can be used to specify the number that is used for the first
+footnote.
+
+Default: 1
+Used by: HTML converter
+
+
+.TP
+.B \-\-coderay_bold_every ARG
+
+Defines how often a line number should be made bold
+
+Default: 10
+Used by: HTML converter
+
+
+.TP
+.B \-\-filter_html ARG
+
+An array of HTML tags that should be filtered from the output
+
+The value can either be specified as array or as a space separated
+string (which will be converted to an array). All HTML tags that are
+listed in the array will be filtered from the output, i.e. only their
+contents is used. This applies only to HTML tags found in the initial
+document.
+
+Default: []
+Used by: HTML converter
+
+
+.TP
+.B \-\-coderay_css ARG
+
+Defines how the highlighted code gets styled
+
+Possible values are :class (CSS classes are applied to the code
+elements, one must supply the needed CSS file) or :style (default CSS
+styles are directly applied to the code elements).
+
+Default: style
+Used by: HTML converter
+
+
+.TP
+.B \-\-template ARG
+
+The name of an ERB template file that should be used to wrap the output
+
+This is used to wrap the output in an environment so that the output can
+be used as a stand-alone document. For example, an HTML template would
+provide the needed header and body tags so that the whole output is a
+valid HTML file. If no template is specified, the output will be just
+the converted text.
+
+When resolving the template file, the given template name is used first.
+If such a file is not found, the converter extension is appended. If the
+file still cannot be found, the templates name is interpreted as a
+template name that is provided by kramdown (without the converter
+extension).
+
+kramdown provides a default template named 'default' for each converter.
+
+Default: ''
+Used by: all converters
+
+
+.TP
+.B \-\-coderay_wrap ARG
+
+Defines how the highlighted code should be wrapped
+
+The possible values are :span, :div or nil.
+
+Default: :div
+Used by: HTML converter
+
+
+.TP
+.B \-\-[no\-]auto_ids
+
+Use automatic header ID generation
+
+If this option is `true`, ID values for all headers are automatically
+generated if no ID is explicitly specified.
+
+Default: true
+Used by: kramdown parser
+
+
+.SH SEE ALSO
+The kramdown website, http://kramdown.rubyforge.org/ for more information, especially on the support
+input syntax.
+.SH AUTHOR
+kramdown was written by Thomas Leitner <t_leitner@gmx.at>.
+.PP
+This manual page was written by Thomas Leitner <t_leitner@gmx.at>.
+