kramdown 0.2.0 → 0.3.0

data/lib/kramdown/parser/kramdown/header.rb

@@ -0,0 +1,81 @@
+# -*- 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
+
+      # 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
+        gen_id
+      end
+
+      HEADER_ID=/(?:[ \t]\{#((?:\w|\d)[\w\d-]*)\})?/
+      SETEXT_HEADER_START = /^(#{OPT_SPACE}[^ \t].*?)#{HEADER_ID}[ \t]*?\n(-|=)+\s*?\n/
+
+      # Parse the Setext header at the current location.
+      def parse_setext_header
+        if @tree.children.last && @tree.children.last.type != :blank
+          return false
+        end
+        @src.pos += @src.matched_size
+        text, id, level = @src[1].strip, @src[2], @src[3]
+        el = Element.new(:header, nil, :level => (level == '-' ? 2 : 1))
+        add_text(text, el)
+        el.options[:attr] = {'id' => id} if id
+        el.options[:attr] = {'id' => generate_id(text)} if @doc.options[:auto_ids] && !id
+        @tree.children << el
+        true
+      end
+      define_parser(:setext_header, SETEXT_HEADER_START)
+
+
+      ATX_HEADER_START = /^\#{1,6}/
+      ATX_HEADER_MATCH = /^(\#{1,6})(.+?)\s*?#*#{HEADER_ID}\s*?\n/
+
+      # Parse the Atx header at the current location.
+      def parse_atx_header
+        if @tree.children.last && @tree.children.last.type != :blank
+          return false
+        end
+        result = @src.scan(ATX_HEADER_MATCH)
+        level, text, id = @src[1], @src[2].strip, @src[3]
+        el = Element.new(:header, nil, :level => level.length)
+        add_text(text, el)
+        el.options[:attr] = {'id' => id} if id
+        el.options[:attr] = {'id' => generate_id(text)} if @doc.options[:auto_ids] && !id
+        @tree.children << el
+        true
+      end
+      define_parser(:atx_header, ATX_HEADER_START)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/horizontal_rule.rb

@@ -0,0 +1,39 @@
+# -*- 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
+
+      HR_START = /^#{OPT_SPACE}(\*|-|_)[ \t]*\1[ \t]*\1[ \t]*(\1|[ \t])*\n/
+
+      # Parse the horizontal rule at the current location.
+      def parse_horizontal_rule
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:hr)
+        true
+      end
+      define_parser(:horizontal_rule, HR_START)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/html.rb

@@ -0,0 +1,253 @@
+# -*- 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/>.
+#++
+#
+
+require 'rexml/parsers/baseparser'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      #:stopdoc:
+      # The following regexps are based on the ones used by REXML, with some slight modifications.
+      #:startdoc:
+      HTML_COMMENT_RE = /<!--(.*?)-->/m
+      HTML_INSTRUCTION_RE = /<\?(.*?)\?>/m
+      HTML_ATTRIBUTE_RE = /\s*(#{REXML::Parsers::BaseParser::UNAME_STR})\s*=\s*(["'])(.*?)\2/m
+      HTML_TAG_RE = /<((?>#{REXML::Parsers::BaseParser::UNAME_STR}))\s*((?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}\s*=\s*(["']).*?\3)*)\s*(\/)?>/m
+      HTML_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::NAME_STR})\s*>/m
+
+
+      HTML_PARSE_AS_BLOCK = %w{applet button blockquote colgroup dd div dl fieldset form iframe li
+                               map noscript object ol table tbody td th thead tfoot tr ul}
+      HTML_PARSE_AS_SPAN  = %w{a abbr acronym address b bdo big cite caption code del dfn dt em
+                               h1 h2 h3 h4 h5 h6 i ins kbd label legend optgroup p pre q rb rbc
+                               rp rt rtc ruby samp select small span strong sub sup tt var}
+      HTML_PARSE_AS_RAW   = %w{script math option textarea}
+
+      HTML_PARSE_AS = Hash.new {|h,k| h[k] = :raw}
+      HTML_PARSE_AS_BLOCK.each {|i| HTML_PARSE_AS[i] = :block}
+      HTML_PARSE_AS_SPAN.each {|i| HTML_PARSE_AS[i] = :span}
+      HTML_PARSE_AS_RAW.each {|i| HTML_PARSE_AS[i] = :raw}
+
+      #:stopdoc:
+      # Some HTML elements like script belong to both categories (i.e. are valid in block and
+      # span HTML) and don't appear therefore!
+      #:startdoc:
+      HTML_SPAN_ELEMENTS = %w{a abbr acronym b big bdo br button cite code del dfn em i img input
+                              ins kbd label option q rb rbc rp rt rtc ruby samp select small span
+                              strong sub sup textarea tt var}
+      HTML_BLOCK_ELEMENTS = %w{address applet button blockquote caption col colgroup dd div dl dt fieldset
+                               form h1 h2 h3 h4 h5 h6 hr iframe legend li map ol optgroup p pre table tbody
+                               td th thead tfoot tr ul}
+      HTML_ELEMENTS_WITHOUT_BODY = %w{area br col hr img input}
+
+      HTML_BLOCK_START = /^#{OPT_SPACE}<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
+      HTML_RAW_START = /(?=<(#{REXML::Parsers::BaseParser::UNAME_STR}|\/))/
+
+      # Parse the HTML at the current position as block level HTML.
+      def parse_block_html
+        if result = @src.scan(HTML_COMMENT_RE)
+          @tree.children << Element.new(:xml_comment, result, :type => :block)
+          @src.scan(/[ \t]*\n/)
+          true
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, :type => :block)
+          @src.scan(/[ \t]*\n/)
+          true
+        else
+          if result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
+            @src.pos += @src.matched_size
+            handle_html_start_tag
+            true
+          elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
+            @src.pos += @src.matched_size
+            name = @src[1]
+
+            if @tree.type ==:html_element && @tree.value == name
+              throw :stop_block_parsing, :found
+            else
+              warning("Found invalidly used HTML closing tag for '#{name}' - ignoring it")
+              true
+            end
+          else
+            false
+          end
+        end
+      end
+      define_parser(:block_html, HTML_BLOCK_START)
+
+
+      # Return the HTML parse type defined by the string +val+, i.e. raw when "0", default parsing
+      # (return value +nil+) when "1", span parsing when "span" and block parsing when "block". If
+      # +val+ is nil, then the default parsing mode is used.
+      def get_parse_type(val)
+        case val
+        when "0" then :raw
+        when "1" then :default
+        when "span" then :span
+        when "block" then :block
+        when NilClass then nil
+        else
+          warning("Invalid markdown attribute val '#{val}', using default")
+          nil
+        end
+      end
+
+      # Process the HTML start tag that has already be scanned/checked.
+      def handle_html_start_tag
+        curpos = @src.pos
+        name = @src[1]
+        closed = !@src[4].nil?
+        attrs = {}
+        @src[2].scan(HTML_ATTRIBUTE_RE).each {|attr,sep,val| attrs[attr] = val}
+
+        parse_type = if @tree.type != :html_element || @tree.options[:parse_type] != :raw
+                       (@doc.options[:parse_block_html] ? HTML_PARSE_AS[name] : :raw)
+                     else
+                       :raw
+                     end
+        if val = get_parse_type(attrs.delete('markdown'))
+          parse_type = (val == :default ? HTML_PARSE_AS[name] : val)
+        end
+
+        @src.scan(/[ \t]*\n/) if parse_type == :block
+
+        el = Element.new(:html_element, name, :attr => attrs, :type => :block, :parse_type => parse_type)
+        el.options[:outer_element] = true if @tree.type != :html_element
+        el.options[:parent_is_raw] = true if @tree.type == :html_element && @tree.options[:parse_type] == :raw
+        @tree.children << el
+
+        if !closed && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
+          warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
+        elsif !closed
+          if parse_type == :block
+            end_tag_found = parse_blocks(el)
+            if !end_tag_found
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+            end
+          elsif parse_type == :span
+            if result = @src.scan_until(/(?=<\/#{el.value}\s*>)/m)
+              add_text(@src.string[curpos...@src.pos], el)
+              @src.scan(HTML_TAG_CLOSE_RE)
+            else
+              add_text(@src.scan(/.*/m), el)
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+            end
+          else
+            parse_raw_html(el)
+          end
+          @src.scan(/[ \t]*\n/) unless (@tree.type == :html_element && @tree.options[:parse_type] == :raw)
+        end
+      end
+
+      # Parse raw HTML until the matching end tag for +el+ is found or until the end of the
+      # document.
+      def parse_raw_html(el)
+        @stack.push(@tree)
+        @tree = el
+
+        done = false
+        endpos = nil
+        while !@src.eos? && !done
+          if result = @src.scan_until(HTML_RAW_START)
+            endpos = @src.pos
+            add_text(result, @tree, :html_text)
+            if @src.scan(HTML_TAG_RE)
+              handle_html_start_tag
+            elsif @src.scan(HTML_TAG_CLOSE_RE)
+              if @tree.value == @src[1]
+                done = true
+              else
+                warning("Found invalidly used HTML closing tag for '#{@src[1]}' - ignoring it")
+              end
+            else
+              add_text(@src.scan(/./), @tree, :html_text)
+            end
+          else
+            result = @src.scan(/.*/m)
+            add_text(result, @tree, :html_text)
+            warning("Found no end tag for '#{@tree.value}' - auto-closing it")
+            done = true
+          end
+        end
+
+        @tree = @stack.pop
+        endpos
+      end
+
+
+      HTML_SPAN_START = /<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
+
+      # Parse the HTML at the current position as span level HTML.
+      def parse_span_html
+        if result = @src.scan(HTML_COMMENT_RE)
+          @tree.children << Element.new(:xml_comment, result, :type => :span)
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, :type => :span)
+        elsif result = @src.scan(HTML_TAG_CLOSE_RE)
+          warning("Found invalidly used HTML closing tag for '#{@src[1]}' - ignoring it")
+        elsif result = @src.scan(HTML_TAG_RE)
+          return if HTML_BLOCK_ELEMENTS.include?(@src[1])
+
+          reset_pos = @src.pos
+          attrs = {}
+          @src[2].scan(HTML_ATTRIBUTE_RE).each {|name,sep,val| attrs[name] = val.gsub(/\n+/, ' ')}
+
+          do_parsing = (HTML_PARSE_AS_RAW.include?(@src[1]) ? false : @doc.options[:parse_span_html])
+          if val = get_parse_type(attrs.delete('markdown'))
+            if val == :block
+              warning("Cannot use block level parsing in span level HTML tag - using default mode")
+            elsif val == :span
+              do_parsing = true
+            elsif val == :default
+              (HTML_PARSE_AS_RAW.include?(@src[1]) ? false : true)
+            elsif val == :raw
+              do_parsing = false
+            end
+          end
+
+          el = Element.new(:html_element, @src[1], :attr => attrs, :type => :span)
+          stop_re = /<\/#{Regexp.escape(@src[1])}\s*>/
+          if @src[4]
+            @tree.children << el
+          elsif HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
+            warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
+            @tree.children << el
+          else
+            if parse_spans(el, stop_re, (do_parsing ? nil : [:span_html]), (do_parsing ? :text : :html_text))
+              end_pos = @src.pos
+              @src.scan(stop_re)
+            else
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+              add_text(@src.scan(/.*/m))
+            end
+            @tree.children << el
+          end
+        else
+          add_text(@src.scan(/./))
+        end
+      end
+      define_parser(:span_html, HTML_SPAN_START)
+
+    end
+  end
+end

data/lib/kramdown/{deprecated.rb → parser/kramdown/html_entity.rb}

@@ -20,22 +20,20 @@
 #++
 #
 
+require 'rexml/parsers/baseparser'
+
 module Kramdown
+  module Parser
+    class Kramdown
 
-  class Extension
+      # Parse the HTML entity at the current location.
+      def parse_html_entity
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:entity, @src.matched)
+      end
+      define_parser(:html_entity, REXML::Parsers::BaseParser::REFERENCE_RE)
 
-    def parse_nokramdown(parser, opts, body)
-      warn("The extension 'nokramdown' is deprecated and has been renamed to 'nomarkdown'")
-      parse_nomarkdown(parser, opts, body)
-    end
 
-    def parse_kdoptions(parser, opts, body)
-      warn("The extension 'kdoptions' is deprecated and has been renamed to 'options'")
-      parse_options(parser, opts, body)
     end
-
   end
-
 end
-
-

data/lib/kramdown/parser/kramdown/line_break.rb

@@ -0,0 +1,38 @@
+# -*- 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
+
+      LINE_BREAK = /(  |\\\\)(?=\n)/
+
+      # Parse the line break at the current location.
+      def parse_line_break
+        @src.pos += @src.matched_size
+        @tree.children << Element.new(:br)
+      end
+      define_parser(:line_break, LINE_BREAK)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/link.rb

@@ -0,0 +1,153 @@
+# -*- 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
+
+      PUNCTUATION_CHARS = "_.:,;!?-"
+      LINK_ID_CHARS = /[a-zA-Z0-9 #{PUNCTUATION_CHARS}]/
+      LINK_ID_NON_CHARS = /[^a-zA-Z0-9 #{PUNCTUATION_CHARS}]/
+      LINK_DEFINITION_START = /^#{OPT_SPACE}\[(#{LINK_ID_CHARS}+)\]:[ \t]*(?:<(.*?)>|([^\s]+))[ \t]*?(?:\n?[ \t]*?(["'])(.+?)\4[ \t]*?)?\n/
+
+      # Parse the link definition at the current location.
+      def parse_link_definition
+        @src.pos += @src.matched_size
+        link_id, link_url, link_title = @src[1].downcase, @src[2] || @src[3], @src[5]
+        warning("Duplicate link ID '#{link_id}' - overwriting") if @doc.parse_infos[:link_defs][link_id]
+        @doc.parse_infos[:link_defs][link_id] = [link_url, link_title]
+        true
+      end
+      define_parser(:link_definition, LINK_DEFINITION_START)
+
+
+      # This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
+      # and the element itself to the <tt>@tree</tt>.
+      def add_link(el, href, title, alt_text = nil)
+        el.options[:attr] ||= {}
+        el.options[:attr]['title'] = title if title
+        if el.type == :a
+          el.options[:attr]['href'] = href
+        else
+          el.options[:attr]['src'] = href
+          el.options[:attr]['alt'] = alt_text
+          el.children.clear
+        end
+        @tree.children << el
+      end
+
+      LINK_TEXT_BRACKET_RE = /\\\[|\\\]|\[|\]/
+      LINK_INLINE_ID_RE = /\s*?\[(#{LINK_ID_CHARS}+)?\]/
+      LINK_INLINE_TITLE_RE = /\s*?(["'])(.+?)\1\s*?\)/
+      LINK_START = /!?\[(?=[^^])/
+
+      # Parse the link at the current scanner position. This method is used to parse normal links as
+      # well as image links.
+      def parse_link
+        result = @src.scan(LINK_START)
+        reset_pos = @src.pos
+
+        link_type = (result =~ /^!/ ? :img : :a)
+
+        # no nested links allowed
+        if link_type == :a && (@tree.type == :img || @tree.type == :a || @stack.any? {|t,s| t && (t.type == :img || t.type == :a)})
+          add_text(result)
+          return
+        end
+        el = Element.new(link_type)
+
+        stop_re = /\]|!?\[/
+        count = 1
+        found = parse_spans(el, stop_re) do
+          case @src.matched
+          when "[", "!["
+            count += 1
+          when "]"
+            count -= 1
+          end
+          count - el.children.select {|c| c.type == :img}.size == 0
+        end
+        if !found || el.children.empty?
+          @src.pos = reset_pos
+          add_text(result)
+          return
+        end
+        alt_text = @src.string[reset_pos...@src.pos]
+        conv_link_id = alt_text.gsub(/(\s|\n)+/m, ' ').gsub(LINK_ID_NON_CHARS, '').downcase
+        @src.scan(stop_re)
+
+        # reference style link or no link url
+        if @src.scan(LINK_INLINE_ID_RE) || !@src.check(/\(/)
+          link_id = (@src[1] || conv_link_id).downcase
+          if @doc.parse_infos[:link_defs].has_key?(link_id)
+            add_link(el, @doc.parse_infos[:link_defs][link_id].first, @doc.parse_infos[:link_defs][link_id].last, alt_text)
+          else
+            warning("No link definition for link ID '#{link_id}' found")
+            @src.pos = reset_pos
+            add_text(result)
+          end
+          return
+        end
+
+        # link url in parentheses
+        if @src.scan(/\(<(.*?)>/)
+          link_url = @src[1]
+          if @src.scan(/\)/)
+            add_link(el, link_url, nil, alt_text)
+            return
+          end
+        else
+          link_url = ''
+          re = /\(|\)|\s/
+          nr_of_brackets = 0
+          while temp = @src.scan_until(re)
+            link_url += temp
+            case @src.matched
+            when /\s/
+              break
+            when '('
+              nr_of_brackets += 1
+            when ')'
+              nr_of_brackets -= 1
+              break if nr_of_brackets == 0
+            end
+          end
+          link_url = link_url[1..-2]
+
+          if nr_of_brackets == 0
+            add_link(el, link_url, nil, alt_text)
+            return
+          end
+        end
+
+        if @src.scan(LINK_INLINE_TITLE_RE)
+          add_link(el, link_url, @src[2], alt_text)
+        else
+          @src.pos = reset_pos
+          add_text(result)
+        end
+      end
+      define_parser(:link, LINK_START)
+
+    end
+  end
+end