asciidoctor 0.1.0 → 0.1.1

data/lib/asciidoctor/list_item.rb

@@ -1,5 +1,6 @@
+module Asciidoctor
 # Public: Methods for managing items for AsciiDoc olists, ulist, and dlists.
-class Asciidoctor::ListItem < Asciidoctor::AbstractBlock
+class ListItem < AbstractBlock
 
   # Public: Get/Set the String used to mark this list item
   attr_accessor :marker
@@ -20,7 +21,7 @@ class Asciidoctor::ListItem < Asciidoctor::AbstractBlock
 
   def text
     # this will allow the text to be processed
-    ::Asciidoctor::Block.new(self, nil, [@text]).content
+    Block.new(self, nil, [@text]).content
   end
 
   def content
@@ -39,7 +40,7 @@ class Asciidoctor::ListItem < Asciidoctor::AbstractBlock
   #
   # Returns nothing
   def fold_first(continuation_connects_first_block = false, content_adjacent = false)
-    if !blocks.empty? && blocks.first.is_a?(Asciidoctor::Block) &&
+    if !blocks.empty? && blocks.first.is_a?(Block) &&
         ((blocks.first.context == :paragraph && !continuation_connects_first_block) ||
         ((content_adjacent || !continuation_connects_first_block) && blocks.first.context == :literal &&
             blocks.first.attr('options', []).include?('listparagraph')))
@@ -56,20 +57,20 @@ class Asciidoctor::ListItem < Asciidoctor::AbstractBlock
 
   def splain(parent_level = 0)
     parent_level += 1
-    Asciidoctor.puts_indented(parent_level, "List Item anchor: #{@anchor}") unless @anchor.nil?
-    Asciidoctor.puts_indented(parent_level, "Text: #{@text}") unless @text.nil?
+    Debug.puts_indented(parent_level, "List Item anchor: #{@anchor}") unless @anchor.nil?
+    Debug.puts_indented(parent_level, "Text: #{@text}") unless @text.nil?
 
-    Asciidoctor.puts_indented(parent_level, "Blocks: #{@blocks.count}")
+    Debug.puts_indented(parent_level, "Blocks: #{@blocks.count}")
 
     if @blocks.any?
-      Asciidoctor.puts_indented(parent_level, "Blocks content (#{@blocks.count}):")
+      Debug.puts_indented(parent_level, "Blocks content (#{@blocks.count}):")
       @blocks.each_with_index do |block, i|
-        Asciidoctor.puts_indented(parent_level, "v" * (60 - parent_level*2))
-        Asciidoctor.puts_indented(parent_level, "Block ##{i} is a #{block.class}")
-        Asciidoctor.puts_indented(parent_level, "Name is #{block.title rescue 'n/a'}")
-        Asciidoctor.puts_indented(parent_level, "=" * 40)
+        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'}")
+        Debug.puts_indented(parent_level, "=" * 40)
         block.splain(parent_level) if block.respond_to? :splain
-        Asciidoctor.puts_indented(parent_level, "^" * (60 - parent_level*2))
+        Debug.puts_indented(parent_level, "^" * (60 - parent_level*2))
       end
     end
     nil
@@ -79,3 +80,4 @@ class Asciidoctor::ListItem < Asciidoctor::AbstractBlock
     "#{super.to_s} - #@context [text:#@text, blocks:#{(@blocks || []).size}]"
   end
 end
+end

data/lib/asciidoctor/reader.rb

@@ -1,23 +1,23 @@
-# Public: Methods for retrieving lines from Asciidoc documents
-class Asciidoctor::Reader
+module Asciidoctor
+# Public: Methods for retrieving lines from AsciiDoc source files
+class Reader
 
-  include Asciidoctor
-
-  # Public: Get the String document source.
+  # Public: Get the document source as a String Array of lines.
   attr_reader :source
 
-  # Public: Get the String Array of lines parsed from the source
-  attr_reader :lines
+  # Public: Get the 1-based offset of the current line.
+  attr_reader :lineno
 
   # Public: Initialize the Reader object.
   #
   # data       - The Array of Strings holding the Asciidoc source document. The
-  #              original instance of this Array is not modified
+  #              original instance of this Array is not modified (default: nil)
   # document   - The document with which this reader is associated. Used to access
-  #              document attributes
-  # overrides  - A Hash of attributes that were passed to the Document and should
-  #              prevent attribute assignments or removals of matching keys found in
-  #              the document
+  #              document attributes (default: nil)
+  # preprocess - A flag indicating whether to run the preprocessor on these lines.
+  #              Only enable for the outer-most Reader. If this argument is true,
+  #              a Document object must also be supplied.
+  #              (default: false)
   # block      - A block that can be used to retrieve external Asciidoc
   #              data to include in this document.
   #
@@ -25,33 +25,63 @@ class Asciidoctor::Reader
   #
   #   data   = File.readlines(filename)
   #   reader = Asciidoctor::Reader.new data
-  def initialize(data = [], document = nil, overrides = nil, &block)
-    # if document is nil, we assume this is a preprocessed string
-    if document.nil?
+  def initialize(data = nil, document = nil, preprocess = false, &block)
+    data = [] if data.nil?
+    # TODO use Struct to track file/lineno info; track as file changes; offset for sub-readers
+    @lineno = 0
+    if !preprocess
       @lines = data.is_a?(String) ? data.lines.entries : data.dup
+      @preprocess_source = false
     elsif !data.empty?
-      @overrides = overrides || {}
+      # NOTE we assume document is not nil!
       @document = document
-      process(data.is_a?(String) ? data.lines.entries : data, &block)
+      @preprocess_source = true
+      @include_block = block_given? ? block : nil
+      normalize_data(data.is_a?(String) ? data.lines.entries : data)
     else
       @lines = []
+      @preprocess_source = false
     end
 
-    @source = @lines.join
+    @source = @lines.dup
+
+    @next_line_preprocessed = false
+    @unescape_next_line = false
+
+    @conditionals_stack = []
+    @skipping = false
+    @eof = false
+  end
+
+  # Public: Get a copy of the remaining Array of String lines parsed from the source
+  def lines
+    @lines.nil? ? nil : @lines.dup
   end
 
   # Public: Check whether there are any lines left to read.
   #
-  # Returns true if !@lines.empty? is true, or false otherwise.
-  def has_lines?
-    !@lines.empty?
+  # If preprocessing is enabled for this Reader, and there are lines remaining,
+  # the next line is preprocessed before checking whether there are more lines. 
+  #
+  # Returns true if @lines is empty, or false otherwise.
+  def has_more_lines?
+    if @eof || (@eof = @lines.empty?)
+      false
+    elsif @preprocess_source && !@next_line_preprocessed
+      preprocess_next_line.nil? ? false : !@lines.empty?
+    else
+      true
+    end
   end
 
   # Public: Check whether this reader is empty (contains no lines)
   #
-  # Returns true if @lines.empty? is true, otherwise false.
+  # If preprocessing is enabled for this Reader, and there are lines remaining,
+  # the next line is preprocessed before checking whether there are more lines. 
+  #
+  # Returns true if @lines is empty, otherwise false.
   def empty?
-    @lines.empty?
+    !has_more_lines?
   end
 
   # Private: Strip off leading blank lines in the Array of lines.
@@ -61,25 +91,27 @@ class Asciidoctor::Reader
   #   @lines
   #   => ["\n", "\t\n", "Foo\n", "Bar\n", "\n"]
   #
-  #   skip_blank
+  #   skip_blank_lines
   #   => 2
   #
   #   @lines
   #   => ["Foo\n", "Bar\n"]
   #
   # Returns an Integer of the number of lines skipped
-  def skip_blank
+  def skip_blank_lines
     skipped = 0
-    while has_lines? && @lines.first.strip.empty?
-      @lines.shift
-      skipped += 1
-    end
+    # optimized code for shortest execution path
+    while !(next_line = get_line).nil?
+      if next_line.chomp.empty?
+        skipped += 1
+      else
+        unshift_line next_line
+        break
+      end
+    end 
 
     skipped
   end
-  # Create alias of skip_blank named skip_blank_lines for readability
-  # TODO likely want to drop the original method name
-  alias :skip_blank_lines :skip_blank
 
   # Public: Consume consecutive lines containing line- or block-level comments.
   #
@@ -94,25 +126,27 @@ class Asciidoctor::Reader
   #
   #   @lines
   #   => ["actual text\n"]
-  def consume_comments(opts = {})
+  def consume_comments(options = {})
     comment_lines = []
-    while !@lines.empty?
-      next_line = peek_line
-      if opts[:include_blanks] && next_line.strip.empty?
-        comment_lines << get_line
-      elsif match = next_line.match(REGEXP[:comment_blk])
-        comment_lines << get_line
-        comment_lines.push(*(grab_lines_until(:terminator => match[0], :preserve_last_line => true)))
-        comment_lines << get_line
-      elsif next_line.match(REGEXP[:comment])
-        comment_lines << get_line
+    preprocess = options.fetch(:preprocess, true)
+    while !(next_line = get_line(preprocess)).nil?
+      if options[:include_blank_lines] && next_line.chomp.empty?
+        comment_lines << next_line
+      elsif (commentish = next_line.start_with?('//')) && (match = next_line.match(REGEXP[:comment_blk]))
+        comment_lines << next_line
+        comment_lines.push(*(grab_lines_until(:terminator => match[0], :grab_last_line => true, :preprocess => false)))
+      elsif commentish && next_line.match(REGEXP[:comment])
+        comment_lines << next_line
       else
+        # throw it back
+        unshift_line next_line
         break
       end
     end
 
     comment_lines
   end
+  alias :skip_comment_lines :consume_comments
 
   # Public: Consume consecutive lines containing line comments.
   #
@@ -129,10 +163,12 @@ class Asciidoctor::Reader
   #   => ["bar\n"]
   def consume_line_comments
     comment_lines = []
-    while !@lines.empty?
-      if peek_line.match(REGEXP[:comment])
-        comment_lines << get_line
+    # optimized code for shortest execution path
+    while !(next_line = get_line).nil?
+      if next_line.match(REGEXP[:comment])
+        comment_lines << next_line
       else
+        unshift_line next_line
         break
       end
     end
@@ -140,41 +176,302 @@ class Asciidoctor::Reader
     comment_lines
   end
 
-  # Skip the next line if it's a list continuation character
-  # 
-  # Returns nil
-  def skip_list_continuation
-    if has_lines? && @lines.first.chomp == '+'
-      @lines.shift
-    end
-
-    nil
-  end
-
   # Public: Get the next line of source data. Consumes the line returned.
   #
+  # preprocess - A Boolean flag indicating whether to evaluate preprocessing
+  #              directives (macros) before reading line (default: true)
+  #
   # Returns the String of the next line of the source data if data is present.
   # Returns nil if there is no more data.
-  def get_line
-    @lines.shift
+  def get_line(preprocess = true)
+    if @eof || (@eof = @lines.empty?)
+      @next_line_preprocessed = true
+      nil
+    elsif preprocess && @preprocess_source &&
+        !@next_line_preprocessed && preprocess_next_line.nil?
+      @next_line_preprocessed = true
+      nil
+    else
+      @lineno += 1
+      @next_line_preprocessed = false
+      if @unescape_next_line
+        @unescape_next_line = false
+        @lines.shift[1..-1]
+      else
+        @lines.shift
+      end
+    end
+  end
+
+  # Public: Advance to the next line by discarding the line at the front of the stack
+  #
+  # Removes the line at the front of the stack without any processing.
+  #
+  # returns a boolean indicating whether there was a line to discard
+  def advance
+    @next_line_preprocessed = false
+    # we assume that we're advancing over a line of known content
+    if @eof || (@eof = @lines.empty?)
+      false
+    else
+      @lineno += 1
+      @lines.shift
+      true
+    end
   end
-  # QUESTION what about advance?
-  # Create an alias of get_line named next_line for readability
-  alias :next_line :get_line
 
   # Public: Get the next line of source data. Does not consume the line returned.
   #
+  # preprocess - A Boolean flag indicating whether to evaluate preprocessing
+  #              directives (macros) before reading line (default: true)
+  #
   # Returns a String dup of the next line of the source data if data is present.
   # Returns nil if there is no more data.
-  def peek_line
-    @lines.first.dup if @lines.first
+  def peek_line(preprocess = true)
+    if !preprocess
+      # QUESTION do we need to dup?
+      @eof || (@eof = @lines.empty?) ? nil : @lines.first.dup
+    elsif has_more_lines?
+      # QUESTION do we need to dup?
+      @lines.first.dup
+    else
+      nil
+    end
+  end
+
+  # TODO document & test me!
+  def peek_lines(number = 1)
+    lines = []
+    idx = 0
+    (1..number).each do
+      if @preprocess_source && !@next_line_preprocessed
+        advanced = preprocess_next_line
+        break if advanced.nil? || @eof || (@eof = @lines.empty?)
+        idx = 0 if advanced
+      end
+      break if idx >= @lines.size
+      # QUESTION do we need to dup?
+      lines << @lines[idx].dup
+      idx += 1
+    end
+    lines
+  end
+
+  # Internal: Preprocess the next line until the cursor is at a line of content
+  #
+  # Evaluate preprocessor macros on the next line, continuing to do so until
+  # the cursor arrives at a line of included content. That line is marked as
+  # preprocessed so that preprocessing is not performed multiple times.
+  #
+  # returns a Boolean indicating whether the cursor advanced, or nil if there
+  # are no more lines available.
+  def preprocess_next_line
+    # this return could be happening from a recursive call
+    return nil if @eof || (next_line = @lines.first).nil?
+    if next_line.include?('if') && (match = next_line.match(REGEXP[:ifdef_macro]))
+      if next_line.start_with? '\\'
+        @next_line_preprocessed = true
+        @unescape_next_line = true
+        false
+      else
+        preprocess_conditional_inclusion(*match.captures)
+      end
+    elsif @skipping
+      advance
+      # skip over comment blocks, we don't want to process directives in them
+      skip_comment_lines :include_blank_lines => true, :preprocess => false
+      preprocess_next_line.nil? ? nil : true
+    elsif next_line.include?('include::') && match = next_line.match(REGEXP[:include_macro])
+      if next_line.start_with? '\\'
+        @next_line_preprocessed = true
+        @unescape_next_line = true
+        false
+      else
+        preprocess_include(match[1])
+      end
+    else
+      @next_line_preprocessed = true
+      false
+    end
   end
 
-  # Public: Push Array of string `lines` onto queue of source data lines, unless `lines` has no non-nil values.
+  # Internal: Preprocess the directive (macro) to conditionally include content.
+  #
+  # Preprocess the conditional inclusion directive (ifdef, ifndef, ifeval,
+  # endif) under the cursor. If the Reader is currently skipping content, then
+  # simply track the open and close delimiters of any nested conditional
+  # blocks. If the Reader is not skipping, mark whether the condition is
+  # satisfied and continue preprocessing recursively until the next line of
+  # available content is found.
+  #
+  # directive  - The conditional inclusion directive (ifdef, ifndef, ifeval, endif)
+  # target     - The target, which is the name of one or more attributes that are
+  #              used in the condition (blank in the case of the ifeval directive)
+  # delimiter  - The conditional delimiter for multiple attributes ('+' means all
+  #              attributes must be defined or undefined, ',' means any of the attributes
+  #              can be defined or undefined.
+  # text       - The text associated with this directive (occurring between the square brackets)
+  #              Used for a single-line conditional block in the case of the ifdef or
+  #              ifndef directives, and for the conditional expression for the ifeval directive.
+  #
+  # returns a Boolean indicating whether the cursor advanced, or nil if there
+  # are no more lines available.
+  def preprocess_conditional_inclusion(directive, target, delimiter, text)
+    # must have a target before brackets if ifdef or ifndef
+    # must not have text between brackets if endif
+    # don't honor match if it doesn't meet this criteria
+    if ((directive == 'ifdef' || directive == 'ifndef') && target.empty?) ||
+        (directive == 'endif' && !text.nil?)
+      @next_line_preprocessed = true
+      return false
+    end
+
+    if directive == 'endif'
+      stack_size = @conditionals_stack.size
+      if stack_size > 0
+        pair = @conditionals_stack.last
+        if target.empty? || target == pair[:target]
+          @conditionals_stack.pop
+          @skipping = @conditionals_stack.empty? ? false : @conditionals_stack.last[:skipping]
+        else
+          puts "asciidoctor: ERROR: line #{@lineno + 1}: mismatched macro: endif::#{target}[], expected endif::#{pair[:target]}[]"
+        end
+      else
+        puts "asciidoctor: ERROR: line #{@lineno + 1}: unmatched macro: endif::#{target}[]"
+      end
+      advance
+      return preprocess_next_line.nil? ? nil : true
+    end
+
+    skip = nil
+    if !@skipping
+      case directive
+      when 'ifdef'
+        case delimiter
+        when nil
+          # if the attribute is undefined, then skip
+          skip = !@document.attributes.has_key?(target)
+        when ','
+          # if any attribute is defined, then don't skip
+          skip = !target.split(',').detect {|name| @document.attributes.has_key? name }
+        when '+'
+          # if any attribute is undefined, then skip
+          skip = target.split('+').detect {|name| !@document.attributes.has_key? name }
+        end
+      when 'ifndef'
+        case delimiter
+        when nil
+          # if the attribute is defined, then skip
+          skip = @document.attributes.has_key?(target)
+        when ','
+          # if any attribute is undefined, then don't skip
+          skip = !target.split(',').detect {|name| !@document.attributes.has_key? name }
+        when '+'
+          # if any attribute is defined, then skip
+          skip = target.split('+').detect {|name| @document.attributes.has_key? name }
+        end
+      when 'ifeval'
+        # the text in brackets must match an expression
+        # don't honor match if it doesn't meet this criteria
+        if !target.empty? || !(expr_match = text.strip.match(REGEXP[:eval_expr]))
+          @next_line_preprocessed = true
+          return false
+        end
+
+        lhs = resolve_expr_val(expr_match[1])
+        op = expr_match[2]
+        rhs = resolve_expr_val(expr_match[3])
+
+        skip = !lhs.send(op.to_sym, rhs)
+      end
+      @skipping = skip
+    end
+    advance
+    # single line conditional inclusion
+    if directive != 'ifeval' && !text.nil?
+      if !@skipping
+        unshift_line "#{text.rstrip}\n"
+        return true
+      end
+    # conditional inclusion block
+    else
+      @conditionals_stack << {:target => target, :skip => skip, :skipping => @skipping}
+    end
+    return preprocess_next_line.nil? ? nil : true
+  end
+
+  # Internal: Preprocess the directive (macro) to include the target document.
+  #
+  # Preprocess the directive to include the target document. The scenarios
+  # are as follows:
+  #
+  # If SafeMode is SECURE or greater, the directive is ignore and the include
+  # directive line is emitted verbatim.
+  #
+  # Otherwise, if an include handler is specified (currently controlled by a
+  # closure block), pass the target to that block and expect an Array of String
+  # lines in return.
+  #
+  # Otherwise, if the include-depth attribute is greater than 0, normalize the
+  # target path and read the lines onto the beginning of the Array of source
+  # data.
+  #
+  # If none of the above apply, emit the include directive line verbatim.
+  #
+  # target - The name of the source document to include as specified in the
+  #          target slot of the include::[] macro
+  #
+  # returns a Boolean indicating whether the line under the cursor has changed.
+  def preprocess_include(target)
+    # if running in SafeMode::SECURE or greater, don't process this directive
+    if @document.safe >= SafeMode::SECURE
+      @next_line_preprocessed = true
+      false
+    # assume that if a block is given, the developer wants
+    # to handle when and how to process the include, even
+    # if the include-depth attribute is 0
+    elsif @include_block
+      advance
+      # FIXME this borks line numbers
+      @lines.unshift(*@include_block.call(target).map {|l| "#{l.rstrip}\n"})
+    # FIXME currently we're not checking the upper bound of the include depth
+    elsif @document.attributes.fetch('include-depth', 0).to_i > 0
+      advance
+      # FIXME this borks line numbers
+      @lines.unshift(*File.readlines(@document.normalize_asset_path(target, 'include file')).map {|l| "#{l.rstrip}\n"})
+      true
+    else
+      @next_line_preprocessed = true
+      false
+    end
+  end
+
+  # Public: Push the String line onto the beginning of the Array of source data.
+  #
+  # Since this line was (assumed to be) previously retrieved through the
+  # reader, it is marked as preprocessed.
+  #
+  # returns nil
+  def unshift_line(line)
+    @lines.unshift line
+    @next_line_preprocessed = true
+    @eof = false
+    @lineno -= 1
+    nil
+  end
+
+  # Public: Push Array of lines onto the front of the Array of source data, unless `lines` has no non-nil values.
   #
   # Returns nil
   def unshift(*new_lines)
-    @lines.unshift(*new_lines) if !new_lines.empty?
+    size = new_lines.size
+    if size > 0
+      @lines.unshift(*new_lines)
+      # assume that what we are putting back on is already processed for directives
+      @next_line_preprocessed = true
+      @eof = false
+      @lineno -= size
+    end
     nil
   end
 
@@ -184,7 +481,7 @@ class Asciidoctor::Reader
   #
   # Returns nil
   def chomp_last!
-    @lines.last.chomp! unless @lines.empty?
+    @lines.last.chomp! unless @eof || (@eof = @lines.empty?)
     nil
   end
 
@@ -218,27 +515,27 @@ class Asciidoctor::Reader
     buffer = []
 
     finis = false
-    get_line if options[:skip_first_line]
+    advance if options[:skip_first_line]
     # save options to locals for minor optimization
     terminator = options[:terminator]
     terminator.chomp! if terminator
     break_on_blank_lines = options[:break_on_blank_lines]
     break_on_list_continuation = options[:break_on_list_continuation]
-    while (this_line = self.get_line)
-      Asciidoctor.debug { "Reader processing line: '#{this_line}'" }
+    skip_line_comments = options[:skip_line_comments]
+    preprocess = options.fetch(:preprocess, true)
+    while !(this_line = get_line(preprocess)).nil?
+      Debug.debug { "Reader processing line: '#{this_line}'" }
       finis = true if terminator && this_line.chomp == terminator
       finis = true if !finis && break_on_blank_lines && this_line.strip.empty?
       finis = true if !finis && break_on_list_continuation && this_line.chomp == LIST_CONTINUATION
       finis = true if !finis && block && yield(this_line)
       if finis
-        self.unshift(this_line) if options[:preserve_last_line]
         buffer << this_line if options[:grab_last_line]
+        unshift_line(this_line) if options[:preserve_last_line]
         break
       end
 
-      if options[:skip_line_comments] && this_line.match(REGEXP[:comment])
-        # skip it
-      else
+      unless skip_line_comments && this_line.match(REGEXP[:comment])
         buffer << this_line
       end
     end
@@ -263,109 +560,63 @@ class Asciidoctor::Reader
   #   sanitize_attribute_name('Foo 3 #-Billy')
   #   => 'foo3-billy'
   def sanitize_attribute_name(name)
-    name.gsub(/[^\w\-]/, '').downcase
+    Lexer.sanitize_attribute_name(name)
   end
 
-  # Private: Process raw input, used for the outermost reader.
-  def process(data, &block)
-    raw_source = []
-    include_depth = @document.attr('include-depth', 0).to_i
-
-    data.each do |line|
-      if inc = line.match(REGEXP[:include_macro])
-        if inc[0].start_with? '\\'
-          raw_source << line[1..-1]
-        # if running in SafeMode::SECURE or greater, don't process
-        # this directive (or should we swallow it?)
-        elsif @document.safe >= SafeMode::SECURE
-          raw_source << line
-        # assume that if a block is given, the developer wants
-        # to handle when and how to process the include, even
-        # if the include-depth attribute is 0
-        elsif block_given?
-          raw_source.concat yield(inc[1])
-        elsif include_depth > 0
-          raw_source.concat File.readlines(@document.normalize_asset_path(inc[1], 'include file'))
-        else
-          raw_source << line
-        end
-      else
-        raw_source << line
-      end
+  # Private: Resolve the value of one side of the expression
+  def resolve_expr_val(str)
+    val = str
+    type = nil
+
+    if val.start_with?('"') && val.end_with?('"') ||
+        val.start_with?('\'') && val.end_with?('\'')
+      type = :s
+      val = val[1..-2]
     end
 
-    skip_to = nil
-    continuing_value = nil
-    continuing_key = nil
-    @lines = []
-
-    raw_source.each do |line|
-      # normalize line ending to LF (purging occurrences of CRLF)
-      line = "#{line.rstrip}\n"
-      if skip_to
-        skip_to = nil if line.match(skip_to)
-      elsif continuing_value
-        close_continue = false
-        # Lines that start with whitespace and end with a '+' are
-        # a continuation, so gobble them up into `value`
-        if line.match(REGEXP[:attr_continue])
-          continuing_value += ' ' + $1.rstrip
-        # An empty line ends a continuation
-        elsif line.strip.empty?
-          raw_source.unshift(line)
-          close_continue = true
-        else
-          # If this continued line isn't empty and doesn't end with a +, then
-          # this is the end of the continuation, no matter what the next line
-          # does.
-          continuing_value += ' ' + line.strip
-          close_continue = true
-        end
-        if close_continue
-          unless attribute_overridden? continuing_key
-            @document.attributes[continuing_key] = apply_attribute_value_subs(continuing_value)
-          end
-          continuing_key = nil
-          continuing_value = nil
-        end
-      elsif line.match(REGEXP[:ifdef_macro])
-        attr = $2
-        skip = case $1
-               when 'ifdef';  !@document.attributes.has_key?(attr)
-               when 'ifndef'; @document.attributes.has_key?(attr)
-               end
-        skip_to = /^endif::#{attr}\[\]\s*\n/ if skip
-      elsif line.match(REGEXP[:attr_assign])
-        key = sanitize_attribute_name($1)
-        value = $2
-        if value.match(REGEXP[:attr_continue])
-          # attribute value continuation line; grab lines until we run out
-          # of continuation lines
-          continuing_key = key
-          continuing_value = $1.rstrip  # strip off the spaces and +
-        else
-          unless attribute_overridden? key
-            @document.attributes[key] = apply_attribute_value_subs(value)
-            if key == 'backend'
-              @document.update_backend_attributes()
-            end
-          end
-        end
-      elsif line.match(REGEXP[:attr_delete])
-        key = sanitize_attribute_name($1)
-        unless attribute_overridden? key
-          @document.attributes.delete(key)
-        end
-      elsif !line.match(REGEXP[:endif_macro])
-        while line.match(REGEXP[:attr_conditional])
-          value = @document.attributes.has_key?($1) ? $2 : ''
-          line.sub!(REGEXP[:attr_conditional], value)
-        end
-        # NOTE leave line comments in as they play a role in flow (such as a list divider)
-        @lines << line
+    if val.include? '{'
+      val = @document.sub_attributes(val)
+    end
+
+    if type != :s
+      if val.empty?
+        val = nil
+      elsif val == 'true'
+        val = true
+      elsif val == 'false'
+        val = false
+      elsif val.include?('.')
+        val = val.to_f
+      else
+        val = val.to_i
       end
     end
 
+    val
+  end
+
+  # Private: Normalize raw input, used for the outermost Reader.
+  #
+  # This method strips whitespace from the end of every line of
+  # the source data and appends a LF (i.e., Unix endline). This
+  # whitespace substitution is very important to how Asciidoctor
+  # works.
+  #
+  # Any leading or trailing blank lines are also removed.
+  #
+  # The normalized lines are assigned to the @lines instance variable.
+  #
+  # data - A String Array of input data to be normalized
+  #
+  # returns nothing
+  def normalize_data(data)
+    # normalize line ending to LF (purging occurrences of CRLF)
+    # this rstrip is *very* important to how Asciidoctor works
+    @lines = data.map {|line| "#{line.rstrip}\n" }
+
+    @lines.shift && @lineno += 1 while !@lines.first.nil? && @lines.first.chomp.empty?
+    @lines.pop while !@lines.last.nil? && @lines.last.chomp.empty?
+
     # Process bibliography references, so they're available when text
     # before the reference is being rendered.
     # FIXME we don't have support for bibliography lists yet, so disable for now
@@ -375,41 +626,7 @@ class Asciidoctor::Reader
     #    @document.register(:ids, biblio[1])
     #  end
     #end
+    nil
   end
-
-  # Internal: Determine if the attribute has been overridden in the document options
-  #
-  # key - The attribute key to check
-  #
-  # Returns true if the attribute has been overridden, false otherwise
-  def attribute_overridden?(key)
-    @overrides.has_key?(key) || @overrides.has_key?(key + '!')
-  end
-
-  # Internal: Apply substitutions to the attribute value
-  #
-  # If the value is an inline passthrough macro (e.g., pass:[text]), then
-  # apply the substitutions defined on the macro to the text. Otherwise,
-  # apply the verbatim substitutions to the value.
-  #
-  # value - The String attribute value on which to perform substitutions
-  #
-  # Returns The String value with substitutions performed.
-  def apply_attribute_value_subs(value)
-    if value.match(REGEXP[:pass_macro_basic])
-      # copy match for Ruby 1.8.7 compat
-      m = $~
-      subs = []
-      if !m[1].empty?
-        subs = @document.resolve_subs(m[1])
-      end
-      if !subs.empty?
-        @document.apply_subs(m[2], subs)
-      else
-        m[2]
-      end
-    else
-      @document.apply_header_subs(value)
-    end
-  end
+end
 end