kramdown 0.6.0 → 0.7.0

data/lib/kramdown/converter/base.rb

@@ -68,6 +68,20 @@ module Kramdown
         end
       end
 
+
+      # Generate an alpha-numeric ID from the the string +str+.
+      def generate_id(str)
+        gen_id = str.gsub(/[^a-zA-Z0-9 -]/, '').gsub(/^[^a-zA-Z]*/, '').gsub(' ', '-').downcase
+        gen_id = 'section' if gen_id.length == 0
+        @used_ids ||= {}
+        if @used_ids.has_key?(gen_id)
+          gen_id += '-' + (@used_ids[gen_id] += 1).to_s
+        else
+          @used_ids[gen_id] = 0
+        end
+        @doc.options[:auto_id_prefix] + gen_id
+      end
+
     end
 
   end

data/lib/kramdown/converter/html.rb

@@ -48,6 +48,8 @@ module Kramdown
         super
         @footnote_counter = @footnote_start = @doc.options[:footnote_nr]
         @footnotes = []
+        @toc = []
+        @toc_code = nil
       end
 
       def convert(el, indent = -INDENTATION, opts = {})
@@ -109,6 +111,11 @@ module Kramdown
       end
 
       def convert_header(el, indent, opts)
+        el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
+        if @doc.options[:auto_ids] && !(el.options[:attr] && el.options[:attr]['id'])
+          (el.options[:attr] ||= {})['id'] = generate_id(el.options[:raw_text])
+        end
+        @toc << [el.options[:level], el.options[:attr]['id'], el.children] if el.options[:attr] && el.options[:attr]['id']
         "#{' '*indent}<h#{el.options[:level]}#{options_for_element(el)}>#{inner(el, indent, opts)}</h#{el.options[:level]}>\n"
       end
 
@@ -117,7 +124,12 @@ module Kramdown
       end
 
       def convert_ul(el, indent, opts)
-        "#{' '*indent}<#{el.type}#{options_for_element(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</#{el.type}>\n"
+        if !@toc_code && (el.options[:ial][:refs].include?('toc') rescue nil) && (el.type == :ul || el.type == :ol)
+          @toc_code = [el.type, (0..128).to_a.map{|a| rand(36).to_s(36)}.join]
+          @toc_code.last
+        else
+          "#{' '*indent}<#{el.type}#{options_for_element(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</#{el.type}>\n"
+        end
       end
       alias :convert_ol :convert_ul
       alias :convert_dl :convert_ul
@@ -269,8 +281,58 @@ module Kramdown
         "<#{type}#{options_for_element(el)}>#{escape_html(el.value, :text)}</#{type}>#{type == 'div' ? "\n" : ''}"
       end
 
+      def convert_abbreviation(el, indent, opts)
+        title = @doc.parse_infos[:abbrev_defs][el.value]
+        title = nil if title.empty?
+        "<abbr#{title ? " title=\"#{title}\"" : ''}>#{el.value}</abbr>"
+      end
+
       def convert_root(el, indent, opts)
-        inner(el, indent, opts) << footnote_content
+        result = inner(el, indent, opts)
+        result << footnote_content
+        if @toc_code
+          toc_tree = generate_toc_tree(@toc, @toc_code.first)
+          text = if toc_tree.children.size > 0
+                   convert(toc_tree, 0)
+                 else
+                   ''
+                 end
+          result.sub!(/#{@toc_code.last}/, text)
+        end
+        result
+      end
+
+      def generate_toc_tree(toc, type)
+        sections = Element.new(type, nil, {:attr => {:id => 'markdown-toc'}})
+        stack = []
+        toc.each do |level, id, children|
+          li = Element.new(:li, nil, {:level => level})
+          a = Element.new(:a, nil, {:attr => {:href => "##{id}"}})
+          a.children += children
+          li.children << a
+          li.children << Element.new(type)
+
+          success = false
+          while !success
+            if stack.empty?
+              sections.children << li
+              stack << li
+              success = true
+            elsif stack.last.options[:level] < li.options[:level]
+              stack.last.children.last.children << li
+              stack << li
+              success = true
+            else
+              item = stack.pop
+              item.children.pop unless item.children.last.children.size > 0
+            end
+          end
+        end
+        while !stack.empty?
+          item = stack.pop
+          item.children.pop unless item.children.last.children.size > 0
+        end
+        sections
       end
 
       # Helper method for obfuscating the +text+ by using HTML entities.

data/lib/kramdown/converter/latex.rb

@@ -103,8 +103,9 @@ module Kramdown
       }
       def convert_header(el, opts)
         type = HEADER_TYPES[el.options[:level]]
-        if el.options[:attr] && (id = el.options[:attr]['id'])
-          "\\hypertarget{#{id}}{}\\#{type}*{#{inner(el, opts)}}\\label{#{id}}\n\n"
+        if (el.options[:attr] && (id = el.options[:attr]['id'])) ||
+            (@doc.options[:auto_ids] && (id = generate_id(el.options[:raw_text])))
+          "\\hypertarget{#{id}}{}\\#{type}{#{inner(el, opts)}}\\label{#{id}}\n\n"
         else
           "\\#{type}*{#{inner(el, opts)}}\n\n"
         end
@@ -115,12 +116,14 @@ module Kramdown
       end
 
       def convert_ul(el, opts)
-        latex_environment('itemize', inner(el, opts))
-      end
-
-      def convert_ol(el, opts)
-        latex_environment('enumerate', inner(el, opts))
+        if !@doc.conversion_infos[:has_toc] && (el.options[:ial][:refs].include?('toc') rescue nil)
+          @doc.conversion_infos[:has_toc] = true
+          '\tableofcontents'
+        else
+          latex_environment(el.type == :ul ? 'itemize' : 'enumerate', inner(el, opts))
+        end
       end
+      alias :convert_ol :convert_ul
 
       def convert_dl(el, opts)
         latex_environment('description', inner(el, opts))
@@ -514,6 +517,10 @@ EOF
         end
       end
 
+      def convert_abbreviation(el, indent, opts)
+        el.value
+      end
+
       ESCAPE_MAP = {
         "^"  => "\\^{}",
         "\\" => "\\textbackslash{}",

data/lib/kramdown/document.rb

@@ -91,9 +91,13 @@ module Kramdown
       @warnings = []
       @parse_infos = {}
       @conversion_infos = {}
-      @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]}")
+      parser = (options[:input] || 'kramdown').to_s
+      parser = parser[0..0].upcase + parser[1..-1]
+      if Parser.const_defined?(parser)
+        @tree = Parser.const_get(parser).parse(source, self)
+      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

data/lib/kramdown/options.rb

@@ -148,7 +148,19 @@ 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
+Used by: HTML/Latex converter
+EOF
+
+    define(:auto_id_prefix, String, '', <<EOF)
+Prefix used for automatically generated heaer IDs
+
+This option can be used to set a prefix for the automatically generated
+header IDs so that there is no conflict when rendering multiple kramdown
+documents into one output file separately. The prefix should only
+contain characters that are valid in an ID!
+
+Default: ''
+Used by: HTML/Latex converter
 EOF
 
     define(:parse_block_html, Boolean, false, <<EOF)

data/lib/kramdown/parser/kramdown.rb

@@ -31,6 +31,44 @@ module Kramdown
   module Parser
 
     # Used for parsing a document in kramdown format.
+    #
+    # If you want to extend the functionality of the parser, you need to the following:
+    #
+    # * Create a new subclass
+    # * add the needed parser methods
+    # * modify the @block_parsers and @span_parsers variables and add the names of your parser
+    #   methods
+    #
+    # Here is a small example for an extended parser class that parses ERB style tags as raw text if
+    # they are used as span level elements (an equivalent block level parser should probably also be
+    # made to handle the block case):
+    #
+    #   require 'kramdown/parser/kramdown'
+    #
+    #   class Kramdown::Parser::ERBKramdown < Kramdown::Parser::Kramdown
+    #
+    #      def initialize(doc)
+    #        super(doc)
+    #        @span_parsers.unshift(:erb_tags)
+    #      end
+    #
+    #      ERB_TAGS_START = /<%.*?%>/
+    #
+    #      def parse_erb_tags
+    #        @src.pos += @src.matched_size
+    #        @tree.children << Element.new(:raw, @src.matched)
+    #      end
+    #      define_parser(:erb_tags, ERB_TAGS_START, '<%')
+    #
+    #   end
+    #
+    # The new parser can be used like this:
+    #
+    #   require 'kramdown/document'
+    #   # require the file with the above parser class
+    #
+    #   Kramdown::Document.new(input_text, :input => 'ERBKramdown').to_html
+    #
     class Kramdown
 
       include ::Kramdown
@@ -48,10 +86,20 @@ module Kramdown
         @tree = nil
         @stack = []
         @text_type = :text
+        @block_ial = nil
 
         @doc.parse_infos[:ald] = {}
         @doc.parse_infos[:link_defs] = {}
+        @doc.parse_infos[:abbrev_defs] = {}
         @doc.parse_infos[:footnotes] = {}
+
+        @block_parsers = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :table, :atx_header,
+                          :setext_header, :horizontal_rule, :list, :definition_list, :link_definition, :block_html,
+                          :footnote_definition, :abbrev_definition, :ald, :block_math, :extension_block_depr,
+                          :block_extension, :block_ial, :eob_marker, :paragraph]
+        @span_parsers =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link, :smart_quotes, :inline_math,
+                         :span_extension, :span_ial, :html_entity, :typographic_syms, :line_break, :escaped_chars]
+
       end
       private_class_method(:new, :allocate)
 
@@ -67,6 +115,7 @@ module Kramdown
         tree = Element.new(:root)
         parse_blocks(tree, adapt_source(source))
         update_tree(tree)
+        replace_abbreviations(tree)
         @doc.parse_infos[:footnotes].each do |name, data|
           update_tree(data[:content])
         end
@@ -80,19 +129,13 @@ module Kramdown
       end
 
       #######
-      private
+      protected
       #######
 
-      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, :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.
       def configure_parser
         @parsers = {}
-        (BLOCK_PARSERS + SPAN_PARSERS).each do |name|
+        (@block_parsers + @span_parsers).each do |name|
           if self.class.has_parser?(name)
             @parsers[name] = self.class.parser(name)
           else
@@ -103,7 +146,7 @@ module Kramdown
       end
 
       # Create the needed span parser regexps.
-      def span_parser_regexps(parsers = SPAN_PARSERS)
+      def span_parser_regexps(parsers = @span_parsers)
         span_start = /#{parsers.map {|name| @parsers[name].span_start}.join('|')}/
         [span_start, /(?=#{span_start})/]
       end
@@ -115,7 +158,8 @@ module Kramdown
 
         status = catch(:stop_block_parsing) do
           while !@src.eos?
-            BLOCK_PARSERS.any? do |name|
+            block_ial_set = @block_ial
+            @block_parsers.any? do |name|
               if @src.check(@parsers[name].start_re)
                 send(@parsers[name].method)
               else
@@ -125,6 +169,7 @@ module Kramdown
               warning('Warning: this should not occur - no block parser handled the line')
               add_text(@src.scan(/.*\n/))
             end
+            @block_ial = nil if block_ial_set
           end
         end
 
@@ -157,7 +202,7 @@ module Kramdown
         span_start = @span_start
         span_start_re = @span_start_re
         span_start, span_start_re = span_parser_regexps(parsers) if parsers
-        parsers = parsers || SPAN_PARSERS
+        parsers = parsers || @span_parsers
 
         used_re = (stop_re.nil? ? span_start_re : /(?=#{Regexp.union(stop_re, span_start)})/)
         stop_re_found = false
@@ -211,20 +256,27 @@ module Kramdown
         ial.each {|k,v| attr[k] = v if k.kind_of?(String) && k != 'class' }
       end
 
+      # Create a new block level element, taking care of applying a preceding block IAL if it exists.
+      def new_block_el(*args)
+        el = Element.new(*args)
+        el.options[:ial] = @block_ial if @block_ial && el.type != :blank && el.type != :eob
+        el
+      end
+
       # Extract the part of the StringScanner backed string specified by the +range+. This method
       # also works correctly under Ruby 1.9.
-      def extract_string(range)
+      def extract_string(range, strscan = @src)
         result = nil
         if RUBY_VERSION >= '1.9'
           begin
-            enc = @src.string.encoding
-            @src.string.force_encoding('ASCII-8BIT')
-            result = @src.string[range].force_encoding(enc)
+            enc = strscan.string.encoding
+            strscan.string.force_encoding('ASCII-8BIT')
+            result = strscan.string[range].force_encoding(enc)
           ensure
-            @src.string.force_encoding(enc)
+            strscan.string.force_encoding(enc)
           end
         else
-          result = @src.string[range]
+          result = strscan.string[range]
         end
         result
       end
@@ -285,6 +337,7 @@ module Kramdown
       require 'kramdown/parser/kramdown/emphasis'
       require 'kramdown/parser/kramdown/smart_quotes'
       require 'kramdown/parser/kramdown/math'
+      require 'kramdown/parser/kramdown/abbreviation'
 
     end
 

data/lib/kramdown/parser/kramdown/abbreviation.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-2010 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
+
+      ABBREV_DEFINITION_START = /^#{OPT_SPACE}\*\[(.+?)\]:(.*?)\n/
+
+      # Parse the link definition at the current location.
+      def parse_abbrev_definition
+        @src.pos += @src.matched_size
+        abbrev_id, abbrev_text = @src[1], @src[2].strip
+        warning("Duplicate abbreviation ID '#{abbrev_id}' - overwriting") if @doc.parse_infos[:abbrev_defs][abbrev_id]
+        @doc.parse_infos[:abbrev_defs][abbrev_id] = abbrev_text
+        true
+      end
+      define_parser(:abbrev_definition, ABBREV_DEFINITION_START)
+
+      # Replace the abbreviation text with elements.
+      def replace_abbreviations(el, regexps = nil)
+        return if @doc.parse_infos[:abbrev_defs].empty?
+        if !regexps
+          regexps = [Regexp.union(*@doc.parse_infos[:abbrev_defs].keys.map {|k| /#{Regexp.escape(k)}/})]
+          regexps << /(?=(?:\W|^)#{regexps.first}(?!\w))/ # regexp should only match on word boundaries
+        end
+        el.children.map! do |child|
+          if child.type == :text
+            result = []
+            strscan = StringScanner.new(child.value)
+            while temp = strscan.scan_until(regexps.last)
+              temp += strscan.scan(/\W|^/)
+              abbr = strscan.scan(regexps.first)
+              result += [Element.new(:text, temp), Element.new(:abbreviation, abbr)]
+            end
+            result + [Element.new(:text, extract_string(strscan.pos..-1, strscan))]
+          else
+            replace_abbreviations(child, regexps)
+            child
+          end
+        end.flatten!
+      end
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/attribute_list.rb

@@ -74,6 +74,8 @@ module Kramdown
         @src.pos += @src.matched_size
         if @tree.children.last && @tree.children.last.type != :blank && @tree.children.last.type != :eob
           parse_attribute_list(@src[1], @tree.children.last.options[:ial] ||= {})
+        else
+          parse_attribute_list(@src[1], @block_ial = {})
         end
         true
       end
@@ -92,7 +94,6 @@ module Kramdown
           update_attr_with_ial(@tree.children.last.options[:attr] ||= {}, attr)
         else
           warning("Ignoring span IAL because preceding element is just text")
-          add_text(@src.matched)
         end
       end
       define_parser(:span_ial, IAL_SPAN_START, '\{:')