asciidoctor 0.0.7 → 0.0.9

data/lib/asciidoctor/list_item.rb

@@ -1,26 +1,21 @@
 # Public: Methods for managing items for AsciiDoc olists, ulist, and dlists.
-class Asciidoctor::ListItem
-  # Public: Get the Array of Blocks from the list item's continuation.
-  attr_reader :blocks
+class Asciidoctor::ListItem < Asciidoctor::AbstractBlock
 
-  # Public: Get/Set the String list item anchor name.
-  attr_accessor :anchor
-
-  # Public: Get/Set the Integer list level (for nesting list elements).
-  attr_accessor :level
+  # Public: Get/Set the String used to mark this list item
+  attr_accessor :marker
 
   # Public: Initialize an Asciidoctor::ListItem object.
   #
   # parent - The parent list block for this list item
-  # text - the String text (default '')
-  def initialize(parent, text='')
-    @parent = parent
+  # text - the String text (default nil)
+  def initialize(parent, text = nil)
+    super(parent, :list_item)
     @text = text
-    @blocks = []
+    @level = parent.level
   end
 
-  def text=(new_text)
-    @text = new_text
+  def text?
+    !@text.to_s.empty?
   end
 
   def text
@@ -28,35 +23,35 @@ class Asciidoctor::ListItem
     ::Asciidoctor::Block.new(self, nil, [@text]).content
   end
 
-  def document
-    @parent.document
-  end
-
   def content
-    # create method for !blocks.empty?
-    if !blocks.empty?
-      blocks.map{|block| block.render}.join
-    else
-      nil
-    end
+    blocks? ? blocks.map {|b| b.render }.join : nil
   end
 
   # Public: Fold the first paragraph block into the text
-  def fold_first
-    # looking for :literal here allows indentation of paragraph content, then strip indent
+  #
+  # Here are the rules for when a folding occurs:
+  #
+  # Given: this list item has at least one block
+  # When: the first block is a paragraph that's not connected by a list continuation
+  # Or: the first block is an indented paragraph that's adjacent (wrapped line)
+  # Or: the first block is an indented paragraph that's not connected by a list continuation
+  # Then: then drop the first block and fold it's content (buffer) into the list text
+  #
+  # Returns nothing
+  def fold_first(continuation_connects_first_block = false, content_adjacent = false)
     if !blocks.empty? && blocks.first.is_a?(Asciidoctor::Block) &&
-        (blocks.first.context == :paragraph || blocks.first.context == :literal)
+        ((blocks.first.context == :paragraph && !continuation_connects_first_block) ||
+        ((content_adjacent || !continuation_connects_first_block) && blocks.first.context == :literal &&
+            blocks.first.attr('options', []).include?('listparagraph')))
+
       block = blocks.shift
-      if !@text.nil? && !@text.empty?
+      unless @text.to_s.empty?
         block.buffer.unshift(@text)
       end
 
-      if block.context == :literal
-        @text = block.buffer.map {|l| l.lstrip}.join("\n")
-      else
-        @text = block.buffer.join("\n")
-      end
+      @text = block.buffer.join("\n")
     end
+    nil
   end
 
   def splain(parent_level = 0)
@@ -71,7 +66,7 @@ class Asciidoctor::ListItem
       @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.name rescue 'n/a'}")
+        Asciidoctor.puts_indented(parent_level, "Name is #{block.title rescue 'n/a'}")
         Asciidoctor.puts_indented(parent_level, "=" * 40)
         block.splain(parent_level) if block.respond_to? :splain
         Asciidoctor.puts_indented(parent_level, "^" * (60 - parent_level*2))
@@ -79,4 +74,8 @@ class Asciidoctor::ListItem
     end
     nil
   end
+
+  def to_s
+    "#{super.to_s} - #@context [text:#@text, blocks:#{(@blocks || []).size}]"
+  end
 end

data/lib/asciidoctor/reader.rb

@@ -9,155 +9,55 @@ class Asciidoctor::Reader
   # Public: Get the String Array of lines parsed from the source
   attr_reader :lines
 
-  # Public: Get the Hash of attributes
-  attr_reader :attributes
-
-  attr_reader :references
-
-  # Public: Convert a string to a legal attribute name.
-  #
-  # name  - The String holding the Asciidoc attribute name.
-  #
-  # Returns a String with the legal name.
-  #
-  # Examples
-  #
-  #   sanitize_attribute_name('Foo Bar')
-  #   => 'foobar'
-  #
-  #   sanitize_attribute_name('foo')
-  #   => 'foo'
-  #
-  #   sanitize_attribute_name('Foo 3 #-Billy')
-  #   => 'foo3-billy'
-  def sanitize_attribute_name(name)
-    name.gsub(/[^\w\-_]/, '').downcase
-  end
-
   # Public: Initialize the Reader object.
   #
-  # data  - The Array of Strings holding the Asciidoc source document.
-  # block - A block that can be used to retrieve external Asciidoc
-  #         data to include in this document.
+  # data       - The Array of Strings holding the Asciidoc source document. The
+  #              original instance of this Array is not modified
+  # 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
+  # block      - A block that can be used to retrieve external Asciidoc
+  #              data to include in this document.
   #
   # Examples
   #
   #   data   = File.readlines(filename)
-  #   reader = Asciidoctor::Reader.new(data)
-  def initialize(data = [], attributes = {}, &block)
-    raw_source = []
-    @attributes = attributes
-    @references = {}
-
-    data = data.split("\n") if data.is_a? String
-
-    include_regexp = /^include::([^\[]+)\[\]\s*\n?\z/
-
-    data.each do |line|
-      if inc = line.match(include_regexp)
-        if block_given?
-          raw_source << yield(inc[1])
-        else
-          raw_source.concat(File.readlines(inc[1]))
-        end
-      else
-        raw_source << line
-      end
-    end
-
-    ifdef_regexp = /^(ifdef|ifndef)::([^\[]+)\[\]/
-    endif_regexp = /^endif::/
-    defattr_regexp = /^:([^:!]+):\s*(.*)\s*$/
-    delete_attr_regexp = /^:([^:]+)!:\s*$/
-    conditional_regexp = /^\s*\{([^\?]+)\?\s*([^\}]+)\s*\}/
-
-    skip_to = nil
-    continuing_value = nil
-    continuing_key = nil
-    @lines = []
-    raw_source.each do |line|
-      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 match = line.match(/\s+(.+)\s+\+\s*$/)
-          continuing_value += ' ' + match[1]
-        elsif match = line.match(/\s+(.+)/)
-          # If this continued line doesn't end with a +, then this
-          # is the end of the continuation, no matter what the next
-          # line does.
-          continuing_value += ' ' + match[1]
-          close_continue = true
-        else
-          # If this line doesn't start with whitespace, then it's
-          # not a valid continuation line, so push it back for processing
-          close_continue = true
-          raw_source.unshift(line)
-        end
-        if close_continue
-          @attributes[continuing_key] = continuing_value
-          continuing_key = nil
-          continuing_value = nil
-        end
-      elsif match = line.match(ifdef_regexp)
-        attr = match[2]
-        skip = case match[1]
-               when 'ifdef';  !@attributes.has_key?(attr)
-               when 'ifndef'; @attributes.has_key?(attr)
-               end
-        skip_to = /^endif::#{attr}\[\]\s*\n/ if skip
-      elsif match = line.match(defattr_regexp)
-        key = sanitize_attribute_name(match[1])
-        value = match[2]
-        if match = value.match(Asciidoctor::REGEXP[:attr_continue])
-          # attribute value continuation line; grab lines until we run out
-          # of continuation lines
-          continuing_key = key
-          continuing_value = match[1]  # strip off the spaces and +
-          Asciidoctor.debug "continuing key: #{continuing_key} with partial value: '#{continuing_value}'"
-        else
-          @attributes[key] = value
-          Asciidoctor.debug "Defines[#{key}] is '#{value}'"
-        end
-      elsif match = line.match(delete_attr_regexp)
-        key = sanitize_attribute_name(match[1])
-        @attributes.delete(key)
-      elsif !line.match(endif_regexp)
-        while match = line.match(conditional_regexp)
-          value = @attributes.has_key?(match[1]) ? match[2] : ''
-          line.sub!(conditional_regexp, value)
-        end
-        # leave line comments in as they play a role in flow (such as a list divider)
-        @lines << line
-      end
+  #   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?
+      @lines = data.is_a?(String) ? data.lines.entries : data.dup
+    elsif !data.empty?
+      @overrides = overrides || {}
+      @document = document
+      process(data.is_a?(String) ? data.lines.entries : data, &block)
+    else
+      @lines = []
     end
 
-    # Process bibliography references, so they're available when text
-    # before the reference is being rendered.
-    @lines.each do |line|
-      if biblio = line.match(REGEXP[:biblio])
-        @references[biblio[1]] = "[#{biblio[1]}]"
-      end
-    end
+    # just in case we got some nils floating at the end of our lines after reading a funky document
+    @lines.pop until @lines.empty? || !@lines.last.nil?
 
-    #Asciidoctor.debug "About to leave Reader#init, and references is #{@references.inspect}"
     @source = @lines.join
-    Asciidoctor.debug "Leaving Reader#init, and I have #{@lines.count} lines"
-    Asciidoctor.debug "Also, has_lines? is #{self.has_lines?}"
   end
 
   # Public: Check whether there are any lines left to read.
   #
-  # Returns true if @lines.any? is true, or false otherwise.
+  # Returns true if !@lines.empty? is true, or false otherwise.
   def has_lines?
-    @lines.any?
+    !@lines.empty?
   end
 
-  # Private: Strip off leading blank lines in the Array of lines.
+  # Public: Check whether this reader is empty (contains no lines)
   #
-  # Returns nil.
+  # Returns true if @lines.empty? is true, otherwise false.
+  def empty?
+    @lines.empty?
+  end
+
+  # Private: Strip off leading blank lines in the Array of lines.
   #
   # Examples
   #
@@ -165,23 +65,89 @@ class Asciidoctor::Reader
   #   => ["\n", "\t\n", "Foo\n", "Bar\n", "\n"]
   #
   #   skip_blank
-  #   => nil
+  #   => 2
   #
   #   @lines
   #   => ["Foo\n", "Bar\n"]
+  #
+  # Returns an Integer of the number of lines skipped
   def skip_blank
-    while @lines.any? && @lines.first.strip.empty?
+    skipped = 0
+    while has_lines? && @lines.first.strip.empty?
       @lines.shift
+      skipped += 1
     end
 
-    nil
+    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.
+  #
+  # Returns the Array of lines that were consumed
+  #
+  # Examples
+  #   @lines
+  #   => ["// foo\n", "////\n", "foo bar\n", "////\n", "actual text\n"]
+  #
+  #   comment_lines = consume_comments
+  #   => ["// foo\n", "////\n", "foo bar\n", "////\n"]
+  #
+  #   @lines
+  #   => ["actual text\n"]
+  def consume_comments(opts = {})
+    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
+      else
+        break
+      end
+    end
+
+    comment_lines
+  end
+
+  # Public: Consume consecutive lines containing line comments.
+  #
+  # Returns the Array of lines that were consumed
+  #
+  # Examples
+  #   @lines
+  #   => ["// foo\n", "bar\n"]
+  #
+  #   comment_lines = consume_comments
+  #   => ["// foo\n"]
+  #
+  #   @lines
+  #   => ["bar\n"]
+  def consume_line_comments
+    comment_lines = []
+    while !@lines.empty?
+      if peek_line.match(REGEXP[:comment])
+        comment_lines << get_line
+      else
+        break
+      end
+    end
+
+    comment_lines
   end
 
   # Skip the next line if it's a list continuation character
   # 
   # Returns nil
   def skip_list_continuation
-    if !@lines.empty? && @lines.first.chomp == '+'
+    if has_lines? && @lines.first.chomp == '+'
       @lines.shift
     end
 
@@ -195,6 +161,9 @@ class Asciidoctor::Reader
   def get_line
     @lines.shift
   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.
   #
@@ -204,11 +173,21 @@ class Asciidoctor::Reader
     @lines.first.dup if @lines.first
   end
 
-  # Public: Push String `line` onto queue of source data lines, unless `line` is nil.
+  # Public: Push Array of string `lines` onto queue of source data lines, unless `lines` has no non-nil values.
   #
   # Returns nil
-  def unshift(line)
-    @lines.unshift(line) if line
+  def unshift(*new_lines)
+    @lines.unshift(*new_lines) if !new_lines.empty?
+    nil
+  end
+
+  # Public: Chomp the String on the last line if this reader contains at least one line
+  #
+  # Delegates to chomp!
+  #
+  # Returns nil
+  def chomp_last!
+    @lines.last.chomp! unless @lines.empty?
     nil
   end
 
@@ -219,9 +198,14 @@ class Asciidoctor::Reader
   # options - an optional Hash of processing options:
   #           * :break_on_blank_lines may be used to specify to break on
   #               blank lines
+  #           * :skip_first_line may be used to tell the reader to advance
+  #               beyond the first line before beginning the scan
   #           * :preserve_last_line may be used to specify that the String
   #               causing the method to stop processing lines should be
   #               pushed back onto the `lines` Array.
+  #           * :grab_last_line may be used to specify that the String
+  #               causing the method to stop processing lines should be
+  #               included in the lines being returned
   #
   # Returns the Array of lines forming the next segment.
   #
@@ -236,18 +220,197 @@ class Asciidoctor::Reader
   def grab_lines_until(options = {}, &block)
     buffer = []
 
+    finis = false
+    get_line 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 "Processing line: '#{this_line}'"
-      finis ||= true if options[:break_on_blank_lines] && this_line.strip.empty?
-      finis ||= true if block && value = yield(this_line)
+      Asciidoctor.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]
         break
       end
 
-      buffer << this_line
+      if options[:skip_line_comments] && this_line.match(REGEXP[:comment])
+        # skip it
+      else
+        buffer << this_line
+      end
     end
+
     buffer
   end
 
+  # Public: Convert a string to a legal attribute name.
+  #
+  # name  - The String holding the Asciidoc attribute name.
+  #
+  # Returns a String with the legal name.
+  #
+  # Examples
+  #
+  #   sanitize_attribute_name('Foo Bar')
+  #   => 'foobar'
+  #
+  #   sanitize_attribute_name('foo')
+  #   => 'foo'
+  #
+  #   sanitize_attribute_name('Foo 3 #-Billy')
+  #   => 'foo3-billy'
+  def sanitize_attribute_name(name)
+    name.gsub(/[^\w\-]/, '').downcase
+  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
+    end
+
+    skip_to = nil
+    continuing_value = nil
+    continuing_key = nil
+    @lines = []
+
+    raw_source.each do |line|
+      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
+        # 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  # 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!(conditional_regexp, value)
+        end
+        # leave line comments in as they play a role in flow (such as a list divider)
+        @lines << line
+      end
+    end
+
+    # 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
+    # plus, this should be done while we are walking lines above
+    #@lines.each do |line|
+    #  if biblio = line.match(REGEXP[:biblio])
+    #    @document.register(:ids, biblio[1])
+    #  end
+    #end
+  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