gitdown 0.0.1

data/lib/kramdown/parser/kramdown/footnote.rb

@@ -0,0 +1,74 @@
+# -*- 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/>.
+#++
+#
+
+require 'kramdown/parser/kramdown/extensions'
+require 'kramdown/parser/kramdown/blank_line'
+require 'kramdown/parser/kramdown/codeblock'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      FOOTNOTE_DEFINITION_START = /^#{OPT_SPACE}\[\^(#{ALD_ID_NAME})\]:\s*?(.*?\n#{CODEBLOCK_MATCH})/
+
+      # Parse the foot note definition at the current location.
+      def parse_footnote_definition
+        @src.pos += @src.matched_size
+
+        el = Element.new(:footnote_def)
+        parse_blocks(el, @src[2].gsub(INDENT, ''))
+        warning("Duplicate footnote name '#{@src[1]}' - overwriting") if @footnotes[@src[1]]
+        (@footnotes[@src[1]] = {})[:content] = el
+        @tree.children << Element.new(:eob, :footnote_def)
+        true
+      end
+      define_parser(:footnote_definition, FOOTNOTE_DEFINITION_START)
+
+
+      FOOTNOTE_MARKER_START = /\[\^(#{ALD_ID_NAME})\]/
+
+      # Parse the footnote marker at the current location.
+      def parse_footnote_marker
+        @src.pos += @src.matched_size
+        fn_def = @footnotes[@src[1]]
+        if fn_def
+          valid = fn_def[:marker] && fn_def[:stack][0..-2].zip(fn_def[:stack][1..-1]).all? do |par, child|
+            par.children.include?(child)
+          end
+          if !fn_def[:marker] || !valid
+            fn_def[:marker] = Element.new(:footnote, fn_def[:content], nil, :name => @src[1])
+            fn_def[:stack] = [@stack.map {|s| s.first}, @tree, fn_def[:marker]].flatten.compact
+            @tree.children << fn_def[:marker]
+          else
+            warning("Footnote marker '#{@src[1]}' already appeared in document, ignoring newly found marker")
+            add_text(@src.matched)
+          end
+        else
+          warning("Footnote definition for '#{@src[1]}' not found")
+          add_text(@src.matched)
+        end
+      end
+      define_parser(:footnote_marker, FOOTNOTE_MARKER_START, '\[')
+
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# -*- 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/>.
+#++
+#
+
+require 'kramdown/parser/kramdown/block_boundary'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      HEADER_ID=/(?:[ \t]\{#(\w[\w-]*)\})?/
+      SETEXT_HEADER_START = /^(#{OPT_SPACE}[^ \t].*?)#{HEADER_ID}[ \t]*?\n(-|=)+\s*?\n/
+
+      # Parse the Setext header at the current location.
+      def parse_setext_header
+        return false if !after_block_boundary?
+
+        @src.pos += @src.matched_size
+        text, id, level = @src[1], @src[2], @src[3]
+        text.strip!
+        el = new_block_el(:header, nil, nil, :level => (level == '-' ? 2 : 1), :raw_text => text)
+        add_text(text, el)
+        el.attr['id'] = id if 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
+        return false if !after_block_boundary?
+
+        @src.scan(ATX_HEADER_MATCH)
+        level, text, id = @src[1], @src[2], @src[3]
+        text.strip!
+        el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text)
+        add_text(text, el)
+        el.attr['id'] = id if 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-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
+
+      HR_START = /^#{OPT_SPACE}(\*|-|_)[ \t]*\1[ \t]*\1(\1|[ \t])*\n/
+
+      # Parse the horizontal rule at the current location.
+      def parse_horizontal_rule
+        @src.pos += @src.matched_size
+        @tree.children << new_block_el(:hr)
+        true
+      end
+      define_parser(:horizontal_rule, HR_START)
+
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# -*- 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/>.
+#++
+#
+
+require 'kramdown/parser/html'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      include Kramdown::Parser::Html::Parser
+
+      # Mapping of markdown attribute value to content model. I.e. :raw when "0", :default when "1"
+      # (use default content model for the HTML element), :span when "span", :block when block and
+      # for everything else +nil+ is returned.
+      HTML_MARKDOWN_ATTR_MAP = {"0" => :raw, "1" => :default, "span" => :span, "block" => :block}
+
+      TRAILING_WHITESPACE = /[ \t]*\n/
+
+      def handle_kramdown_html_tag(el, closed)
+        el.options[:ial] = @block_ial if @block_ial
+
+        content_model = if @tree.type != :html_element || @tree.options[:content_model] != :raw
+                          (@options[:parse_block_html] ? HTML_CONTENT_MODEL[el.value] : :raw)
+                        else
+                          :raw
+                        end
+        if val = HTML_MARKDOWN_ATTR_MAP[el.attr.delete('markdown')]
+          content_model = (val == :default ? HTML_CONTENT_MODEL[el.value] : val)
+        end
+
+        @src.scan(TRAILING_WHITESPACE) if content_model == :block
+        el.options[:content_model] = content_model
+
+        if !closed
+          if content_model == :block
+            if !parse_blocks(el)
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+            end
+          elsif content_model == :span
+            curpos = @src.pos
+            if @src.scan_until(/(?=<\/#{el.value}\s*>)/mi)
+              add_text(extract_string(curpos...@src.pos, @src), el)
+              @src.scan(HTML_TAG_CLOSE_RE)
+            else
+              add_text(@src.rest, el)
+              @src.terminate
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+            end
+          else
+            parse_raw_html(el, &method(:handle_kramdown_html_tag))
+          end
+          @src.scan(TRAILING_WHITESPACE) unless (@tree.type == :html_element && @tree.options[:content_model] == :raw)
+        end
+      end
+
+
+      HTML_BLOCK_START = /^#{OPT_SPACE}<(#{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, nil, :category => :block)
+          @src.scan(TRAILING_WHITESPACE)
+          true
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
+          @src.scan(TRAILING_WHITESPACE)
+          true
+        else
+          if result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1].downcase)
+            @src.pos += @src.matched_size
+            handle_html_start_tag(&method(:handle_kramdown_html_tag))
+            Kramdown::Parser::Html::ElementConverter.convert(@root, @tree.children.last) if @options[:html_to_native]
+            true
+          elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1].downcase)
+            name = @src[1].downcase
+
+            if @tree.type == :html_element && @tree.value == name
+              @src.pos += @src.matched_size
+              throw :stop_block_parsing, :found
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+      end
+      define_parser(:block_html, HTML_BLOCK_START)
+
+
+      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, nil, :category => :span)
+        elsif result = @src.scan(HTML_INSTRUCTION_RE)
+          @tree.children << Element.new(:xml_pi, result, nil, :category => :span)
+        elsif result = @src.scan(HTML_TAG_CLOSE_RE)
+          warning("Found invalidly used HTML closing tag for '#{@src[1]}'")
+          add_text(result)
+        elsif result = @src.scan(HTML_TAG_RE)
+          tag_name = @src[1].downcase
+          if HTML_BLOCK_ELEMENTS.include?(tag_name)
+            warning("Found block HTML tag '#{tag_name}' in span-level text")
+            add_text(result)
+            return
+          end
+
+          attrs = Utils::OrderedHash.new
+          @src[2].scan(HTML_ATTRIBUTE_RE).each {|name,sep,val| attrs[name] = val.gsub(/\n+/, ' ')}
+
+          do_parsing = (HTML_CONTENT_MODEL[tag_name] == :raw || @tree.options[:content_model] == :raw ? false : @options[:parse_span_html])
+          if val = HTML_MARKDOWN_ATTR_MAP[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
+              do_parsing = HTML_CONTENT_MODEL[tag_name] != :raw
+            elsif val == :raw
+              do_parsing = false
+            end
+          end
+
+          el = Element.new(:html_element, tag_name, attrs, :category => :span, :content_model => (do_parsing ? :span : :raw))
+          @tree.children << el
+          stop_re = /<\/#{Regexp.escape(tag_name)}\s*>/i
+          if !@src[4] && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
+            warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
+          elsif !@src[4]
+            if parse_spans(el, stop_re, (do_parsing ? nil : [:span_html]))
+              @src.scan(stop_re)
+            else
+              warning("Found no end tag for '#{el.value}' - auto-closing it")
+              add_text(@src.rest, el)
+              @src.terminate
+            end
+          end
+          Kramdown::Parser::Html::ElementConverter.convert(@root, el) if @options[:html_to_native]
+        else
+          add_text(@src.getch)
+        end
+      end
+      define_parser(:span_html, HTML_SPAN_START, '<')
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/html_entity.rb

@@ -0,0 +1,44 @@
+# -*- 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/>.
+#++
+#
+
+require 'kramdown/parser/html'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      # Parse the HTML entity at the current location.
+      def parse_html_entity
+        @src.pos += @src.matched_size
+        begin
+          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity(@src[1] || (@src[2] && @src[2].to_i) || @src[3].hex),
+                                        nil, :original => @src.matched)
+        rescue ::Kramdown::Error
+          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('amp'))
+          add_text(@src.matched[1..-1])
+        end
+      end
+      define_parser(:html_entity, Kramdown::Parser::Html::Constants::HTML_ENTITY_RE, '&')
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# -*- 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
+
+      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, '(  |\\\\)(?=\n)')
+
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# -*- 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
+
+      # Normalize the link identifier.
+      def normalize_link_id(id)
+        id.gsub(/(\s|\n)+/, ' ').downcase
+      end
+
+      LINK_DEFINITION_START = /^#{OPT_SPACE}\[([^\n\]]+)\]:[ \t]*(?:<(.*?)>|([^'"\n]*?\S[^'"\n]*?))[ \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 = normalize_link_id(@src[1]), @src[2] || @src[3], @src[5]
+        warning("Duplicate link ID '#{link_id}' - overwriting") if @link_defs[link_id]
+        @link_defs[link_id] = [link_url, link_title]
+        @tree.children << Element.new(:eob, :link_def)
+        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 @tree.
+      def add_link(el, href, title, alt_text = nil)
+        if el.type == :a
+          el.attr['href'] = href
+        else
+          el.attr['src'] = href
+          el.attr['alt'] = alt_text
+          el.children.clear
+        end
+        el.attr['title'] = title if title
+        @tree.children << el
+      end
+
+      LINK_BRACKET_STOP_RE = /(\])|!?\[/
+      LINK_PAREN_STOP_RE = /(\()|(\))|\s(?=['"])/
+      LINK_INLINE_ID_RE = /\s*?\[([^\]]+)?\]/
+      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)
+
+        count = 1
+        found = parse_spans(el, LINK_BRACKET_STOP_RE) do
+          count = count + (@src[1] ? -1 : 1)
+          count - el.children.select {|c| c.type == :img}.size == 0
+        end
+        if !found || (link_type == :a && el.children.empty?)
+          @src.pos = reset_pos
+          add_text(result)
+          return
+        end
+        alt_text = extract_string(reset_pos...@src.pos, @src)
+        @src.scan(LINK_BRACKET_STOP_RE)
+
+        # reference style link or no link url
+        if @src.scan(LINK_INLINE_ID_RE) || !@src.check(/\(/)
+          link_id = normalize_link_id(@src[1] || alt_text)
+          if @link_defs.has_key?(link_id)
+            add_link(el, @link_defs[link_id].first, @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 = ''
+          nr_of_brackets = 0
+          while temp = @src.scan_until(LINK_PAREN_STOP_RE)
+            link_url << temp
+            if @src[2]
+              nr_of_brackets -= 1
+              break if nr_of_brackets == 0
+            elsif @src[1]
+              nr_of_brackets += 1
+            else
+              break
+            end
+          end
+          link_url = link_url[1..-2]
+          link_url.strip!
+
+          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