motion-kramdown 0.5.0

data/lib/kramdown/parser/kramdown/autolink.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
+  module Parser
+    class Kramdown
+
+      if RUBY_VERSION == '1.8.5'
+        ACHARS = '\w\x80-\xFF'
+      elsif RUBY_VERSION < '1.9.0'
+        ACHARS = '\w'
+      else
+        ACHARS = '[[:alnum:]]'
+      end
+      AUTOLINK_START_STR = "<((mailto|https?|ftps?):.+?|[-.#{ACHARS}]+@[-#{ACHARS}]+(?:\.[-#{ACHARS}]+)*\.[a-z]+)>"
+      AUTOLINK_START = /#{AUTOLINK_START_STR}/u
+
+      # Parse the autolink at the current location.
+      def parse_autolink
+        start_line_number = @src.current_line_number
+        @src.pos += @src.matched_size
+        href = (@src[2].nil? ? "mailto:#{@src[1]}" : @src[1])
+        el = Element.new(:a, nil, {'href' => href}, :location => start_line_number)
+        add_text(@src[1].sub(/^mailto:/, ''), el)
+        @tree.children << el
+      end
+      define_parser(:autolink, AUTOLINK_START, '<')
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/blank_line.rb

@@ -0,0 +1,30 @@
+# -*- 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
+  module Parser
+    class Kramdown
+
+      BLANK_LINE = /(?:^\s*\n)+/m     # RM Oniguruma -> ICU
+
+      # Parse the blank line at the current postition.
+      def parse_blank_line
+        @src.pos += @src.matched_size
+        if @tree.children.last && @tree.children.last.type == :blank
+          @tree.children.last.value << @src.matched
+        else
+          @tree.children << new_block_el(:blank, @src.matched)
+        end
+        true
+      end
+      define_parser(:blank_line, BLANK_LINE)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/block_boundary.rb

@@ -0,0 +1,33 @@
+# -*- 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/parser/kramdown/extensions'
+# RM require 'kramdown/parser/kramdown/blank_line'
+# RM require 'kramdown/parser/kramdown/eob'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      BLOCK_BOUNDARY = /#{BLANK_LINE}|#{EOB_MARKER}|#{IAL_BLOCK_START}|\Z/
+
+      # Return +true+ if we are after a block boundary.
+      def after_block_boundary?
+        !@tree.children.last || @tree.children.last.type == :blank ||
+          (@tree.children.last.type == :eob && @tree.children.last.value.nil?) || @block_ial
+      end
+
+      # Return +true+ if we are before a block boundary.
+      def before_block_boundary?
+        @src.check(self.class::BLOCK_BOUNDARY)
+      end
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/blockquote.rb

@@ -0,0 +1,39 @@
+# -*- 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/parser/kramdown/blank_line'
+# RM require 'kramdown/parser/kramdown/extensions'
+# RM require 'kramdown/parser/kramdown/eob'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      BLOCKQUOTE_START = /^#{OPT_SPACE}> ?/
+
+      # Parse the blockquote at the current location.
+      def parse_blockquote
+        start_line_number = @src.current_line_number
+        result = @src.scan(PARAGRAPH_MATCH)
+        while !@src.match?(self.class::LAZY_END)
+          result << @src.scan(PARAGRAPH_MATCH)
+        end
+        result.gsub!(BLOCKQUOTE_START, '')
+
+        el = new_block_el(:blockquote, nil, nil, :location => start_line_number)
+        @tree.children << el
+        parse_blocks(el, result)
+        true
+      end
+      define_parser(:blockquote, BLOCKQUOTE_START)
+
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/codeblock.rb

@@ -0,0 +1,56 @@
+# -*- 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/parser/kramdown/blank_line'
+# RM require 'kramdown/parser/kramdown/extensions'
+# RM require 'kramdown/parser/kramdown/eob'
+# RM require 'kramdown/parser/kramdown/paragraph'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      CODEBLOCK_START = INDENT
+      CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?(?:#{INDENT}[ \t]*\S.*\n)+(?:(?!#{IAL_BLOCK_START}|#{EOB_MARKER}|#{OPT_SPACE_LAZY_END_HTML_STOP}|#{OPT_SPACE_LAZY_END_HTML_START})^[ \t]*\S.*\n)*)*/
+      # RM modified CODEBLOCK_MATCH with new combined OPT_SPACE_LAZY_END_HTML_STOP/START to support RM changes
+
+      # Parse the indented codeblock at the current location.
+      def parse_codeblock
+        start_line_number = @src.current_line_number
+        data = @src.scan(self.class::CODEBLOCK_MATCH)
+        data.gsub!(/\n( {0,3}\S)/, ' \\1')
+        data.gsub!(INDENT, '')
+        @tree.children << new_block_el(:codeblock, data, nil, :location => start_line_number)
+        true
+      end
+      define_parser(:codeblock, CODEBLOCK_START)
+
+
+      FENCED_CODEBLOCK_START = /^~{3,}/
+      FENCED_CODEBLOCK_MATCH = /^((~){3,})\s*?(\w+)?\s*?\n(.*?)^\1\2*\s*?\n/m
+
+      # Parse the fenced codeblock at the current location.
+      def parse_codeblock_fenced
+        if @src.check(self.class::FENCED_CODEBLOCK_MATCH)
+          start_line_number = @src.current_line_number
+          @src.pos += @src.matched_size
+          el = new_block_el(:codeblock, @src[4], nil, :location => start_line_number)
+          lang = @src[3].to_s.strip
+          el.attr['class'] = "language-#{lang}" unless lang.empty?
+          @tree.children << el
+          true
+        else
+          false
+        end
+      end
+      define_parser(:codeblock_fenced, FENCED_CODEBLOCK_START)
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/codespan.rb

@@ -0,0 +1,44 @@
+# -*- 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
+  module Parser
+    class Kramdown
+
+      CODESPAN_DELIMITER = /`+/
+
+      # Parse the codespan at the current scanner location.
+      def parse_codespan
+        start_line_number = @src.current_line_number
+        result = @src.scan(CODESPAN_DELIMITER)
+        simple = (result.length == 1)
+        saved_pos = @src.save_pos
+
+        if simple && @src.pre_match =~ /\s\Z/ && @src.match?(/\s/)
+          add_text(result)
+          return
+        end
+
+        if text = @src.scan_until(/#{result}/)
+          text.sub!(/#{result}\Z/, '')
+          if !simple
+            text = text[1..-1] if text[0..0] == ' '
+            text = text[0..-2] if text[-1..-1] == ' '
+          end
+          @tree.children << Element.new(:codespan, text, nil, :location => start_line_number)
+        else
+          @src.revert_pos(saved_pos)
+          add_text(result)
+        end
+      end
+      define_parser(:codespan, CODESPAN_DELIMITER, '`')
+
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# -*- 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
+  module Parser
+    class Kramdown
+
+      EMPHASIS_START = /(?:\*\*?|__?)/
+
+      # Parse the emphasis at the current location.
+      def parse_emphasis
+        start_line_number = @src.current_line_number
+        saved_pos = @src.save_pos
+
+        result = @src.scan(EMPHASIS_START)
+        element = (result.length == 2 ? :strong : :em)
+        type = result[0..0]
+
+        if (type == '_' && @src.pre_match =~ /[[:alnum:]]\z/ && @src.check(/[[:alnum:]]/)) || @src.check(/\s/) ||
+            @tree.type == element || @stack.any? {|el, _| el.type == element}
+          add_text(result)
+          return
+        end
+
+        sub_parse = lambda do |delim, elem|
+          el = Element.new(elem, nil, nil, :location => start_line_number)
+          stop_re = /#{Regexp.escape(delim)}/
+          found = parse_spans(el, stop_re) do
+            (@src.pre_match[-1, 1] !~ /\s/) &&
+              (elem != :em || !@src.match?(/#{Regexp.escape(delim*2)}(?!#{Regexp.escape(delim)})/)) &&
+              (type != '_' || !@src.match?(/#{Regexp.escape(delim)}[[:alnum:]]/)) && el.children.size > 0
+          end
+          [found, el, stop_re]
+        end
+
+        found, el, stop_re = sub_parse.call(result, element)
+        if !found && element == :strong && @tree.type != :em
+          @src.revert_pos(saved_pos)
+          @src.pos += 1
+          found, el, stop_re = sub_parse.call(type, :em)
+        end
+        if found
+          @src.scan(stop_re)
+          @tree.children << el
+        else
+          @src.revert_pos(saved_pos)
+          @src.pos += result.length
+          add_text(result)
+        end
+      end
+      define_parser(:emphasis, EMPHASIS_START, '\*|_')
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/eob.rb

@@ -0,0 +1,26 @@
+# -*- 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
+  module Parser
+    class Kramdown
+
+      EOB_MARKER = /^\^\s*?\n/m     # RM Oniguruma -> ICU
+
+      # Parse the EOB marker at the current location.
+      def parse_eob_marker
+        @src.pos += @src.matched_size
+        @tree.children << new_block_el(:eob)
+        true
+      end
+      define_parser(:eob_marker, EOB_MARKER)
+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# -*- 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
+  module Parser
+    class Kramdown
+
+      ESCAPED_CHARS = /\\([\\.*_+`<>()\[\]{}#!:|"'\$=-])/
+
+      # Parse the backslash-escaped character at the current location.
+      def parse_escaped_chars
+        @src.pos += @src.matched_size
+        add_text(@src[1])
+      end
+      define_parser(:escaped_chars, ESCAPED_CHARS, '\\\\')
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/extensions.rb

@@ -0,0 +1,201 @@
+# -*- 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
+  module Parser
+    class Kramdown
+
+      IAL_CLASS_ATTR = 'class'
+
+      # Parse the string +str+ and extract all attributes and add all found attributes to the hash
+      # +opts+.
+      def parse_attribute_list(str, opts)
+        return if str.strip.empty? || str.strip == ':'
+        attrs = str.scan(ALD_TYPE_ANY)
+        attrs.each do |key, sep, val, ref, id_and_or_class, _, _|
+          if ref
+            (opts[:refs] ||= []) << ref
+          elsif id_and_or_class
+            id_and_or_class.scan(ALD_TYPE_ID_OR_CLASS).each do |id_attr, class_attr|
+              if class_attr
+                opts[IAL_CLASS_ATTR] = (opts[IAL_CLASS_ATTR] || '') << " #{class_attr}"
+                opts[IAL_CLASS_ATTR].lstrip!
+              else
+                opts['id'] = id_attr
+              end
+            end
+          else
+            val.gsub!(/\\(\}|#{sep})/, "\\1")
+            opts[key] = val
+          end
+        end
+        warning("No or invalid attributes found in IAL/ALD content: #{str}") if attrs.length == 0
+      end
+
+      # Update the +ial+ with the information from the inline attribute list +opts+.
+      def update_ial_with_ial(ial, opts)
+        (ial[:refs] ||= []) << opts[:refs]
+        opts.each do |k,v|
+          if k == IAL_CLASS_ATTR
+            ial[k] = (ial[k] || '') << " #{v}"
+            ial[k].lstrip!
+          elsif k.kind_of?(String)
+            ial[k] = v
+          end
+        end
+      end
+
+      # Parse the generic extension at the current point. The parameter +type+ can either be :block
+      # or :span depending whether we parse a block or span extension tag.
+      def parse_extension_start_tag(type)
+        saved_pos = @src.save_pos
+        start_line_number = @src.current_line_number
+        @src.pos += @src.matched_size
+
+        error_block = lambda do |msg|
+          warning(msg)
+          @src.revert_pos(saved_pos)
+          add_text(@src.getch) if type == :span
+          false
+        end
+
+        if @src[4] || @src.matched == '{:/}'
+          name = (@src[4] ? "for '#{@src[4]}' " : '')
+          return error_block.call("Invalid extension stop tag #{name} found on line #{start_line_number} - ignoring it")
+        end
+
+        ext = @src[1]
+        opts = {}
+        body = nil
+        parse_attribute_list(@src[2] || '', opts)
+
+        if !@src[3]
+          stop_re = (type == :block ? /#{EXT_BLOCK_STOP_STR % ext}/ : /#{EXT_STOP_STR % ext}/)
+          if result = @src.scan_until(stop_re)
+            body = result.sub!(stop_re, '')
+            body.chomp! if type == :block
+          else
+            return error_block.call("No stop tag for extension '#{ext}' found on line #{start_line_number} - ignoring it")
+          end
+        end
+
+        if !handle_extension(ext, opts, body, type, start_line_number)
+          error_block.call("Invalid extension with name '#{ext}' specified on line #{start_line_number} - ignoring it")
+        else
+          true
+        end
+      end
+
+      def handle_extension(name, opts, body, type, line_no = nil)
+        case name
+        when 'comment'
+          @tree.children << Element.new(:comment, body, nil, :category => type, :location => line_no) if body.kind_of?(String)
+          true
+        when 'nomarkdown'
+          @tree.children << Element.new(:raw, body, nil, :category => type, :location => line_no, :type => opts['type'].to_s.split(/\s+/)) if body.kind_of?(String)
+          true
+        when 'options'
+          opts.select do |k,v|
+            k = k.to_sym
+            if Kramdown::Options.defined?(k)
+              begin
+                val = Kramdown::Options.parse(k, v)
+                @options[k] = val
+                (@root.options[:options] ||= {})[k] = val
+              rescue
+              end
+              false
+            else
+              true
+            end
+          end.each do |k,v|
+            warning("Unknown kramdown option '#{k}'")
+          end
+          @tree.children << Element.new(:eob, :extension) if type == :block
+          true
+        else
+          false
+        end
+      end
+
+
+      ALD_ID_CHARS = /[\w-]/
+      ALD_ANY_CHARS = /\\\}|[^\}]/
+      ALD_ID_NAME = /\w#{ALD_ID_CHARS}*/
+      ALD_TYPE_KEY_VALUE_PAIR = /(#{ALD_ID_NAME})=("|')((?:\\\}|\\\2|[^\}\2])*?)\2/
+      ALD_TYPE_CLASS_NAME = /\.(#{ALD_ID_NAME})/
+      ALD_TYPE_ID_NAME = /#([A-Za-z][\w:-]*)/
+      ALD_TYPE_ID_OR_CLASS = /#{ALD_TYPE_ID_NAME}|#{ALD_TYPE_CLASS_NAME}/
+      ALD_TYPE_ID_OR_CLASS_MULTI = /((?:#{ALD_TYPE_ID_NAME}|#{ALD_TYPE_CLASS_NAME})+)/
+      ALD_TYPE_REF = /(#{ALD_ID_NAME})/
+      ALD_TYPE_ANY = /(?:\A|\s)(?:#{ALD_TYPE_KEY_VALUE_PAIR}|#{ALD_TYPE_REF}|#{ALD_TYPE_ID_OR_CLASS_MULTI})(?=\s|\Z)/
+      ALD_START = /^#{OPT_SPACE}\{:(#{ALD_ID_NAME}):(#{ALD_ANY_CHARS}+)\}\s*?\n/
+
+      EXT_STOP_STR = "\\{:/(%s)?\\}"
+      EXT_START_STR = "\\{::(\\w+)(?:\\s(#{ALD_ANY_CHARS}*?)|)(\\/)?\\}"
+      EXT_BLOCK_START = /^#{OPT_SPACE}(?:#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME})\s*?\n/
+      EXT_BLOCK_STOP_STR = "^#{OPT_SPACE}#{EXT_STOP_STR}\s*?\n"
+
+      IAL_BLOCK = /\{:(?!:|\/)(#{ALD_ANY_CHARS}+)\}\s*?\n/
+      IAL_BLOCK_START = /^#{OPT_SPACE}#{IAL_BLOCK}/m      # RM Oniguruma -> ICU
+
+      BLOCK_EXTENSIONS_START = /^#{OPT_SPACE}\{:/
+
+      # Parse one of the block extensions (ALD, block IAL or generic extension) at the current
+      # location.
+      def parse_block_extensions
+        if @src.scan(ALD_START)
+          parse_attribute_list(@src[2], @alds[@src[1]] ||= Utils::OrderedHash.new)
+          @tree.children << Element.new(:eob, :ald)
+          true
+        elsif @src.check(EXT_BLOCK_START)
+          parse_extension_start_tag(:block)
+        elsif @src.scan(IAL_BLOCK_START)
+          if @tree.children.last && @tree.children.last.type != :blank && @tree.children.last.type != :eob
+            parse_attribute_list(@src[1], @tree.children.last.options[:ial] ||= Utils::OrderedHash.new)
+            @tree.children << Element.new(:eob, :ial) unless @src.check(IAL_BLOCK_START)
+          else
+            parse_attribute_list(@src[1], @block_ial = Utils::OrderedHash.new)
+          end
+          true
+        else
+          false
+        end
+      end
+      define_parser(:block_extensions, BLOCK_EXTENSIONS_START)
+
+
+      EXT_SPAN_START = /#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME}/
+      IAL_SPAN_START = /\{:(#{ALD_ANY_CHARS}+)\}/
+      SPAN_EXTENSIONS_START = /\{:/
+
+      # Parse the extension span at the current location.
+      def parse_span_extensions
+        if @src.check(EXT_SPAN_START)
+          parse_extension_start_tag(:span)
+        elsif @src.check(IAL_SPAN_START)
+          if @tree.children.last && @tree.children.last.type != :text
+            @src.pos += @src.matched_size
+            attr = Utils::OrderedHash.new
+            parse_attribute_list(@src[1], attr)
+            update_ial_with_ial(@tree.children.last.options[:ial] ||= Utils::OrderedHash.new, attr)
+            update_attr_with_ial(@tree.children.last.attr, attr)
+          else
+            warning("Found span IAL after text - ignoring it")
+            add_text(@src.getch)
+          end
+        else
+          add_text(@src.getch)
+        end
+      end
+      define_parser(:span_extensions, SPAN_EXTENSIONS_START, '\{:')
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# -*- 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/parser/kramdown/extensions'
+# RM require 'kramdown/parser/kramdown/blank_line'
+# RM 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
+        start_line_number = @src.current_line_number
+        @src.pos += @src.matched_size
+
+        el = Element.new(:footnote_def, nil, nil, :location => start_line_number)
+        parse_blocks(el, @src[2].gsub(INDENT, ''))
+        warning("Duplicate footnote name '#{@src[1]}' on line #{start_line_number} - 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
+        start_line_number = @src.current_line_number
+        @src.pos += @src.matched_size
+        fn_def = @footnotes[@src[1]]
+        if fn_def
+          fn_def[:marker] ||= []
+          fn_def[:marker].push(Element.new(:footnote, fn_def[:content], nil, :name => @src[1], :location => start_line_number))
+          fn_def[:stack] = [@stack.map {|s| s.first}, @tree, fn_def[:marker]].flatten.compact
+          @tree.children << fn_def[:marker].last
+        else
+          warning("Footnote definition for '#{@src[1]}' not found on line #{start_line_number}")
+          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,59 @@
+# -*- 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/parser/kramdown/block_boundary'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      HEADER_ID=/(?:[ \t]+\{#([A-Za-z][\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?
+
+        start_line_number = @src.current_line_number
+        @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, :location => start_line_number)
+        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?
+
+        start_line_number = @src.current_line_number
+        @src.check(ATX_HEADER_MATCH)
+        level, text, id = @src[1], @src[2].to_s.strip, @src[3]
+        return false if text.empty?
+
+        @src.pos += @src.matched_size
+        el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text, :location => start_line_number)
+        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