kramdown 0.10.0 → 0.11.0

data/lib/kramdown/converter/latex.rb

@@ -49,6 +49,7 @@ module Kramdown
         options = opts.dup.merge(:parent => el)
         el.children.each_with_index do |inner_el, index|
           options[:index] = index
+          options[:result] = result
           result << send("convert_#{inner_el.type}", inner_el, options)
         end
         result
@@ -59,7 +60,7 @@ module Kramdown
       end
 
       def convert_blank(el, opts)
-        ""
+        opts[:result] =~ /\n\n\Z|\A\Z/ ? "" : "\n"
       end
 
       def convert_text(el, opts)
@@ -76,12 +77,12 @@ module Kramdown
 
       def convert_standalone_image(el, opts, img)
         attrs = attribute_list(el)
-        "\\begin{figure}#{attrs}\n\\begin{center}\n#{img}\n\\end{center}\n\\caption{#{escape(el.children.first.options[:attr]['alt'])}}\n\\end{figure}#{attrs}\n"
+        "\\begin{figure}#{attrs}\n\\begin{center}\n#{img}\n\\end{center}\n\\caption{#{escape(el.children.first.attr['alt'])}}\n\\end{figure}#{attrs}\n"
       end
 
       def convert_codeblock(el, opts)
-        show_whitespace = el.options[:attr] && el.options[:attr]['class'].to_s =~ /\bshow-whitespaces\b/
-        lang = el.options[:attr] && el.options[:attr]['lang']
+        show_whitespace = el.attr['class'].to_s =~ /\bshow-whitespaces\b/
+        lang = el.attr['lang']
         if show_whitespace || lang
           result = "\\lstset{showspaces=%s,showtabs=%s}\n" % (show_whitespace ? ['true', 'true'] : ['false', 'false'])
           result += "\\lstset{language=#{lang}}\n" if lang
@@ -95,7 +96,7 @@ module Kramdown
 
       def latex_environment(type, el, text)
         attrs = attribute_list(el)
-        "\\begin{#{type}}#{attrs}\n#{text}\n\\end{#{type}}#{attrs}\n"
+        "\\begin{#{type}}#{attrs}\n#{text.rstrip}\n\\end{#{type}}#{attrs}\n"
       end
 
       def convert_blockquote(el, opts)
@@ -112,7 +113,7 @@ module Kramdown
       }
       def convert_header(el, opts)
         type = HEADER_TYPES[el.options[:level]]
-        if ((el.options[:attr] && (id = el.options[:attr]['id'])) ||
+        if ((id = el.attr['id']) ||
             (@doc.options[:auto_ids] && (id = generate_id(el.options[:raw_text])))) &&
             (@doc.options[:toc_depth] <= 0 || el.options[:level] <= @doc.options[:toc_depth])
           "\\hypertarget{#{id}}{}\\#{type}{#{inner(el, opts)}}\\label{#{id}}\n\n"
@@ -213,7 +214,7 @@ module Kramdown
       end
 
       def convert_a(el, opts)
-        url = el.options[:attr]['href']
+        url = el.attr['href']
         if url =~ /^#/
           "\\hyperlink{#{url[1..-1]}}{#{inner(el, opts)}}"
         else
@@ -222,12 +223,12 @@ module Kramdown
       end
 
       def convert_img(el, opts)
-        if el.options[:attr]['src'] =~ /^(https?|ftps?):\/\//
+        if el.attr['src'] =~ /^(https?|ftps?):\/\//
           @doc.warnings << "Cannot include non-local image"
           ''
-        elsif !el.options[:attr]['src'].empty?
+        elsif !el.options.attr['src'].empty?
           @doc.conversion_infos[:packages] << 'graphicx'
-          "\\includegraphics{#{el.options[:attr]['src']}}"
+          "\\includegraphics{#{el.attr['src']}}"
         else
           @doc.warnings << "Cannot include image with empty path"
           ''
@@ -240,11 +241,15 @@ module Kramdown
 
       def convert_footnote(el, opts)
         @doc.conversion_infos[:packages] << 'fancyvrb'
-        "\\footnote{#{inner(@doc.parse_infos[:footnotes][el.options[:name]][:content], opts)}}"
+        "\\footnote{#{inner(@doc.parse_infos[:footnotes][el.options[:name]][:content], opts).rstrip}}"
       end
 
       def convert_raw(el, opts)
-        escape(el.value)
+        if !el.options[:type] || el.options[:type].empty? || el.options[:type].include?('latex')
+          el.value + (el.options[:category] == :block ? "\n" : '')
+        else
+          ''
+        end
       end
 
       def convert_em(el, opts)
@@ -561,7 +566,7 @@ module Kramdown
       end
 
       def attribute_list(el)
-        attrs = (el.options[:attr] || {}).map {|k,v| v.nil? ? '' : " #{k}=\"#{v.to_s}\""}.compact.sort.join('')
+        attrs = el.attr.map {|k,v| v.nil? ? '' : " #{k}=\"#{v.to_s}\""}.compact.sort.join('')
         attrs = "   % #{attrs}" if !attrs.empty?
         attrs
       end

data/lib/kramdown/document.rb

@@ -136,10 +136,12 @@ module Kramdown
     # Many elements don't use this field.
     attr_accessor :value
 
+    # The attributes of the element. Uses an Utils::OrderedHash to retain the insertion order.
+    attr_reader :attr
+
     # The options hash for the element. It is used for storing arbitray options as well as the
     # following special contents:
     #
-    # - *Attributes* of the element under the <tt>:attr</tt> key
     # - Category of the element, either <tt>:block</tt> or <tt>:span</tt>, under the
     #   <tt>:category</tt> key. If this key is absent, it can be assumed that the element is in the
     #   <tt>:span</tt> category.
@@ -149,15 +151,15 @@ module Kramdown
     attr_accessor :children
 
 
-    # Create a new Element object of type +type+. The optional parameters +value+ and +options+ can
-    # also be set in this constructor for convenience.
-    def initialize(type, value = nil, options = {})
-      @type, @value, @options = type, value, options
+    # Create a new Element object of type +type+. The optional parameters +value+, +attr+ and
+    # +options+ can also be set in this constructor for convenience.
+    def initialize(type, value = nil, attr = nil, options = {})
+      @type, @value, @attr, @options = type, value, Utils::OrderedHash.new(attr), options
       @children = []
     end
 
     def inspect #:nodoc:
-      "<kd:#{@type}#{@value.nil? ? '' : ' ' + @value.inspect}#{options.empty? ? '' : ' ' + @options.inspect}#{@children.empty? ? '' : ' ' + @children.inspect}>"
+      "<kd:#{@type}#{@value.nil? ? '' : ' ' + @value.inspect} #{@attr.inspect}#{options.empty? ? '' : ' ' + @options.inspect}#{@children.empty? ? '' : ' ' + @children.inspect}>"
     end
 
   end

data/lib/kramdown/options.rb

@@ -260,16 +260,6 @@ styles are directly applied to the code elements).
 
 Default: style
 Used by: HTML converter
-EOF
-
-    define(:numeric_entities, Boolean, false, <<EOF)
-DEPRECATED: Defines whether entities are output using names or numeric values
-
-Note that this option is deprecated and replaced by the entities option.
-This option will be removed in a future release.
-
-Default: false
-Used by: HTML converter, kramdown converter
 EOF
 
     define(:entity_output, Symbol, :as_char, <<EOF)
@@ -292,6 +282,13 @@ and h2 headers but not for h3, h4, etc. A value of 0 uses all header levels.
 
 Default: 0
 Used by: HTML/Latex converter
+EOF
+
+    define(:line_width, Integer, 72, <<EOF)
+Defines the line width to be used when outputting a document
+
+Default: 72
+Used by: kramdown converter
 EOF
 
   end

data/lib/kramdown/parser/html.rb

@@ -39,7 +39,7 @@ module Kramdown
         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_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::UNAME_STR})\s*>/m
         HTML_ENTITY_RE = /&([\w:][\-\w\.:]*);|&#(\d+);|&\#x([0-9a-fA-F]+);/
 
 
@@ -80,10 +80,10 @@ module Kramdown
         def handle_html_start_tag
           name = @src[1]
           closed = !@src[4].nil?
-          attrs = {}
+          attrs = Utils::OrderedHash.new
           @src[2].scan(HTML_ATTRIBUTE_RE).each {|attr,sep,val| attrs[attr] = val}
 
-          el = Element.new(:html_element, name, :attr => attrs, :category => :block)
+          el = Element.new(:html_element, name, attrs, :category => :block)
           @tree.children << el
 
           if !closed && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
@@ -129,9 +129,9 @@ module Kramdown
             if result = @src.scan_until(HTML_RAW_START)
               add_text(result, @tree, :text)
               if result = @src.scan(HTML_COMMENT_RE)
-                @tree.children << Element.new(:xml_comment, result, :category => :block, :parent_is_raw => true)
+                @tree.children << Element.new(:xml_comment, result, nil, :category => :block)
               elsif result = @src.scan(HTML_INSTRUCTION_RE)
-                @tree.children << Element.new(:xml_pi, result, :category => :block, :parent_is_raw => true)
+                @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
               elsif @src.scan(HTML_TAG_RE)
                 handle_html_start_tag(&block)
               elsif @src.scan(HTML_TAG_CLOSE_RE)
@@ -242,7 +242,7 @@ module Kramdown
                         elsif %w{mdash ndash hellip laquo raquo}.include?(val)
                           Element.new(:typographic_sym, val.intern)
                         else
-                          Element.new(:entity, entity(val), :original => src.matched)
+                          Element.new(:entity, entity(val), nil, :original => src.matched)
                         end
             else
               result << Element.new(:text, src.scan(/.*/m))
@@ -253,8 +253,7 @@ module Kramdown
 
         def process_html_element(el, do_conversion = true, preserve_text = false)
           el.options = {:category => HTML_SPAN_ELEMENTS.include?(el.value) ? :span : :block,
-            :parse_type => HTML_PARSE_AS[el.value],
-            :attr => el.options[:attr]
+            :parse_type => HTML_PARSE_AS[el.value]
           }
           process_children(el, do_conversion, preserve_text)
         end
@@ -263,15 +262,13 @@ module Kramdown
           el.children.delete_if {|c| c.type == :text}
         end
 
-        SPAN_ELEMENTS = [:em, :strong, :br, :a, :img, :codespan, :entity, :smart_quote, :typographic_sym, :math]
-
         def wrap_text_children(el)
           tmp = []
           last_is_p = false
           el.children.each do |c|
             if c.options[:category] != :block || c.type == :text
               if !last_is_p
-                tmp << Element.new(:p, nil, :transparent => true)
+                tmp << Element.new(:p, nil, nil, :transparent => true)
                 last_is_p = true
               end
               tmp.last.children << c
@@ -306,7 +303,7 @@ module Kramdown
 
         def set_basics(el, type, category, opts = {})
           el.type = type
-          el.options = {:category => category, :attr => el.options[:attr]}.merge(opts)
+          el.options = {:category => category}.merge(opts)
           el.value = nil
         end
 
@@ -316,7 +313,7 @@ module Kramdown
         end
 
         def convert_a(el)
-          if el.options[:attr].has_key?('href')
+          if el.attr['href']
             set_basics(el, :a, :span)
             process_children(el)
           else
@@ -324,6 +321,16 @@ module Kramdown
           end
         end
 
+        def convert_b(el)
+          set_basics(el, :strong, :span)
+          process_children(el)
+        end
+
+        def convert_i(el)
+          set_basics(el, :em, :span)
+          process_children(el)
+        end
+
         def convert_h1(el)
           set_basics(el, :header, :block, :level => el.value[1..1].to_i)
           extract_text(el, el.options[:raw_text] = '')
@@ -366,6 +373,7 @@ module Kramdown
               set_basics(el, :codeblock, :block)
             end
             el.value = result.first.value
+            el.children.clear
           end
         end
         alias :convert_pre :convert_code
@@ -388,7 +396,7 @@ module Kramdown
           end
           calc_alignment.call(el)
           if el.children.first.type == :tr
-            tbody = Element.new(:tbody, nil, :category => :block)
+            tbody = Element.new(:tbody, nil, nil, :category => :block)
             tbody.children = el.children
             el.children = [tbody]
           end
@@ -429,17 +437,17 @@ module Kramdown
         alias :convert_span :convert_div
 
         def is_math_tag?(el)
-          el.options[:attr] && el.options[:attr]['class'].to_s =~ /\bmath\b/ &&
+          el.attr['class'].to_s =~ /\bmath\b/ &&
             el.children.size == 1 && el.children.first.type == :text
         end
 
         def handle_math_tag(el)
           set_basics(el, :math, (el.value == 'div' ? :block : :span))
           el.value = el.children.shift.value
-          if el.options[:attr]['class'] =~ /^\s*math\s*$/
-            el.options[:attr].delete('class')
+          if el.attr['class'] =~ /^\s*math\s*$/
+            el.attr.delete('class')
           else
-            el.options[:attr]['class'].sub!(/\s?math/, '')
+            el.attr['class'].sub!(/\s?math/, '')
           end
           el.value.gsub!(/&(amp|quot|gt|lt);/) do |m|
             case m
@@ -462,11 +470,11 @@ module Kramdown
 
         while true
           if result = @src.scan(/\s*#{HTML_INSTRUCTION_RE}/)
-            @tree.children << Element.new(:xml_pi, result.strip, :category => :block)
+            @tree.children << Element.new(:xml_pi, result.strip, nil, :category => :block)
           elsif result = @src.scan(/\s*#{HTML_DOCTYPE_RE}/)
-            @tree.children << Element.new(:html_doctype, result.strip, :category => :block)
+            @tree.children << Element.new(:html_doctype, result.strip, nil, :category => :block)
           elsif result = @src.scan(/\s*#{HTML_COMMENT_RE}/)
-            @tree.children << Element.new(:xml_comment, result.strip, :category => :block)
+            @tree.children << Element.new(:xml_comment, result.strip, nil, :category => :block)
           else
             break
           end

data/lib/kramdown/parser/kramdown.rb

@@ -168,17 +168,28 @@ module Kramdown
       # Update the tree by parsing all <tt>:raw_text</tt> elements with the span level parser
       # (resets +@tree+, +@src+ and the +@stack+) and by updating the attributes from the IALs.
       def update_tree(element)
+        last_blank = nil
         element.children.map! do |child|
           if child.type == :raw_text
+            last_blank = nil
             @stack, @tree, @text_type = [], nil, :text
             @src = StringScanner.new(child.value)
             parse_spans(child)
             child.children
           elsif child.type == :eob
             []
+          elsif child.type == :blank
+            if last_blank
+              last_blank.value += child.value
+              []
+            else
+              last_blank = child
+              child
+            end
           else
+            last_blank = nil
             update_tree(child)
-            update_attr_with_ial(child.options[:attr] ||= {}, child.options[:ial]) if child.options[:ial]
+            update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
             child
           end
         end.flatten!
@@ -227,8 +238,13 @@ module Kramdown
         ial[:refs].each do |ref|
           update_attr_with_ial(attr, ref) if ref = @doc.parse_infos[:ald][ref]
         end if ial[:refs]
-        attr['class'] = ((attr['class'] || '') + " #{ial['class']}").lstrip if ial['class']
-        ial.each {|k,v| attr[k] = v if k.kind_of?(String) && k != 'class' }
+        ial.each do |k,v|
+          if k == 'class'
+            attr[k] = ((attr[k] || '') + " #{v}").lstrip
+          elsif k.kind_of?(String)
+            attr[k] = v
+          end
+        end
       end
 
       # Create a new block level element, taking care of applying a preceding block IAL if it exists.

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

@@ -32,6 +32,7 @@ module Kramdown
         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
+        @tree.children << Element.new(:eob, :abbrev_def)
         true
       end
       define_parser(:abbrev_definition, ABBREV_DEFINITION_START)

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

@@ -43,8 +43,13 @@ module Kramdown
       # Update the +ial+ with the information from the inline attribute list +opts+.
       def update_ial_with_ial(ial, opts)
         (ial[:refs] ||= []) << opts[:refs]
-        ial['class'] = ((ial['class'] || '') + " #{opts['class']}").lstrip if opts['class']
-        opts.each {|k,v| ial[k] = v if k != :refs && k != 'class' }
+        opts.each do |k,v|
+          if k == 'class'
+            ial[k] = ((ial[k] || '') + " #{v}").lstrip
+          elsif k.kind_of?(String)
+            ial[k] = v
+          end
+        end
       end
 
 
@@ -53,7 +58,7 @@ module Kramdown
       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 = /#(#{ALD_ID_NAME})/
+      ALD_TYPE_ID_NAME = /#(\w[\w:-]*)/
       ALD_TYPE_REF = /(#{ALD_ID_NAME})/
       ALD_TYPE_ANY = /(?:\A|\s)(?:#{ALD_TYPE_KEY_VALUE_PAIR}|#{ALD_TYPE_ID_NAME}|#{ALD_TYPE_CLASS_NAME}|#{ALD_TYPE_REF})(?=\s|\Z)/
       ALD_START = /^#{OPT_SPACE}\{:(#{ALD_ID_NAME}):(#{ALD_ANY_CHARS}+)\}\s*?\n/
@@ -61,24 +66,25 @@ module Kramdown
       # Parse the attribute list definition at the current location.
       def parse_ald
         @src.pos += @src.matched_size
-        parse_attribute_list(@src[2], @doc.parse_infos[:ald][@src[1]] ||= {})
-        @tree.children << Element.new(:eob)
+        parse_attribute_list(@src[2], @doc.parse_infos[:ald][@src[1]] ||= Utils::OrderedHash.new)
+        @tree.children << Element.new(:eob, :ald)
         true
       end
       define_parser(:ald, ALD_START)
 
 
-      IAL_BLOCK_START = /^#{OPT_SPACE}\{:(?!:)(#{ALD_ANY_CHARS}+)\}\s*?\n/
+      IAL_BLOCK = /\{:(?!:|\/)(#{ALD_ANY_CHARS}+)\}\s*?\n/
+      IAL_BLOCK_START = /^#{OPT_SPACE}#{IAL_BLOCK}/
 
       # Parse the inline attribute list at the current location.
       def parse_block_ial
         @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] ||= {})
+          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 = {})
+          parse_attribute_list(@src[1], @block_ial = Utils::OrderedHash.new)
         end
-        @tree.children << Element.new(:eob) unless @src.check(IAL_BLOCK_START)
         true
       end
       define_parser(:block_ial, IAL_BLOCK_START)
@@ -90,10 +96,10 @@ module Kramdown
       def parse_span_ial
         @src.pos += @src.matched_size
         if @tree.children.last && @tree.children.last.type != :text
-          attr = {}
+          attr = Utils::OrderedHash.new
           parse_attribute_list(@src[1], attr)
-          update_ial_with_ial(@tree.children.last.options[:ial] ||= {}, attr)
-          update_attr_with_ial(@tree.children.last.options[:attr] ||= {}, 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("Ignoring span IAL because preceding element is just text")
         end

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

@@ -43,7 +43,7 @@ module Kramdown
         @src.pos += @src.matched_size
         href = @src[1]
         href= "mailto:#{href}" if @src[2].nil?
-        el = Element.new(:a, nil, {:attr => {'href' => href}})
+        el = Element.new(:a, nil, {'href' => href})
         add_text(@src[1].sub(/^mailto:/, ''), el)
         @tree.children << el
       end