asciidoctor 0.1.2 → 0.1.3

data/lib/asciidoctor/block.rb

@@ -14,9 +14,6 @@ class Block < AbstractBlock
   # Public: Get/Set the original Array content for this section block.
   attr_accessor :buffer
 
-  # Public: Get/Set the caption for this block
-  attr_accessor :caption
-
   # Public: Initialize an Asciidoctor::Block object.
   #
   # parent  - The parent Asciidoc Object.
@@ -26,7 +23,6 @@ class Block < AbstractBlock
   def initialize(parent, context, buffer = nil)
     super(parent, context)
     @buffer = buffer
-    @caption = nil
   end
 
   # Public: Get the rendered String content for this Block.  If the block
@@ -34,56 +30,12 @@ class Block < AbstractBlock
   # rendered and returned as content that can be included in the
   # parent block's template.
   def render
-    Debug.debug { "Now rendering #{@context} block for #{self}" }
     @document.playback_attributes @attributes
     out = renderer.render("block_#{@context}", self)
     @document.callouts.next_list if @context == :colist
     out
   end
 
-  def splain(parent_level = 0)
-    parent_level += 1
-    Debug.puts_indented(parent_level, "Block id: #{id}") unless self.id.nil?
-    Debug.puts_indented(parent_level, "Block title: #{title}") unless self.title.nil?
-    Debug.puts_indented(parent_level, "Block caption: #{caption}") unless self.caption.nil?
-    Debug.puts_indented(parent_level, "Block level: #{level}") unless self.level.nil?
-    Debug.puts_indented(parent_level, "Block context: #{context}") unless self.context.nil?
-
-    Debug.puts_indented(parent_level, "Blocks: #{@blocks.count}")
-
-    if buffer.is_a? Enumerable
-      buffer.each_with_index do |buf, i|
-        Debug.puts_indented(parent_level, "v" * (60 - parent_level*2))
-        Debug.puts_indented(parent_level, "Buffer ##{i} is a #{buf.class}")
-        Debug.puts_indented(parent_level, "Name is #{buf.title rescue 'n/a'}")
-
-        if buf.respond_to? :splain
-          buf.splain(parent_level)
-        else
-          Debug.puts_indented(parent_level, "Buffer: #{buf}")
-        end
-        Debug.puts_indented(parent_level, "^" * (60 - parent_level*2))
-      end
-    else
-      if buffer.respond_to? :splain
-        buffer.splain(parent_level)
-      else
-        Debug.puts_indented(parent_level, "Buffer: #{@buffer}")
-      end
-    end
-
-    @blocks.each_with_index do |block, i|
-      Debug.puts_indented(parent_level, "v" * (60 - parent_level*2))
-      Debug.puts_indented(parent_level, "Block ##{i} is a #{block.class}")
-      Debug.puts_indented(parent_level, "Name is #{block.title rescue 'n/a'}")
-
-      block.splain(parent_level) if block.respond_to? :splain
-      Debug.puts_indented(parent_level, "^" * (60 - parent_level*2))
-    end
-    
-    nil
-  end
-
   # Public: Get an HTML-ified version of the source buffer, with special
   # Asciidoc characters and entities converted to their HTML equivalents.
   #
@@ -96,7 +48,7 @@ class Block < AbstractBlock
   #   => ["<em>This</em> is what happens when you &lt;meet&gt; a stranger in the &lt;alps&gt;!"]
   def content
     case @context
-    when :preamble, :open
+    when :preamble
       @blocks.map {|b| b.render }.join
     # lists get iterated in the template (for now)
     # list items recurse into this block when their text and content methods are called
@@ -106,7 +58,7 @@ class Block < AbstractBlock
       apply_literal_subs(@buffer)
     when :pass
       apply_passthrough_subs(@buffer)
-    when :admonition, :example, :sidebar, :quote, :verse
+    when :admonition, :example, :sidebar, :quote, :verse, :open
       if !@buffer.nil?
         apply_para_subs(@buffer)
       else

data/lib/asciidoctor/cli/options.rb

@@ -44,11 +44,11 @@ Example: asciidoctor -b html5 source.asciidoc
           opts.on('-v', '--verbose', 'enable verbose mode (default: false)') do |verbose|
             self[:verbose] = true
           end
-          opts.on('-b', '--backend BACKEND', ['html5', 'docbook45'], 'set output format (i.e., backend): [html5, docbook45] (default: html5)') do |backend|
+          opts.on('-b', '--backend BACKEND', 'set output format backend (default: html5)') do |backend|
             self[:attributes]['backend'] = backend
           end
-          opts.on('-d', '--doctype DOCTYPE', ['article', 'book'],
-                  'document type to use when rendering output: [article, book] (default: article)') do |doc_type|
+          opts.on('-d', '--doctype DOCTYPE', ['article', 'book', 'inline'],
+                  'document type to use when rendering output: [article, book, inline] (default: article)') do |doc_type|
             self[:attributes]['doctype'] = doc_type
           end
           opts.on('-o', '--out-file FILE', 'output file (default: based on input file path); use - to output to STDOUT') do |output_file|
@@ -78,12 +78,13 @@ Example: asciidoctor -b html5 source.asciidoc
           opts.on('-C', '--compact', 'compact the output by removing blank lines (default: false)') do
             self[:compact] = true
           end
-          opts.on('-a', '--attribute key1=value,key2=value2,...', Array,
-                  'a list of attributes, in the form key or key=value pair, to set on the document',
-                  'these attributes take precedence over attributes defined in the source file') do |attribs|
+          opts.on('-a', '--attribute key[=value],key2[=value2],...', Array,
+                  'a list of document attributes to set in the form of key, key! or key=value pair',
+                  'unless @ is appended to the value, these attributes take precedence over attributes',
+                  'defined in the source document') do |attribs|
             attribs.each do |attrib|
-              tokens = attrib.split('=')
-              self[:attributes][tokens[0]] = tokens[1] || ''
+              key, val = attrib.split '=', 2
+              self[:attributes][key] = val || ''
             end
           end
           opts.on('-T', '--template-dir DIR', 'directory containing custom render templates the override the built-in set') do |template_dir|

data/lib/asciidoctor/document.rb

@@ -104,13 +104,14 @@ class Document < AbstractBlock
 
     if options[:parent]
       @parent_document = options.delete(:parent)
-      # should we dup here?
+      # should we dup attributes here?
       options[:attributes] = @parent_document.attributes
-      options[:safe] ||= @parent_document.safe
       options[:base_dir] ||= @parent_document.base_dir
+      @safe = @parent_document.safe
       @renderer = @parent_document.renderer
     else
       @parent_document = nil
+      @safe = nil
     end
 
     @header = nil
@@ -124,7 +125,19 @@ class Document < AbstractBlock
     @counters = {}
     @callouts = Callouts.new
     @options = options
-    @safe = @options.fetch(:safe, SafeMode::SECURE).to_i
+    # safely resolve the safe mode from const, int or string
+    if @safe.nil? && !(safe_mode = @options[:safe])
+      @safe = SafeMode::SECURE
+    elsif safe_mode.is_a?(Fixnum)
+      # be permissive in case API user wants to define new levels
+      @safe = safe_mode
+    else
+      begin
+        @safe = SafeMode.const_get(safe_mode.to_s.upcase).to_i
+      rescue
+        @safe = SafeMode::SECURE.to_i
+      end
+    end
     @options[:header_footer] = @options.fetch(:header_footer, false)
 
     @attributes['encoding'] = 'UTF-8'
@@ -184,11 +197,11 @@ class Document < AbstractBlock
 
     # allow common attributes backend and doctype to be set using options hash
     unless @options[:backend].nil?
-      @attribute_overrides['backend'] = @options[:backend]
+      @attribute_overrides['backend'] = @options[:backend].to_s
     end
 
     unless @options[:doctype].nil?
-      @attribute_overrides['doctype'] = @options[:doctype]
+      @attribute_overrides['doctype'] = @options[:doctype].to_s
     end
 
     if @safe >= SafeMode::SERVER
@@ -269,15 +282,6 @@ class Document < AbstractBlock
     Lexer.parse(@reader, self, :header_only => @options.fetch(:parse_header_only, false)) 
 
     @callouts.rewind
-
-    Debug.debug {
-      msg = []
-      msg << "Found #{@blocks.size} blocks in this document:"
-      @blocks.each {|b|
-        msg << b
-      }
-      msg * "\n"
-    }
   end
 
   # Public: Get the named counter and take the next number in the sequence.
@@ -441,6 +445,10 @@ class Document < AbstractBlock
   # Internal: Branch the attributes so that the original state can be restored
   # at a future time.
   def save_attributes
+    unless @attributes.has_key?('doctitle') || (val = doctitle).nil?
+      @attributes['doctitle'] = val
+    end
+
     # css-signature cannot be updated after header attributes are processed
     if @id.nil? && @attributes.has_key?('css-signature')
       @id = @attributes['css-signature']
@@ -578,27 +586,6 @@ class Document < AbstractBlock
     @attributes["filetype-#{file_type}"] = ''
   end
 
-  def splain
-    Debug.debug {
-      msg = ''
-      if @header
-        msg = "Header is #{@header}"
-      else
-        msg = "No header"
-      end
-
-      msg += "I have #{@blocks.count} blocks"
-      @blocks.each_with_index do |block, i|
-        msg += "v" * 60
-        msg += "Block ##{i} is a #{block.class}"
-        msg += "Name is #{block.title rescue 'n/a'}"
-        block.splain(0) if block.respond_to? :splain
-        msg += "^" * 60
-      end
-    }
-    nil
-  end
-
   def renderer(opts = {})
     return @renderer if @renderer
     
@@ -627,11 +614,21 @@ class Document < AbstractBlock
   def render(opts = {})
     restore_attributes
     r = renderer(opts)
-    @options.merge(opts)[:header_footer] ? r.render('document', self).strip : r.render('embedded', self)
+    if doctype == 'inline'
+      # QUESTION should we warn if @blocks.size > 0 and the first block is not a paragraph?
+      if @blocks.size > 0 && (block = @blocks.first).context == :paragraph
+        block.content
+      else
+        ''
+      end
+    else
+      @options.merge(opts)[:header_footer] ? r.render('document', self).strip : r.render('embedded', self)
+    end
   end
 
   def content
-    # per AsciiDoc-spec, remove the title after rendering the header
+    # per AsciiDoc-spec, remove the title before rendering the body,
+    # regardless of whether the header is rendered)
     @attributes.delete('title')
     @blocks.map {|b| b.render }.join
   end
@@ -651,14 +648,7 @@ class Document < AbstractBlock
     if safe >= SafeMode::SECURE
       ''
     else
-      if ext.nil?
-        case @attributes['basebackend']
-        when 'docbook'
-          ext = '.xml'
-        when 'html'
-          ext = '.html'
-        end
-      end
+      ext = @attributes['outfilesuffix'] if ext.nil?
 
       content = nil
 

data/lib/asciidoctor/helpers.rb

@@ -37,6 +37,16 @@ module Helpers
     end
   end
 
+  def self.mkdir_p(dir)
+    unless File.directory? dir
+      parent_dir = File.dirname(dir)
+      if !File.directory?(parent_dir = File.dirname(dir)) && parent_dir != '.'
+        mkdir_p(parent_dir)
+      end
+      Dir.mkdir(dir)
+    end
+  end
+
   # Public: A generic capture output routine to be used in templates
   #def self.capture_output(*args, &block)
   #  Proc.new { block.call(*args) }

data/lib/asciidoctor/lexer.rb

@@ -74,10 +74,33 @@ class Lexer
     # that precede first block
     block_attributes = parse_block_metadata_lines(reader, document)
 
+    # special case, block title is not allowed above document title,
+    # carry attributes over to the document body
+    if block_attributes.has_key?('title')
+      document.clear_playback_attributes block_attributes
+      document.save_attributes
+      block_attributes['invalid-header'] = true
+      return block_attributes
+    end
+
+    # yep, document title logic in AsciiDoc is just insanity
+    # definitely an area for spec refinement
+    assigned_doctitle = nil
+    unless (val = document.attributes.fetch('doctitle', '')).empty?
+      document.title = val
+      assigned_doctitle = val
+    end
+
+    section_title = nil
     # check if the first line is the document title
     # if so, add a header to the document and parse the header metadata
     if is_next_line_document_title?(reader, block_attributes)
-      document.id, document.title, _, _ = parse_section_title(reader, document)
+      document.id, doctitle, _, _ = parse_section_title(reader, document)
+      unless assigned_doctitle
+        document.title = doctitle
+        assigned_doctitle = doctitle
+      end
+      document.attributes['doctitle'] = section_title = doctitle
       # QUESTION: should this be encapsulated in document?
       if document.id.nil? && block_attributes.has_key?('id')
         document.id = block_attributes.delete('id')
@@ -85,8 +108,15 @@ class Lexer
       parse_header_metadata(reader, document)
     end
 
-    if document.attributes.has_key? 'doctitle'
-      document.title = document.attributes['doctitle']
+    if !(val = document.attributes.fetch('doctitle', '')).empty? &&
+        val != section_title
+      document.title = val
+      assigned_doctitle = val
+    end
+
+    # restore doctitle attribute to original assignment
+    if assigned_doctitle
+      document.attributes['doctitle'] = assigned_doctitle
     end
  
     document.clear_playback_attributes block_attributes
@@ -143,7 +173,7 @@ class Lexer
     # NOTE we could drop a hint in the attributes to indicate
     # that we are at a section title (so we don't have to check)
     if parent.is_a?(Document) && parent.blocks.empty? &&
-        (parent.has_header? || !is_next_line_section?(reader, attributes))
+        (parent.has_header? || attributes.delete('invalid-header') || !is_next_line_section?(reader, attributes))
 
       if parent.has_header?
         preamble = Block.new(parent, :preamble)
@@ -193,11 +223,10 @@ class Lexer
       if next_level
         next_level += section.document.attr('leveloffset', 0).to_i
         doctype = parent.document.doctype
-        if next_level == 0 && doctype != 'book'
-          puts "asciidoctor: ERROR: line #{reader.lineno + 1}: only book doctypes can contain level 0 sections"
-        end
         if next_level > current_level || (section.is_a?(Document) && next_level == 0)
-          unless expected_next_levels.nil? || expected_next_levels.include?(next_level)
+          if next_level == 0 && doctype != 'book'
+            puts "asciidoctor: ERROR: line #{reader.lineno + 1}: only book doctypes can contain level 0 sections"
+          elsif !expected_next_levels.nil? && !expected_next_levels.include?(next_level)
             puts "asciidoctor: WARNING: line #{reader.lineno + 1}: section title out of sequence: " +
                 "expected #{expected_next_levels.size > 1 ? 'levels' : 'level'} #{expected_next_levels * ' or '}, " +
                 "got level #{next_level}"
@@ -206,12 +235,15 @@ class Lexer
           new_section, attributes = next_section(reader, section, attributes)
           section << new_section
         else
+          if next_level == 0 && doctype != 'book'
+            puts "asciidoctor: ERROR: line #{reader.lineno + 1}: only book doctypes can contain level 0 sections"
+          end
           # close this section (and break out of the nesting) to begin a new one
           break
         end
       else
         # just take one block or else we run the risk of overrunning section boundaries
-        new_block = next_block(reader, section, attributes, :parse_metadata => false)
+        new_block = next_block(reader, (preamble || section), attributes, :parse_metadata => false)
         if !new_block.nil?
           (preamble || section) << new_block
           attributes = {}
@@ -224,8 +256,8 @@ class Lexer
       reader.skip_blank_lines
     end
 
-    # drop the preamble if it has no content
-    if preamble && preamble.blocks.empty?
+    if preamble && !preamble.blocks?
+      # drop the preamble if it has no content
       section.delete_at(0)
     end
 
@@ -260,11 +292,13 @@ class Lexer
     # bail if we've reached the end of the parent block or document
     return nil unless reader.has_more_lines?
 
+    text_only = options[:text]
     # check for option to find list item text only
     # if skipped a line, assume a list continuation was
     # used and block content is acceptable
-    if options[:text] && skipped > 0
+    if text_only && skipped > 0
       options.delete(:text)
+      text_only = false
     end
     
     parse_metadata = options.fetch(:parse_metadata, true)
@@ -292,9 +326,8 @@ class Lexer
       block_context = nil
       terminator = nil
       # QUESTION put this inside call to rekey attributes?
-      if attributes.has_key? 1
-        explicit_style = attributes['style']
-        style = attributes['style'] = attributes[1]
+      if attributes[1]
+        style, explicit_style = parse_style_attribute(attributes)
       end
 
       if delimited_blk_match = is_delimited_block?(this_line, true)
@@ -332,7 +365,7 @@ class Lexer
           end
 
           # process lines normally
-          if !options[:text]
+          if !text_only
             # NOTE we're letting break lines (ruler, page_break, etc) have attributes
             if (match = this_line.match(REGEXP[:break_line]))
               block = Block.new(parent, BREAK_LINES[match[0][0..2]])
@@ -461,8 +494,7 @@ class Lexer
             break
 
           # FIXME create another set for "passthrough" styles
-          # though partintro should likely be a dedicated block
-          elsif !style.nil? && style != 'normal' && style != 'partintro'
+          elsif !style.nil? && style != 'normal'
             if PARAGRAPH_STYLES.include?(style)
               block_context = style.to_sym
               reader.unshift_line this_line
@@ -498,13 +530,7 @@ class Lexer
               (COMPLIANCE[:block_terminates_paragraph] && (is_delimited_block?(line) || line.match(REGEXP[:attr_line])))
             }
 
-            # trim off the indentation equivalent to the size of the least indented line
-            if !buffer.empty?
-              offset = buffer.map {|line| line.match(REGEXP[:leading_blanks])[1].length }.min
-              if offset > 0
-                buffer = buffer.map {|l| l.sub(/^\s{1,#{offset}}/, '') }
-              end
-            end
+            reset_block_indent! buffer
 
             block = Block.new(parent, :literal, buffer)
             # a literal gets special meaning inside of a definition list
@@ -541,12 +567,49 @@ class Lexer
 
             catalog_inline_anchors(buffer.join, document)
 
-            if !options[:text] && (admonition_match = buffer.first.match(REGEXP[:admonition_inline]))
+            first_line = buffer.first
+            if !text_only && (admonition_match = first_line.match(REGEXP[:admonition_inline]))
               buffer[0] = admonition_match.post_match.lstrip
               block = Block.new(parent, :admonition, buffer)
               attributes['style'] = admonition_match[1]
               attributes['name'] = admonition_name = admonition_match[1].downcase
               attributes['caption'] ||= document.attributes["#{admonition_name}-caption"]
+            elsif !text_only && COMPLIANCE[:markdown_syntax] && first_line.start_with?('> ')
+              buffer.map! {|line|
+                if line.start_with?('> ')
+                  line[2..-1]
+                elsif line.chomp == '>'
+                  line[1..-1]
+                else
+                  line
+                end
+              }
+
+              if buffer.last.start_with?('-- ')
+                attribution, citetitle = buffer.pop[3..-1].split(', ')
+                buffer.pop while buffer.last.chomp.empty?
+                buffer[-1] = buffer.last.chomp
+              else
+                attribution, citetitle = nil
+              end
+              attributes['style'] = 'quote'
+              attributes['attribution'] = attribution unless attribution.nil?
+              attributes['citetitle'] = citetitle unless citetitle.nil?
+              # NOTE will only detect headings that are floating titles (not section titles)
+              # TODO could assume a floating title when inside a block context
+              block = build_block(:quote, :complex, false, parent, Reader.new(buffer), attributes)
+            elsif !text_only && buffer.size > 1 && first_line.start_with?('"') &&
+                buffer.last.start_with?('-- ') && buffer[-2].chomp.end_with?('"')
+              buffer[0] = first_line[1..-1]
+              attribution, citetitle = buffer.pop[3..-1].split(', ')
+              buffer.pop while buffer.last.chomp.empty?
+              buffer[-1] = buffer.last.chomp.chop
+              attributes['style'] = 'quote'
+              attributes['attribution'] = attribution unless attribution.nil?
+              attributes['citetitle'] = citetitle unless citetitle.nil?
+              block = Block.new(parent, :quote, buffer)
+              #block = Block.new(parent, :quote)
+              #block << Block.new(block, :paragraph, buffer)
             else
               # QUESTION is this necessary?
               #if style == 'normal' && [' ', "\t"].include?(buffer.first[0..0])
@@ -565,6 +628,10 @@ class Lexer
 
       # either delimited block or styled paragraph
       if block.nil? && !block_context.nil?
+        # abstract and partintro should be handled by open block
+        # FIXME kind of hackish...need to sort out how to generalize this
+        block_context = :open if block_context == :abstract || block_context == :partintro
+
         case block_context
         when :admonition
           attributes['name'] = admonition_name = style.downcase
@@ -576,7 +643,7 @@ class Lexer
           return nil
 
         when :example
-          block = build_block(block_context, :complex, terminator, parent, reader, attributes, true)
+          block = build_block(block_context, :complex, terminator, parent, reader, attributes, {:supports_caption => true})
 
         when :listing, :fenced_code, :source
           if block_context == :fenced_code
@@ -587,7 +654,7 @@ class Lexer
           elsif block_context == :source
             AttributeList.rekey(attributes, [nil, 'language', 'linenums'])
           end
-          block = build_block(:listing, :verbatim, terminator, parent, reader, attributes, true)
+          block = build_block(:listing, :verbatim, terminator, parent, reader, attributes, {:supports_caption => true})
 
         when :literal
           block = build_block(block_context, :verbatim, terminator, parent, reader, attributes)
@@ -600,6 +667,12 @@ class Lexer
 
         when :table
           block_reader = Reader.new reader.grab_lines_until(:terminator => terminator, :skip_line_comments => true)
+          case terminator[0..0]
+            when ','
+              attributes['format'] = 'csv'
+            when ':'
+              attributes['format'] = 'dsv'
+          end
           block = next_table(block_reader, parent, attributes)
 
         when :quote, :verse
@@ -621,7 +694,7 @@ class Lexer
       # REVIEW seems like there is a better way to organize this wrap-up
       block.id      ||= attributes['id'] if attributes.has_key?('id')
       block.title     = attributes['title'] unless block.title?
-      block.caption ||= attributes['caption'] unless block.is_a?(Section)
+      block.caption ||= attributes.delete('caption')
       # AsciiDoc always use [id] as the reftext in HTML output,
       # but I'd like to do better in Asciidoctor
       if block.id && block.title? && !attributes.has_key?('reftext')
@@ -651,11 +724,13 @@ class Lexer
         tip = line[0..3]
         tl = 4
 
-        # special case for fenced code blocks
-        tip_alt = tip.chop
-        if tip_alt == '```' || tip_alt == '~~~'
-          tip = tip_alt
-          tl = 3
+        if COMPLIANCE[:markdown_syntax]
+          # special case for fenced code blocks
+          tip_alt = tip.chop
+          if tip_alt == '```' || tip_alt == '~~~'
+            tip = tip_alt
+            tl = 3
+          end
         end
       end
 
@@ -689,8 +764,9 @@ class Lexer
   end
 
   # whether a block supports complex content should be a config setting
+  # if terminator is false, that means the all the lines in the reader should be parsed
   # NOTE could invoke filter in here, before and after parsing
-  def self.build_block(block_context, content_type, terminator, parent, reader, attributes, supports_caption = false)
+  def self.build_block(block_context, content_type, terminator, parent, reader, attributes, options = {})
     if terminator.nil?
       if content_type == :verbatim
         buffer = reader.grab_lines_until(:break_on_blank_lines => true, :break_on_list_continuation => true)
@@ -706,14 +782,21 @@ class Lexer
       end
     elsif content_type != :complex
       buffer = reader.grab_lines_until(:terminator => terminator, :chomp_last_line => true)
+    elsif terminator == false
+      buffer = nil
+      block_reader = reader
     else
       buffer = nil
       block_reader = Reader.new reader.grab_lines_until(:terminator => terminator)
     end
 
+    if content_type == :verbatim && attributes.has_key?('indent')
+      reset_block_indent! buffer, attributes['indent'].to_i
+    end
+
     block = Block.new(parent, block_context, buffer)
     # should supports_caption be necessary?
-    if supports_caption
+    if options.fetch(:supports_caption, false)
       block.title = attributes.delete('title') if attributes.has_key?('title')
       block.assign_caption attributes.delete('caption')
     end
@@ -1114,7 +1197,7 @@ class Lexer
     end
 
     #puts "BUFFER[#{list_type},#{sibling_trait}]>#{buffer.join}<BUFFER"
-    #puts "BUFFER[#{list_type},#{sibling_trait}]>#{buffer}<BUFFER"
+    #puts "BUFFER[#{list_type},#{sibling_trait}]>#{buffer.inspect}<BUFFER"
 
     buffer
   end
@@ -1130,33 +1213,39 @@ class Lexer
   def self.initialize_section(reader, parent, attributes = {})
     section = Section.new parent
     section.id, section.title, section.level, _ = parse_section_title(reader, section.document)
-    if section.id.nil? && attributes.has_key?('id')
-      section.id = attributes['id']
-    else
-      # generate an id if one was not *embedded* in the heading line
-      # or as an anchor above the section
-      section.id ||= section.generate_id
-    end
-
-    if section.id
-      section.document.register(:ids, [section.id, section.title])
-    end
-
+    # parse style, id and role from first positional attribute
     if attributes[1]
-      section.sectname = attributes[1]
+      section.sectname, _ = parse_style_attribute(attributes)
       section.special = true
       document = parent.document
+      # HACK needs to be refactored so it's driven by config
+      if section.sectname == 'abstract' && document.doctype == 'book'
+        section.sectname = "sect1"
+        section.special = false
+        section.level = 1
       # FIXME refactor to use assign_caption (also check requirements)
-      if section.sectname == 'appendix' &&
+      elsif section.sectname == 'appendix' &&
           !attributes.has_key?('caption') &&
           !document.attributes.has_key?('caption')
         number = document.counter('appendix-number', 'A')
-        attributes['caption'] = "#{document.attributes['appendix-caption']} #{number}: "
+        section.caption = "#{document.attributes['appendix-caption']} #{number}: "
         Document::AttributeEntry.new('appendix-number', number).save_to(attributes)
       end
     else
       section.sectname = "sect#{section.level}"
     end
+
+    if section.id.nil? && (id = attributes['id'])
+      section.id = id
+    else
+      # generate an id if one was not *embedded* in the heading line
+      # or as an anchor above the section
+      section.id ||= section.generate_id
+    end
+
+    if section.id
+      section.document.register(:ids, [section.id, section.title])
+    end
     section.update_attributes(attributes)
     reader.skip_blank_lines
 
@@ -1173,8 +1262,8 @@ class Lexer
 
   #--
   # = is level 0, == is level 1, etc.
-  def self.single_line_section_level(line)
-    [line.length - 1, 0].max
+  def self.single_line_section_level(marker)
+    marker.length - 1
   end
 
   # Internal: Checks if the next line on the Reader is a section title
@@ -1185,7 +1274,7 @@ class Lexer
   # returns the section level if the Reader is positioned at a section title,
   # false otherwise
   def self.is_next_line_section?(reader, attributes)
-    return false if !attributes[1].nil? && ['float', 'discrete'].include?(attributes[1])
+    return false if !(val = attributes[1]).nil? && ['float', 'discrete'].include?(val)
     return false if !reader.has_more_lines?
     is_section_title?(*reader.peek_lines(2))
   end
@@ -1218,7 +1307,8 @@ class Lexer
   end
 
   def self.is_single_line_section_title?(line1)
-    if !line1.nil? && (match = line1.match(REGEXP[:section_title]))
+    if !line1.nil? && (line1.start_with?('=') || (COMPLIANCE[:markdown_syntax] && line1.start_with?('#'))) &&
+        (match = line1.match(REGEXP[:section_title]))
       single_line_section_level match[1]
     else
       false
@@ -1226,8 +1316,8 @@ class Lexer
   end
 
   def self.is_two_line_section_title?(line1, line2)
-    if !line1.nil? && !line2.nil? && line1.match(REGEXP[:section_name]) &&
-        line2.match(REGEXP[:section_underline]) &&
+    if !line1.nil? && !line2.nil? && SECTION_LEVELS.has_key?(line2[0..0]) &&
+        line2.match(REGEXP[:section_underline]) && line1.match(REGEXP[:section_name]) &&
         # chomp so that a (non-visible) endline does not impact calculation
         (line1.chomp.size - line2.chomp.size).abs <= 1
       section_level line2
@@ -1286,14 +1376,15 @@ class Lexer
     sect_level = -1
     single_line = true
 
-    if match = line1.match(REGEXP[:section_title])
+    if (line1.start_with?('=') || (COMPLIANCE[:markdown_syntax] && line1.start_with?('#'))) &&
+        (match = line1.match(REGEXP[:section_title]))
       sect_id = match[3]
       sect_title = match[2]
       sect_level = single_line_section_level match[1]
     else
       line2 = reader.peek_line
-      if !line2.nil? && (name_match = line1.match(REGEXP[:section_name])) &&
-        line2.match(REGEXP[:section_underline]) &&
+      if !line2.nil? && SECTION_LEVELS.has_key?(line2[0..0]) && line2.match(REGEXP[:section_underline]) &&
+        (name_match = line1.match(REGEXP[:section_name])) &&
         # chomp so that a (non-visible) endline does not impact calculation
         (line1.chomp.size - line2.chomp.size).abs <= 1
         if anchor_match = name_match[1].match(REGEXP[:anchor_embedded]) 
@@ -1331,70 +1422,28 @@ class Lexer
     process_attribute_entries(reader, document)
 
     metadata = {}
+    implicit_author = nil
+    implicit_authors = nil
 
     if reader.has_more_lines? && !reader.peek_line.chomp.empty?
-      author_metadata = {}
-      keys = ['author', 'authorinitials', 'firstname', 'middlename', 'lastname', 'email']
-      author_line = reader.get_line
-      author_line.split(REGEXP[:semicolon_delim]).each_with_index do |author_entry, idx|
-        author_entry.strip!
-        next if author_entry.empty?
-        map = {}
-        if idx.zero?
-          keys.each do |key|
-            map[key.to_sym] = key
-          end
-        else
-          keys.each do |key|
-            map[key.to_sym] = "#{key}_#{idx + 1}"
+      author_metadata = process_authors reader.get_line
+
+      unless author_metadata.empty?
+        # apply header subs and assign to document
+        if !document.nil?
+          author_metadata.map do |key, val|
+            val = val.is_a?(String) ? document.apply_header_subs(val) : val
+            document.attributes[key] = val if !document.attributes.has_key?(key)
+            val
           end
-        end
 
-        if match = author_entry.match(REGEXP[:author_info])
-          author_metadata[map[:firstname]] = fname = match[1].tr('_', ' ')
-          author_metadata[map[:author]] = fname
-          author_metadata[map[:authorinitials]] = fname[0, 1]
-          if !match[2].nil? && !match[3].nil?
-            author_metadata[map[:middlename]] = mname = match[2].tr('_', ' ')
-            author_metadata[map[:lastname]] = lname = match[3].tr('_', ' ')
-            author_metadata[map[:author]] = [fname, mname, lname].join ' '
-            author_metadata[map[:authorinitials]] = [fname[0, 1], mname[0, 1], lname[0, 1]].join
-          elsif !match[2].nil?
-            author_metadata[map[:lastname]] = lname = match[2].tr('_', ' ')
-            author_metadata[map[:author]] = [fname, lname].join ' '
-            author_metadata[map[:authorinitials]] = [fname[0, 1], lname[0, 1]].join
-          end
-          author_metadata[map[:email]] = match[4] unless match[4].nil?
-        else
-          author_metadata[map[:author]] = author_metadata[map[:firstname]] = author_entry.strip.squeeze(' ')
-          author_metadata[map[:authorinitials]] = author_metadata[map[:firstname]][0, 1]
+          implicit_author = document.attributes['author']
+          implicit_authors = document.attributes['authors']
         end
 
-        author_metadata['authorcount'] = idx + 1
-        # only assign the _1 attributes if there are multiple authors
-        if idx == 1
-          keys.each do |key|
-            author_metadata["#{key}_1"] = author_metadata[key] if author_metadata.has_key? key
-          end
-        end
-        if idx.zero?
-          author_metadata['authors'] = author_metadata[map[:author]]
-        else
-          author_metadata['authors'] = "#{author_metadata['authors']}, #{author_metadata[map[:author]]}"
-        end
+        metadata = author_metadata
       end
 
-      # apply header subs and assign to document
-      if !document.nil?
-        author_metadata.map do |key, val|
-          val = val.is_a?(String) ? document.apply_header_subs(val) : val
-          document.attributes[key] = val if !document.attributes.has_key?(key)
-          val
-        end
-      end
-
-      metadata = author_metadata.dup
-
       # NOTE this will discard any comment lines, but not skip blank lines
       process_attribute_entries(reader, document)
 
@@ -1412,18 +1461,18 @@ class Lexer
         end
       end
 
-      # apply header subs and assign to document
-      if !document.nil?
-        rev_metadata.map do |key, val|
-          val = document.apply_header_subs(val)
-          document.attributes[key] = val if !document.attributes.has_key?(key)
-          val
+      unless rev_metadata.empty?
+        # apply header subs and assign to document
+        if !document.nil?
+          rev_metadata.map do |key, val|
+            val = document.apply_header_subs(val)
+            document.attributes[key] = val if !document.attributes.has_key?(key)
+            val
+          end
         end
-      end
 
-      rev_metadata.each {|k, v|
-        metadata[k] = v
-      }
+        metadata.update rev_metadata
+      end
 
       # NOTE this will discard any comment lines, but not skip blank lines
       process_attribute_entries(reader, document)
@@ -1431,9 +1480,119 @@ class Lexer
       reader.skip_blank_lines
     end
 
+    if !document.nil?
+      # process author attribute entries that override (or stand in for) the implicit author line
+      author_metadata = nil
+      if document.attributes.has_key?('author') &&
+          (author_line = document.attributes['author']) != implicit_author
+        # do not allow multiple, process as names only
+        author_metadata = process_authors author_line, true, false
+      elsif document.attributes.has_key?('authors') &&
+          (author_line = document.attributes['authors']) != implicit_authors
+        # allow multiple, process as names only
+        author_metadata = process_authors author_line, true
+      else
+        authors = []
+        author_key = "author_#{authors.size + 1}"
+        while document.attributes.has_key? author_key
+          authors << document.attributes[author_key]
+          author_key = "author_#{authors.size + 1}"
+        end
+        if authors.size == 1
+          # do not allow multiple, process as names only
+          author_metadata = process_authors authors.first, true, false
+        elsif authors.size > 1
+          # allow multiple, process as names only
+          author_metadata = process_authors authors.join('; '), true
+        end
+      end
+
+      unless author_metadata.nil?
+        document.attributes.update author_metadata
+
+        # special case
+        if !document.attributes.has_key?('email') && document.attributes.has_key?('email_1')
+          document.attributes['email'] = document.attributes['email_1']
+        end
+      end
+    end
+
     metadata
   end
 
+  # Internal: Parse the author line into a Hash of author metadata
+  #
+  # author_line  - the String author line
+  # names_only   - a Boolean flag that indicates whether to process line as
+  #                names only or names with emails (default: false)
+  # multiple     - a Boolean flag that indicates whether to process multiple
+  #                semicolon-separated entries in the author line (default: true)
+  #
+  # returns a Hash of author metadata
+  def self.process_authors(author_line, names_only = false, multiple = true)
+    author_metadata = {}
+    keys = ['author', 'authorinitials', 'firstname', 'middlename', 'lastname', 'email']
+    author_entries = multiple ? author_line.split(';').map(&:strip) : [author_line]
+    author_entries.each_with_index do |author_entry, idx|
+      author_entry.strip!
+      next if author_entry.empty?
+      key_map = {}
+      if idx.zero?
+        keys.each do |key|
+          key_map[key.to_sym] = key
+        end
+      else
+        keys.each do |key|
+          key_map[key.to_sym] = "#{key}_#{idx + 1}"
+        end
+      end
+
+      segments = nil
+      if names_only
+        # splitting on ' ' will collapse repeating spaces
+        segments = author_entry.split(' ', 3)
+      elsif (match = author_entry.match(REGEXP[:author_info]))
+        segments = match.to_a
+        segments.shift
+      end
+
+      unless segments.nil?
+        author_metadata[key_map[:firstname]] = fname = segments[0].tr('_', ' ')
+        author_metadata[key_map[:author]] = fname
+        author_metadata[key_map[:authorinitials]] = fname[0, 1]
+        if !segments[1].nil? && !segments[2].nil?
+          author_metadata[key_map[:middlename]] = mname = segments[1].tr('_', ' ')
+          author_metadata[key_map[:lastname]] = lname = segments[2].tr('_', ' ')
+          author_metadata[key_map[:author]] = [fname, mname, lname].join ' '
+          author_metadata[key_map[:authorinitials]] = [fname[0, 1], mname[0, 1], lname[0, 1]].join
+        elsif !segments[1].nil?
+          author_metadata[key_map[:lastname]] = lname = segments[1].tr('_', ' ')
+          author_metadata[key_map[:author]] = [fname, lname].join ' '
+          author_metadata[key_map[:authorinitials]] = [fname[0, 1], lname[0, 1]].join
+        end
+        author_metadata[key_map[:email]] = segments[3] unless names_only || segments[3].nil?
+      else
+        author_metadata[key_map[:author]] = author_metadata[key_map[:firstname]] = fname = author_entry.strip.squeeze(' ')
+        author_metadata[key_map[:authorinitials]] = fname[0, 1]
+      end
+
+      author_metadata['authorcount'] = idx + 1
+      # only assign the _1 attributes if there are multiple authors
+      if idx == 1
+        keys.each do |key|
+          author_metadata["#{key}_1"] = author_metadata[key] if author_metadata.has_key? key
+        end
+      end
+      if idx.zero?
+        author_metadata['authors'] = author_metadata[key_map[:author]]
+      else
+        author_metadata['authors'] = "#{author_metadata['authors']}, #{author_metadata[key_map[:author]]}"
+      end
+    end
+
+    author_metadata
+  end
+
   # Internal: Parse lines of metadata until a line of metadata is not found.
   #
   # This method processes sequential lines containing block metadata, ignoring
@@ -1537,29 +1696,41 @@ class Lexer
         end
       end
 
-      if name.end_with?('!')
-        # a nil value signals the attribute should be deleted (undefined)
-        value = nil
-        name = name.chop
-      end
-
-      name = sanitize_attribute_name(name)
-      accessible = true
-      if !parent.nil?
-        accessible = value.nil? ?
-            parent.document.delete_attribute(name) :
-            parent.document.set_attribute(name, value)
-      end
-
-      if !attributes.nil?
-        Document::AttributeEntry.new(name, value).save_to(attributes) if accessible
-      end
+      store_attribute(name, value, parent.nil? ? nil : parent.document, attributes)
       true
     else
       false
     end
   end
 
+  # Public: Store the attribute in the document and register attribute entry if accessible
+  #
+  # name  - the String name of the attribute to store
+  # value - the String value of the attribute to store
+  # doc   - the Document being parsed
+  # attrs - the attributes for the current context
+  #
+  # returns a 2-element array containing the attribute name and value
+  def self.store_attribute(name, value, doc = nil, attrs = nil)
+    if name.end_with?('!')
+      # a nil value signals the attribute should be deleted (undefined)
+      value = nil
+      name = name.chop
+    end
+
+    name = sanitize_attribute_name(name)
+    accessible = true
+    unless doc.nil?
+      accessible = value.nil? ? doc.delete_attribute(name) : doc.set_attribute(name, value)
+    end
+
+    unless !accessible || attrs.nil?
+      Document::AttributeEntry.new(name, value).save_to(attrs)
+    end
+
+    [name, value]
+  end
+
   # Internal: Resolve the 0-index marker for this list item
   #
   # For ordered lists, match the marker used for this list item against the
@@ -1742,9 +1913,9 @@ class Lexer
           if parser_ctx.format == 'psv'
             next_cell_spec, cell_text = parse_cell_spec(m.pre_match, :end)
             parser_ctx.push_cell_spec next_cell_spec
-            parser_ctx.buffer << cell_text
+            parser_ctx.buffer = %(#{parser_ctx.buffer}#{cell_text})
           else
-            parser_ctx.buffer << m.pre_match
+            parser_ctx.buffer = %(#{parser_ctx.buffer}#{m.pre_match})
           end
 
           line = m.post_match
@@ -1752,10 +1923,10 @@ class Lexer
         else
           # no other delimiters to see here
           # suck up this line into the buffer and move on
-          parser_ctx.buffer << line
+          parser_ctx.buffer = %(#{parser_ctx.buffer}#{line})
           # QUESTION make this an option? (unwrap-option?)
           if parser_ctx.format == 'csv'
-            parser_ctx.buffer.rstrip!.concat(' ')
+            parser_ctx.buffer = %(#{parser_ctx.buffer.rstrip} )
           end
           line = ''
           if parser_ctx.format == 'psv' || (parser_ctx.format == 'csv' &&
@@ -1891,6 +2062,143 @@ class Lexer
     [spec, rest]
   end
 
+  # Public: Parse the first positional attribute and assign named attributes
+  #
+  # Parse the first positional attribute to extract the style, role and id
+  # parts, assign the values to their cooresponding attribute keys and return
+  # both the original style attribute and the parsed value from the first
+  # positional attribute.
+  #
+  # attributes - The Hash of attributes to process
+  #
+  # Examples
+  #
+  #   puts attributes
+  #   => {1 => "abstract#intro.lead", "style" => "preamble"}
+  #
+  #   parse_style_attribute(attributes)
+  #   => ["abstract", "preamble"]
+  #
+  #   puts attributes
+  #   => {1 => "abstract#intro.lead", "style" => "abstract", "id" => "intro", "role" => "lead"}
+  #
+  # Returns a two-element Array of the parsed style from the
+  # first positional attribute and the original style that was
+  # replaced
+  def self.parse_style_attribute(attributes)
+    original_style = attributes['style']
+    raw_style = attributes[1]
+    if !raw_style || raw_style.include?(' ')
+      attributes['style'] = raw_style
+      [raw_style, original_style]
+    # FIXME this logic could be condensed
+    else
+      hash_index = raw_style.index('#')
+      dot_index = raw_style.index('.') 
+      if !hash_index.nil? && (dot_index.nil? || hash_index < dot_index)
+        parsed_style = attributes['style'] = (hash_index > 0 ? raw_style[0..(hash_index - 1)] : nil)
+        id = raw_style[(hash_index + 1)..-1]
+        if !dot_index.nil?
+          id, roles = id.split('.', 2)
+          attributes['id'] = id
+          attributes['role'] = roles.tr('.', ' ')
+        else
+          attributes['id'] = id
+        end
+      elsif !dot_index.nil? && (hash_index.nil? || dot_index < hash_index)
+        parsed_style = attributes['style'] = (dot_index > 0 ? raw_style[0..(dot_index - 1)] : nil)
+        roles = raw_style[(dot_index + 1)..-1]
+        if !hash_index.nil?
+          roles, id = roles.split('#', 2)
+          attributes['id'] = id
+          attributes['role'] = roles.tr('.', ' ')
+        else
+          attributes['role'] = roles.tr('.', ' ')
+        end
+      else
+        parsed_style = attributes['style'] = raw_style
+      end
+
+      [parsed_style, original_style]
+    end
+  end
+
+  # Remove the indentation (block offset) shared by all the lines, then
+  # indent the lines by the specified amount if specified
+  #
+  # Trim the leading whitespace (indentation) equivalent to the length
+  # of the indent on the least indented line. If the indent argument
+  # is specified, indent the lines by this many spaces (columns).
+  # 
+  # The purpose of this method is to shift a block of text to
+  # align to the left margin, while still preserving the relative
+  # indentation between lines
+  #
+  # lines  - the Array of String lines to process
+  # indent - the integer number of spaces to add to the beginning
+  #          of each line; if this value is nil, the existing
+  #          space is preserved (optional, default: 0)
+  #
+  # Examples
+  #
+  #   source = <<EOS
+  #       def names
+  #         @name.split ' ')
+  #       end
+  #   EOS
+  #
+  #   source.lines.entries
+  #   # => ["    def names\n", "      @names.split ' '\n", "    end\n"]
+  #
+  #   Lexer.reset_block_indent(source.lines.entries)
+  #   # => ["def names\n", "  @names.split ' '\n", "end\n"]
+  #
+  #   puts Lexer.reset_block_indent(source.lines.entries).join
+  #   # => def names
+  #   # =>   @names.split ' '
+  #   # => end
+  #
+  # returns the Array of String lines with block offset removed
+  def self.reset_block_indent!(lines, indent = 0)
+    return if indent.nil? || lines.empty?
+
+    tab_detected = false
+    # TODO make tab size configurable
+    tab_expansion = '    '
+    # strip leading block indent
+    offsets = lines.map do |line|
+      # break if the first char is non-whitespace
+      break [] unless line.chomp[0..0].lstrip.empty?
+      if line.include? "\t"
+        tab_detected = true
+        line = line.gsub("\t", tab_expansion)
+      end
+      if (flush_line = line.lstrip).empty?
+        nil
+      elsif (offset = line.length - flush_line.length) == 0
+        break []
+      else
+        offset
+      end
+    end
+    
+    unless offsets.empty? || (offsets = offsets.compact).empty?
+      if (offset = offsets.min) > 0
+        lines.map! {|line|
+          line = line.gsub("\t", tab_expansion) if tab_detected
+          line[offset..-1] || "\n"
+        }
+      end
+    end
+
+    if indent > 0
+      padding = ' ' * indent
+      lines.map! {|line| %(#{padding}#{line}) }
+    end
+
+    nil
+  end
+
   # Public: Convert a string to a legal attribute name.
   #
   # name  - the String name of the attribute