asciidoctor 1.5.5 → 1.5.6

data/lib/asciidoctor/path_resolver.rb

@@ -128,28 +128,27 @@ class PathResolver
     else
       @working_dir = ::File.expand_path ::Dir.pwd
     end
-    @_partition_path_sys = {}
-    @_partition_path_web = {}
+    @_partition_path_sys, @_partition_path_web = {}, {}
   end
 
-  # Public: Check if the specified path is an absolute root path
-  # This operation correctly handles both posix and windows paths.
+  # Public: Check if the specified path is an absolute root path.
+  # This operation considers posix paths, windows paths, and file URLs.
+  #
+  # Unix absolute paths and UNC paths start with slash. Windows roots can start
+  # with a drive letter. Absolute paths in the browser start with file://.
   #
   # path - the String path to check
   #
   # returns a Boolean indicating whether the path is an absolute root path
-  def is_root? path
-    # Unix absolute paths and UNC paths start with slash
-    if path.start_with? SLASH
-      true
-    # Windows roots can begin with drive letter
-    elsif @file_separator == BACKSLASH && WindowsRootRx =~ path
-      true
-    # Absolute paths in the browser start with file:///
-    elsif ::RUBY_ENGINE_OPAL && ::JAVASCRIPT_PLATFORM == 'browser' && (path.start_with? 'file:///')
-      true
-    else
-      false
+  if RUBY_ENGINE == 'opal'
+    def is_root? path
+      (path.start_with? SLASH) ||
+          (::JAVASCRIPT_IO_MODULE == 'xmlhttprequest' && (path.start_with? 'file://')) ||
+          (@file_separator == BACKSLASH && (WindowsRootRx.match? path))
+    end
+  else
+    def is_root? path
+      (path.start_with? SLASH) || (@file_separator == BACKSLASH && (WindowsRootRx.match? path))
     end
   end
 
@@ -176,7 +175,7 @@ class PathResolver
   # path - the String path to normalize
   #
   # returns a String path with any backslashes replaced with forward slashes
-  def posixfy path
+  def posixify path
     if path.nil_or_empty?
       ''
     elsif path.include? BACKSLASH
@@ -185,6 +184,7 @@ class PathResolver
       path
     end
   end
+  alias posixfy posixify
 
   # Public: Expand the path by resolving any parent references (..)
   # and cleaning self references (.).
@@ -206,23 +206,23 @@ class PathResolver
   # or segments that are self references (.). The path is converted to a posix
   # path before being partitioned.
   #
-  # path     - the String path to partition
-  # web_path - a Boolean indicating whether the path should be handled
-  #            as a web path (optional, default: false)
+  # path - the String path to partition
+  # web  - a Boolean indicating whether the path should be handled
+  #        as a web path (optional, default: false)
   #
   # Returns a 3-item Array containing the Array of String path segments, the
   # path root (e.g., '/', './', 'c:/') if the path is absolute and the posix
   # version of the path.
   #--
   # QUESTION is it worth it to normalize slashes? it doubles the time elapsed
-  def partition_path path, web_path = false
-    if (result = web_path ? @_partition_path_web[path] : @_partition_path_sys[path])
+  def partition_path path, web = nil
+    if (result = (cache = web ? @_partition_path_web : @_partition_path_sys)[path])
       return result
     end
 
-    posix_path = posixfy path
+    posix_path = posixify path
 
-    root = if web_path
+    root = if web
       # ex. /sample/path
       if is_web_root? posix_path
         SLASH
@@ -241,9 +241,9 @@ class PathResolver
         # ex. /sample/path
         elsif posix_path.start_with? SLASH
           SLASH
-        # ex. c:/sample/path (or file:///sample/path in browser environment)
+        # ex. C:/sample/path (or file:///sample/path in browser environment)
         else
-          posix_path[0..(posix_path.index SLASH)]
+          posix_path.slice 0, (posix_path.index SLASH) + 1
         end
       # ex. ./sample/path
       elsif posix_path.start_with? DOT_SLASH
@@ -260,7 +260,7 @@ class PathResolver
       path_segments = path_segments[2..-1]
     # shift twice for a file:/// path and adjust root
     # NOTE technically file:/// paths work without this adjustment
-    #elsif ::RUBY_ENGINE_OPAL && ::JAVASCRIPT_PLATFORM == 'browser' && root == 'file:/'
+    #elsif ::RUBY_ENGINE_OPAL && ::JAVASCRIPT_IO_MODULE == 'xmlhttprequest' && root == 'file:/'
     #  root = 'file://'
     #  path_segments = path_segments[2..-1]
     # shift once for any other root
@@ -269,9 +269,9 @@ class PathResolver
     end
     # strip out all dot entries
     path_segments.delete DOT
-    # QUESTION should we chomp trailing /? (we pay a small fraction)
-    #posix_path = posix_path.chomp '/'
-    (web_path ? @_partition_path_web : @_partition_path_sys)[path] = [path_segments, root, posix_path]
+    # QUESTION should we chop trailing /? (we pay a small fraction)
+    #posix_path = posix_path.chop if posix_path.end_with? SLASH
+    cache[path] = [path_segments, root, posix_path]
   end
 
   # Public: Join the segments using the posix file separator (since Ruby knows
@@ -285,11 +285,7 @@ class PathResolver
   # returns a String path formed by joining the segments using the posix file
   # separator and prepending the root, if specified
   def join_path segments, root = nil
-    if root
-      %(#{root}#{segments * SLASH})
-    else
-      segments * SLASH
-    end
+    root ? %(#{root}#{segments * SLASH}) : segments * SLASH
   end
 
   # Public: Resolve a system path from the target and start paths. If a jail
@@ -300,8 +296,8 @@ class PathResolver
   # specified in the constructor.
   #
   # target - the String target path
-  # start  - the String start (i.e., parent) path
-  # jail   - the String jail path to confine the resolved path
+  # start  - the String start (i.e., parent) path (default: nil)
+  # jail   - the String jail path to confine the resolved path (default: nil)
   # opts   - an optional Hash of options to control processing (default: {}):
   #          * :recover is used to control whether the processor should auto-recover
   #              when an illegal path is encountered
@@ -310,12 +306,12 @@ class PathResolver
   # returns a String path that joins the target path with the start path with
   # any parent references resolved and self references removed and enforces
   # that the resolved path be contained within the jail, if provided
-  def system_path target, start, jail = nil, opts = {}
+  def system_path target, start = nil, jail = nil, opts = {}
     if jail
       unless is_root? jail
         raise ::SecurityError, %(Jail is not an absolute path: #{jail})
       end
-      jail = posixfy jail
+      jail = posixify jail
     end
 
     if target.nil_or_empty?
@@ -348,7 +344,7 @@ class PathResolver
     if start.nil_or_empty?
       start = jail ? jail : @working_dir
     elsif is_root? start
-      start = posixfy start
+      start = posixify start
     else
       start = system_path start, jail, jail, opts
     end
@@ -379,7 +375,7 @@ class PathResolver
     target_segments.each do |segment|
       if segment == DOT_DOT
         if jail
-          if resolved_segments.length > jail_segments.length
+          if resolved_segments.size > jail_segments.size
             resolved_segments.pop
           elsif !(recover ||= (opts.fetch :recover, true))
             raise ::SecurityError, %(#{opts[:target_name] || 'path'} #{target} refers to location outside jail: #{jail} (disallowed in safe mode))
@@ -391,7 +387,7 @@ class PathResolver
           resolved_segments.pop
         end
       else
-        resolved_segments.push segment
+        resolved_segments << segment
       end
     end
 
@@ -412,12 +408,12 @@ class PathResolver
   # start path with any parent references resolved and self
   # references removed
   def web_path target, start = nil
-    target = posixfy target
-    start = posixfy start
+    target = posixify target
+    start = posixify start
     uri_prefix = nil
 
     unless start.nil_or_empty? || (is_web_root? target)
-      target = %(#{start.chomp '/'}#{SLASH}#{target})
+      target = (start.end_with? SLASH) ? %(#{start}#{target}) : %(#{start}#{SLASH}#{target})
       if (uri_prefix = Helpers.uri_prefix target)
         target = target[uri_prefix.length..-1]
       end
@@ -453,11 +449,11 @@ class PathResolver
       end
     end
 
-    if uri_prefix
-      %(#{uri_prefix}#{join_path resolved_segments, target_root})
-    else
-      join_path resolved_segments, target_root
+    if (resolved_path = join_path resolved_segments, target_root).include? ' '
+      resolved_path = resolved_path.gsub ' ', '%20'
     end
+
+    uri_prefix ? %(#{uri_prefix}#{resolved_path}) : resolved_path
   end
 
   # Public: Calculate the relative path to this absolute filename from the specified base directory
@@ -470,7 +466,7 @@ class PathResolver
   # Return the relative path String of the filename calculated from the base directory
   def relative_path filename, base_directory
     if (is_root? filename) && (is_root? base_directory)
-      offset = base_directory.chomp(@file_separator).length + 1
+      offset = (base_directory.end_with? @file_separator) ? base_directory.length : base_directory.length + 1
       filename[offset..-1]
     else
       filename

data/lib/asciidoctor/reader.rb

@@ -19,7 +19,7 @@ class Reader
       %(#{path}: line #{lineno})
     end
 
-    alias :to_s :line_info
+    alias to_s line_info
   end
 
   attr_reader :file
@@ -36,7 +36,7 @@ class Reader
   attr_accessor :process_lines
 
   # Public: Initialize the Reader object
-  def initialize data = nil, cursor = nil, opts = {:normalize => false}
+  def initialize data = nil, cursor = nil, opts = {}
     if !cursor
       @file = @dir = nil
       @path = '<stdin>'
@@ -88,7 +88,7 @@ class Reader
       if opts[:normalize]
         Helpers.normalize_lines_from_string data
       else
-        data.split EOL
+        data.split LF, -1
       end
     else
       if opts[:normalize]
@@ -133,16 +133,19 @@ class Reader
     peek_line.nil_or_empty?
   end
 
-  # Public: Peek at the next line of source data. Processes the line, if not
+  # Public: Peek at the next line of source data. Processes the line if not
   # already marked as processed, but does not consume it.
   #
   # This method will probe the reader for more lines. If there is a next line
   # that has not previously been visited, the line is passed to the
   # Reader#process_line method to be initialized. This call gives
-  # sub-classess the opportunity to do preprocessing. If the return value of
+  # sub-classes the opportunity to do preprocessing. If the return value of
   # the Reader#process_line is nil, the data is assumed to be changed and
   # Reader#peek_line is invoked again to perform further processing.
   #
+  # If has_more_lines? is called immediately before peek_line, the direct flag
+  # is implicitly true (since the line is flagged as visited).
+  #
   # direct  - A Boolean flag to bypasses the check for more lines and immediately
   #           returns the first element of the internal @lines Array. (default: false)
   #
@@ -167,7 +170,7 @@ class Reader
     end
   end
 
-  # Public: Peek at the next multiple lines of source data. Processes the lines, if not
+  # Public: Peek at the next multiple lines of source data. Processes the lines if not
   # already marked as processed, but does not consume them.
   #
   # This method delegates to Reader#read_line to process and collect the line, then
@@ -175,7 +178,7 @@ class Reader
   # be processed and marked as such so that subsequent reads will not need to process
   # the lines again.
   #
-  # num    - The Integer number of lines to peek.
+  # num    - The positive Integer number of lines to peek (must be greater than 0).
   # direct - A Boolean indicating whether processing should be disabled when reading lines
   #
   # Returns A String Array of the next multiple lines of source data, or an empty Array
@@ -187,12 +190,13 @@ class Reader
       if (line = read_line direct)
         result << line
       else
+        @lineno -= 1 if direct
         break
       end
     end
 
     unless result.empty?
-      result.reverse_each {|line| unshift line }
+      unshift_all result
       @look_ahead = old_look_ahead if direct
     end
 
@@ -229,7 +233,7 @@ class Reader
     end
     lines
   end
-  alias :readlines :read_lines
+  alias readlines read_lines
 
   # Public: Get the remaining lines of source data joined as a String.
   #
@@ -237,7 +241,7 @@ class Reader
   #
   # Returns the lines read joined as a String
   def read
-    read_lines * EOL
+    read_lines * LF
   end
 
   # Public: Advance to the next line by discarding the line at the front of the stack
@@ -252,8 +256,10 @@ class Reader
 
   # 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 seen.
+  # A line pushed on the reader using this method is not processed again. The
+  # method assumes the line was previously retrieved from the reader or does
+  # not otherwise contain preprocessor directives. Therefore, it is marked as
+  # processed immediately.
   #
   # line_to_restore - the line to restore onto the stack
   #
@@ -262,20 +268,21 @@ class Reader
     unshift line_to_restore
     nil
   end
-  alias :restore_line :unshift_line
+  alias restore_line unshift_line
 
   # Public: Push an Array of lines onto the front of the Array of source data.
   #
-  # Since these lines were (assumed to be) previously retrieved through the
-  # reader, they are marked as seen.
+  # Lines pushed on the reader using this method are not processed again. The
+  # method assumes the lines were previously retrieved from the reader or do
+  # not otherwise contain preprocessor directives. Therefore, they are marked
+  # as processed immediately.
   #
   # Returns nothing.
   def unshift_lines lines_to_restore
-    # QUESTION is it faster to use unshift(*lines_to_restore)?
-    lines_to_restore.reverse_each {|line| unshift line }
+    unshift_all lines_to_restore
     nil
   end
-  alias :restore_lines :unshift_lines
+  alias restore_lines unshift_lines
 
   # Public: Replace the next line with the specified line.
   #
@@ -292,7 +299,7 @@ class Reader
     nil
   end
   # deprecated
-  alias :replace_line :replace_next_line
+  alias replace_line replace_next_line
 
   # Public: Strip off leading blank lines in the Array of lines.
   #
@@ -346,10 +353,10 @@ class Reader
     while (next_line = peek_line)
       if include_blank_lines && next_line.empty?
         comment_lines << shift
-      elsif (commentish = next_line.start_with?('//')) && (match = CommentBlockRx.match(next_line))
+      elsif (commentish = next_line.start_with?('//')) && (CommentBlockRx.match? next_line)
         comment_lines << shift
-        comment_lines.push(*(read_lines_until(:terminator => match[0], :read_last_line => true, :skip_processing => true)))
-      elsif commentish && CommentLineRx =~ next_line
+        comment_lines.push(*(read_lines_until(:terminator => next_line, :read_last_line => true, :skip_processing => true)))
+      elsif commentish && (CommentLineRx.match? next_line)
         comment_lines << shift
       else
         break
@@ -366,7 +373,7 @@ class Reader
     comment_lines = []
     # optimized code for shortest execution path
     while (next_line = peek_line)
-      if CommentLineRx =~ next_line
+      if CommentLineRx.match? next_line
         comment_lines << shift
       else
         break
@@ -393,7 +400,7 @@ class Reader
   def eof?
     !has_more_lines?
   end
-  alias :empty? :eof?
+  alias empty? eof?
 
   # Public: Return all the lines from `@lines` until we (1) run out them,
   #   (2) find a blank line with :break_on_blank_lines => true, or (3) find
@@ -470,7 +477,7 @@ class Reader
           line_restored = true
         end
       else
-        unless skip_comments && line.start_with?('//') && CommentLineRx =~ line
+        unless skip_comments && (line.start_with? '//') && (CommentLineRx.match? line)
           result << line
           line_read = true
         end
@@ -504,6 +511,14 @@ class Reader
     @lines.unshift line
   end
 
+  # Internal: Restore the lines to the stack and decrement the lineno
+  def unshift_all lines
+    @lineno -= lines.size
+    @look_ahead += lines.size
+    @eof = false
+    @lines.unshift(*lines)
+  end
+
   def cursor
     Cursor.new @file, @dir, @path, @lineno
   end
@@ -514,7 +529,7 @@ class Reader
   def line_info
     %(#{@path}: line #{@lineno})
   end
-  alias :next_line_info :line_info
+  alias next_line_info line_info
 
   def prev_line_info
     %(#{@path}: line #{@lineno - 1})
@@ -529,12 +544,12 @@ class Reader
 
   # Public: Get a copy of the remaining lines managed by this Reader joined as a String
   def string
-    @lines * EOL
+    @lines * LF
   end
 
   # Public: Get the source lines for this Reader joined as a String
   def source
-    @source_lines * EOL
+    @source_lines * LF
   end
 
   # Public: Get a summary of this Reader.
@@ -553,15 +568,15 @@ class PreprocessorReader < Reader
   attr_reader :includes
 
   # Public: Initialize the PreprocessorReader object
-  def initialize document, data = nil, cursor = nil
+  def initialize document, data = nil, cursor = nil, opts = {}
     @document = document
-    super data, cursor, :normalize => true
+    super data, cursor, opts
     include_depth_default = document.attributes.fetch('max-include-depth', 64).to_i
     include_depth_default = 0 if include_depth_default < 0
     # track both absolute depth for comparing to size of include stack and relative depth for reporting
     @maxdepth = {:abs => include_depth_default, :rel => include_depth_default}
     @include_stack = []
-    @includes = (document.references[:includes] ||= [])
+    @includes = document.catalog[:includes]
     @skipping = false
     @conditional_stack = []
     @include_processor_extensions = nil
@@ -571,9 +586,9 @@ class PreprocessorReader < Reader
     result = super
 
     # QUESTION should this work for AsciiDoc table cell content? Currently it does not.
-    if @document && (@document.attributes.has_key? 'skip-front-matter')
+    if @document && (@document.attributes.key? 'skip-front-matter')
       if (front_matter = skip_front_matter! result)
-        @document.attributes['front-matter'] = front_matter * EOL
+        @document.attributes['front-matter'] = front_matter * LF
       end
     end
 
@@ -599,45 +614,41 @@ class PreprocessorReader < Reader
 
     # NOTE highly optimized
     if line.end_with?(']') && !line.start_with?('[') && line.include?('::')
-      if line.include?('if') && (match = ConditionalDirectiveRx.match(line))
+      if (line.include? 'if') && ConditionalDirectiveRx =~ line
         # if escaped, mark as processed and return line unescaped
-        if line.start_with?('\\')
+        if $1 == '\\'
           @unescape_next_line = true
           @look_ahead += 1
           line[1..-1]
+        elsif preprocess_conditional_directive $2, $3, $4, $5
+          # move the pointer past the conditional line
+          advance
+          # treat next line as uncharted territory
+          nil
         else
-          if preprocess_conditional_inclusion(*match.captures)
-            # move the pointer past the conditional line
-            advance
-            # treat next line as uncharted territory
-            nil
-          else
-            # the line was not a valid conditional line
-            # mark it as visited and return it
-            @look_ahead += 1
-            line
-          end
+          # the line was not a valid conditional line
+          # mark it as visited and return it
+          @look_ahead += 1
+          line
         end
       elsif @skipping
         advance
         nil
-      elsif ((escaped = line.start_with?('\\include::')) || line.start_with?('include::')) && (match = IncludeDirectiveRx.match(line))
+      elsif (line.start_with? 'inc', '\\inc') && IncludeDirectiveRx =~ line
         # if escaped, mark as processed and return line unescaped
-        if escaped
+        if $1 == '\\'
           @unescape_next_line = true
           @look_ahead += 1
           line[1..-1]
+        # QUESTION should we strip whitespace from raw attributes in Substitutors#parse_attributes? (check perf)
+        elsif preprocess_include_directive $2, $3.strip
+          # peek again since the content has changed
+          nil
         else
-          # QUESTION should we strip whitespace from raw attributes in Substitutors#parse_attributes? (check perf)
-          if preprocess_include match[1], match[2].strip
-            # peek again since the content has changed
-            nil
-          else
-            # the line was not a valid include line and is unchanged
-            # mark it as visited and return it
-            @look_ahead += 1
-            line
-          end
+          # the line was not a valid include line and is unchanged
+          # mark it as visited and return it
+          @look_ahead += 1
+          line
         end
       else
         # NOTE optimization to inline super
@@ -672,95 +683,89 @@ class PreprocessorReader < Reader
     end
   end
 
-  # 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.
+  # Internal: Preprocess the directive to conditionally include or exclude content.
+  #
+  # Preprocess the conditional directive (ifdef, ifndef, ifeval, endif) under
+  # the cursor. If Reader is currently skipping content, then simply track the
+  # open and close delimiters of any nested conditional blocks. If Reader is
+  # not skipping, mark whether the condition is satisfied and continue
+  # preprocessing recursively until the next line of available content is
+  # found.
+  #
+  # keyword   - 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 should be advanced
-  def preprocess_conditional_inclusion directive, target, delimiter, text
+  def preprocess_conditional_directive keyword, target, delimiter, text
+    # attributes are case insensitive
+    target = target.downcase unless (no_target = target.empty?)
+
     # 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
+    # skip line if it doesn't meet this criteria
     # QUESTION should we warn for these bogus declarations?
-    if ((directive == 'ifdef' || directive == 'ifndef') && target.empty?) ||
-        (directive == 'endif' && text)
-      return false
-    end
+    return false if (no_target && (keyword == 'ifdef' || keyword == 'ifndef')) || (text && keyword == 'endif')
 
-    # attributes are case insensitive
-    target = target.downcase
-
-    if directive == 'endif'
-      stack_size = @conditional_stack.size
-      if stack_size > 0
-        pair = @conditional_stack[-1]
-        if target.empty? || target == pair[:target]
-          @conditional_stack.pop
-          @skipping = @conditional_stack.empty? ? false : @conditional_stack[-1][:skipping]
-        else
-          warn %(asciidoctor: ERROR: #{line_info}: mismatched macro: endif::#{target}[], expected endif::#{pair[:target]}[])
-        end
-      else
+    if keyword == 'endif'
+      if @conditional_stack.empty?
         warn %(asciidoctor: ERROR: #{line_info}: unmatched macro: endif::#{target}[])
+      elsif no_target || target == (pair = @conditional_stack[-1])[:target]
+        @conditional_stack.pop
+        @skipping = @conditional_stack.empty? ? false : @conditional_stack[-1][:skipping]
+      else
+        warn %(asciidoctor: ERROR: #{line_info}: mismatched macro: endif::#{target}[], expected endif::#{pair[:target]}[])
       end
       return true
     end
 
-    skip = false
-    unless @skipping
+    if @skipping
+      skip = false
+    else
       # QUESTION any way to wrap ifdef & ifndef logic up together?
-      case directive
+      case keyword
       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(',').none? {|name| @document.attributes.has_key? name }
+          # skip if no attribute is defined
+          skip = target.split(',', -1).none? {|name| @document.attributes.key? name }
         when '+'
-          # if any attribute is undefined, then skip
-          skip = target.split('+').any? {|name| !@document.attributes.has_key? name }
+          # skip if any attribute is undefined
+          skip = target.split('+', -1).any? {|name| !@document.attributes.key? name }
+        else
+          # if the attribute is undefined, then skip
+          skip = !@document.attributes.key?(target)
         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(',').none? {|name| !@document.attributes.has_key? name }
+          # skip if any attribute is defined
+          skip = target.split(',', -1).any? {|name| @document.attributes.key? name }
         when '+'
-          # if any attribute is defined, then skip
-          skip = target.split('+').any? {|name| @document.attributes.has_key? name }
+          # skip if all attributes are defined
+          skip = target.split('+', -1).all? {|name| @document.attributes.key? name }
+        else
+          # if the attribute is defined, then skip
+          skip = @document.attributes.key?(target)
         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 = EvalExpressionRx.match(text.strip))
-          return false
-        end
+        return false unless no_target && EvalExpressionRx =~ text.strip
 
-        lhs = resolve_expr_val expr_match[1]
-        rhs = resolve_expr_val expr_match[3]
+        # NOTE save values eagerly for Ruby 1.8.7 compat
+        lhs, op, rhs = $1, $2, $3
+        lhs = resolve_expr_val lhs
+        rhs = resolve_expr_val rhs
 
         # regex enforces a restricted set of math-related operations
-        if (op = expr_match[2]) == '!='
+        if op == '!='
           skip = lhs.send :==, rhs
         else
           skip = !(lhs.send op.to_sym, rhs)
@@ -769,26 +774,25 @@ class PreprocessorReader < Reader
     end
 
     # conditional inclusion block
-    if directive == 'ifeval' || !text
+    if keyword == 'ifeval' || !text
       @skipping = true if skip
       @conditional_stack << {:target => target, :skip => skip, :skipping => @skipping}
     # single line conditional inclusion
     else
       unless @skipping || skip
-        # FIXME slight hack to skip past conditional line
-        # but keep our synthetic line marked as processed
-        # QUESTION can we use read_line true and unshift twice instead?
-        conditional_line = peek_line true
         replace_next_line text.rstrip
-        unshift conditional_line
-        return true
+        # HACK push dummy line to stand in for the opening conditional directive that's subsequently dropped
+        unshift ''
+        # NOTE force line to be processed again if it looks like an include directive
+        # QUESTION should we just call preprocess_include_directive here?
+        @look_ahead -= 1 if text.start_with? 'include::'
       end
     end
 
     true
   end
 
-  # Internal: Preprocess the directive (macro) to include the target document.
+  # Internal: Preprocess the directive to include lines from another document.
   #
   # Preprocess the directive to include the target document. The scenarios
   # are as follows:
@@ -806,23 +810,21 @@ class PreprocessorReader < Reader
   # 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
+  #          target slot of the include::[] directive
   #
   # Returns a Boolean indicating whether the line under the cursor has changed.
-  def preprocess_include raw_target, raw_attributes
-    if (target = @document.sub_attributes raw_target, :attribute_missing => 'drop-line').empty?
+  def preprocess_include_directive raw_target, raw_attributes
+    if ((target = raw_target).include? '{') &&
+        (target = @document.sub_attributes raw_target, :attribute_missing => 'drop-line').empty?
       advance
       if @document.attributes.fetch('attribute-missing', Compliance.attribute_missing) == 'skip'
         unshift %(Unresolved directive in #{@path} - include::#{raw_target}[#{raw_attributes}])
       end
       true
-    # assume that if an include processor is given, the developer wants
-    # to handle when and how to process the include
-    elsif include_processors? &&
-        (extension = @include_processor_extensions.find {|candidate| candidate.instance.handles? target })
+    elsif include_processors? && (ext = @include_processor_extensions.find {|candidate| candidate.instance.handles? target })
       advance
-      # FIXME parse attributes if requested by extension
-      extension.process_method[@document, self, target, AttributeList.new(raw_attributes).parse]
+      # FIXME parse attributes only if requested by extension
+      ext.process_method[@document, self, target, AttributeList.new(raw_attributes).parse]
       true
     # if running in SafeMode::SECURE or greater, don't process this directive
     # however, be friendly and at least make it a link to the source document
@@ -835,25 +837,20 @@ class PreprocessorReader < Reader
         warn %(asciidoctor: ERROR: #{line_info}: maximum include depth of #{@maxdepth[:rel]} exceeded)
         return false
       end
-      if ::RUBY_ENGINE_OPAL
+      if ::RUBY_ENGINE_OPAL && ::JAVASCRIPT_IO_MODULE == 'xmlhttprequest'
         # NOTE resolves uri relative to currently loaded document
         # NOTE we defer checking if file exists and catch the 404 error if it does not
-        # TODO only use this logic if env-browser is set
         target_type = :file
-        include_file = path = if @include_stack.empty?
-          ::Dir.pwd == @document.base_dir ? target : (::File.join @dir, target)
-        else
-          ::File.join @dir, target
-        end
+        inc_path = relpath = @include_stack.empty? && ::Dir.pwd == @document.base_dir ? target : (::File.join @dir, target)
       elsif Helpers.uriish? target
-        unless @document.attributes.has_key? 'allow-uri-read'
+        unless @document.attributes.key? 'allow-uri-read'
           replace_next_line %(link:#{target}[])
           return true
         end
 
         target_type = :uri
-        include_file = path = target
-        if @document.attributes.has_key? 'cache-uri'
+        inc_path = relpath = target
+        if @document.attributes.key? 'cache-uri'
           # caching requires the open-uri-cached gem to be installed
           # processing will be automatically aborted if these libraries can't be opened
           Helpers.require_library 'open-uri/cached', 'open-uri-cached' unless defined? ::OpenURI::Cache
@@ -864,130 +861,159 @@ class PreprocessorReader < Reader
       else
         target_type = :file
         # include file is resolved relative to dir of current include, or base_dir if within original docfile
-        include_file = @document.normalize_system_path(target, @dir, nil, :target_name => 'include file')
-        unless ::File.file? include_file
-          warn %(asciidoctor: WARNING: #{line_info}: include file not found: #{include_file})
+        inc_path = @document.normalize_system_path target, @dir, nil, :target_name => 'include file'
+        unless ::File.file? inc_path
+          warn %(asciidoctor: WARNING: #{line_info}: include file not found: #{inc_path})
           replace_next_line %(Unresolved directive in #{@path} - include::#{target}[#{raw_attributes}])
           return true
         end
-        #path = @document.relative_path include_file
-        path = PathResolver.new.relative_path include_file, @document.base_dir
+        # NOTE relpath is the path relative to the outermost document (or base_dir, if set)
+        #relpath = @document.relative_path inc_path
+        relpath = PathResolver.new.relative_path inc_path, @document.base_dir
       end
 
-      inc_lines = nil
-      tags = nil
-      attributes = {}
-      if !raw_attributes.empty?
+      inc_linenos, inc_tags, attributes = nil, nil, {}
+      unless raw_attributes.empty?
         # QUESTION should we use @document.parse_attribues?
         attributes = AttributeList.new(raw_attributes).parse
-        if attributes.has_key? 'lines'
-          inc_lines = []
+        if attributes.key? 'lines'
+          inc_linenos = []
           attributes['lines'].split(DataDelimiterRx).each do |linedef|
             if linedef.include?('..')
-              from, to = linedef.split('..', 2).map(&:to_i)
+              from, to = linedef.split('..', 2).map {|it| it.to_i }
               if to == -1
-                inc_lines << from
-                inc_lines << 1.0/0.0
+                inc_linenos << from
+                inc_linenos << 1.0/0.0
               else
-                inc_lines.concat ::Range.new(from, to).to_a
+                inc_linenos.concat ::Range.new(from, to).to_a
               end
             else
-              inc_lines << linedef.to_i
+              inc_linenos << linedef.to_i
             end
           end
-          inc_lines = inc_lines.sort.uniq
-        elsif attributes.has_key? 'tag'
-          tags = [attributes['tag']].to_set
-        elsif attributes.has_key? 'tags'
-          tags = attributes['tags'].split(DataDelimiterRx).to_set
+          inc_linenos = inc_linenos.empty? ? nil : inc_linenos.sort.uniq
+        elsif attributes.key? 'tag'
+          unless (tag = attributes['tag']).empty?
+            if tag.start_with? '!'
+              inc_tags = { (tag.slice 1, tag.length) => false } unless tag == '!'
+            else
+              inc_tags = { tag => true }
+            end
+          end
+        elsif attributes.key? 'tags'
+          inc_tags = {}
+          attributes['tags'].split(DataDelimiterRx).each do |tagdef|
+            if tagdef.start_with? '!'
+              inc_tags[tagdef.slice 1, tagdef.length] = false unless tagdef == '!'
+            else
+              inc_tags[tagdef] = true
+            end unless tagdef.empty?
+          end
+          inc_tags = nil if inc_tags.empty?
         end
       end
-      if inc_lines
-        unless inc_lines.empty?
-          selected = []
-          inc_line_offset = 0
-          inc_lineno = 0
-          begin
-            open(include_file, 'r') do |f|
-              f.each_line do |l|
-                inc_lineno += 1
-                take = inc_lines[0]
-                if ::Float === take && take.infinite?
-                  selected.push l
-                  inc_line_offset = inc_lineno if inc_line_offset == 0
-                else
-                  if f.lineno == take
-                    selected.push l
-                    inc_line_offset = inc_lineno if inc_line_offset == 0
-                    inc_lines.shift
-                  end
-                  break if inc_lines.empty?
+
+      if inc_linenos
+        inc_lines, inc_offset, inc_lineno = [], nil, 0
+        begin
+          open(inc_path, 'r') do |f|
+            f.each_line do |l|
+              inc_lineno += 1
+              select = inc_linenos[0]
+              if ::Float === select && select.infinite?
+                # NOTE record line where we started selecting
+                inc_offset ||= inc_lineno
+                inc_lines << l
+              else
+                if inc_lineno == select
+                  # NOTE record line where we started selecting
+                  inc_offset ||= inc_lineno
+                  inc_lines << l
+                  inc_linenos.shift
                 end
+                break if inc_linenos.empty?
               end
             end
-          rescue
-            warn %(asciidoctor: WARNING: #{line_info}: include #{target_type} not readable: #{include_file})
-            replace_next_line %(Unresolved directive in #{@path} - include::#{target}[#{raw_attributes}])
-            return true
           end
-          advance
-          # FIXME not accounting for skipped lines in reader line numbering
-          push_include selected, include_file, path, inc_line_offset, attributes
+        rescue
+          warn %(asciidoctor: WARNING: #{line_info}: include #{target_type} not readable: #{inc_path})
+          replace_next_line %(Unresolved directive in #{@path} - include::#{target}[#{raw_attributes}])
+          return true
         end
-      elsif tags
-        unless tags.empty?
-          selected = []
-          inc_line_offset = 0
-          inc_lineno = 0
-          active_tag = nil
-          tags_found = ::Set.new
-          begin
-            open(include_file, 'r') do |f|
-              f.each_line do |l|
-                inc_lineno += 1
-                # must force encoding here since we're performing String operations on line
-                l.force_encoding(::Encoding::UTF_8) if FORCE_ENCODING
-                l = l.rstrip
-                # tagged lines in XML may end with '-->'
-                tl = l.chomp('-->').rstrip
-                if active_tag
-                  if tl.end_with?(%(end::#{active_tag}[]))
-                    active_tag = nil
-                  else
-                    selected.push l unless tl.end_with?('[]') && TagDirectiveRx =~ tl
-                    inc_line_offset = inc_lineno if inc_line_offset == 0
-                  end
-                else
-                  tags.each do |tag|
-                    if tl.end_with?(%(tag::#{tag}[]))
-                      active_tag = tag
-                      tags_found << tag
-                      break
+        advance
+        # FIXME not accounting for skipped lines in reader line numbering
+        push_include inc_lines, inc_path, relpath, inc_offset, attributes if inc_offset
+      elsif inc_tags
+        inc_lines, inc_offset, inc_lineno, tag_stack, tags_used, active_tag = [], nil, 0, [], ::Set.new, nil
+        if inc_tags.key? '**'
+          if inc_tags.key? '*'
+            select = base_select = (inc_tags.delete '**')
+            wildcard = inc_tags.delete '*'
+          else
+            select = base_select = wildcard = (inc_tags.delete '**')
+          end
+        else
+          select = base_select = !(inc_tags.value? true)
+          wildcard = inc_tags.delete '*'
+        end
+        if (ext_idx = inc_path.rindex '.') && (circ_cmt = CIRCUMFIX_COMMENTS[inc_path.slice ext_idx, inc_path.length])
+          cmt_suffix_len = (tag_suffix = %([] #{circ_cmt[:suffix]})).length - 2
+        end
+        begin
+          open(inc_path, 'r') do |f|
+            f.each_line do |l|
+              inc_lineno += 1
+              # must force encoding since we're performing String operations on line
+              l.force_encoding ::Encoding::UTF_8 if FORCE_ENCODING
+              if (((tl = l.chomp).end_with? '[]') ||
+                  (tag_suffix && (tl.end_with? tag_suffix) && (tl = tl.slice 0, tl.length - cmt_suffix_len))) &&
+                  TagDirectiveRx =~ tl
+                if $1 # end tag
+                  if (this_tag = $2) == active_tag
+                    tag_stack.pop
+                    active_tag, select = tag_stack.empty? ? [nil, base_select] : tag_stack[-1]
+                  elsif inc_tags.key? this_tag
+                    if (idx = tag_stack.rindex {|key, _| key == this_tag })
+                      idx == 0 ? tag_stack.shift : (tag_stack.delete_at idx)
+                      warn %(asciidoctor: WARNING: #{target}: line #{inc_lineno}: mismatched end tag in include: expected #{active_tag}, found #{this_tag})
+                    else
+                      warn %(asciidoctor: WARNING: #{target}: line #{inc_lineno}: unexpected end tag in include: #{this_tag})
                     end
-                  end if tl.end_with?('[]') && TagDirectiveRx =~ tl
+                  end
+                elsif inc_tags.key?(this_tag = $2)
+                  tags_used << this_tag
+                  # QUESTION should we prevent tag from being selected when enclosing tag is excluded?
+                  tag_stack << [(active_tag = this_tag), (select = inc_tags[this_tag])]
+                elsif !wildcard.nil?
+                  select = active_tag && !select ? false : wildcard
+                  tag_stack << [(active_tag = this_tag), select]
                 end
+              elsif select
+                # NOTE record the line where we started selecting
+                inc_offset ||= inc_lineno
+                inc_lines << l
               end
             end
-          rescue
-            warn %(asciidoctor: WARNING: #{line_info}: include #{target_type} not readable: #{include_file})
-            replace_next_line %(Unresolved directive in #{@path} - include::#{target}[#{raw_attributes}])
-            return true
-          end
-          unless (missing_tags = tags.to_a - tags_found.to_a).empty?
-            warn %(asciidoctor: WARNING: #{line_info}: tag#{missing_tags.size > 1 ? 's' : nil} '#{missing_tags * ','}' not found in include #{target_type}: #{include_file})
           end
-          advance
-          # FIXME not accounting for skipped lines in reader line numbering
-          push_include selected, include_file, path, inc_line_offset, attributes
+        rescue
+          warn %(asciidoctor: WARNING: #{line_info}: include #{target_type} not readable: #{inc_path})
+          replace_next_line %(Unresolved directive in #{@path} - include::#{target}[#{raw_attributes}])
+          return true
         end
+        unless (missing_tags = inc_tags.keys.to_a - tags_used.to_a).empty?
+          warn %(asciidoctor: WARNING: #{line_info}: tag#{missing_tags.size > 1 ? 's' : nil} '#{missing_tags * ','}' not found in include #{target_type}: #{inc_path})
+        end
+        advance
+        # FIXME not accounting for skipped lines in reader line numbering
+        push_include inc_lines, inc_path, relpath, inc_offset, attributes if inc_offset
       else
         begin
           # NOTE read content first so that we only advance cursor if IO operation succeeds
-          include_content = open(include_file, 'r') {|f| f.read }
+          inc_content = target_type == :file ? (::IO.read inc_path) : open(inc_path, 'r') {|f| f.read }
           advance
-          push_include include_content, include_file, path, 1, attributes
+          push_include inc_content, inc_path, relpath, 1, attributes
         rescue
-          warn %(asciidoctor: WARNING: #{line_info}: include #{target_type} not readable: #{include_file})
+          warn %(asciidoctor: WARNING: #{line_info}: include #{target_type} not readable: #{inc_path})
           replace_next_line %(Unresolved directive in #{@path} - include::#{target}[#{raw_attributes}])
           return true
         end
@@ -1018,7 +1044,7 @@ class PreprocessorReader < Reader
       @file = file
       @dir = File.dirname file
       # only process lines in AsciiDoc files
-      @process_lines = ASCIIDOC_EXTENSIONS[::File.extname(file)]
+      @process_lines = ASCIIDOC_EXTENSIONS[::File.extname file]
     else
       @file = nil
       @dir = '.' # right?
@@ -1026,16 +1052,16 @@ class PreprocessorReader < Reader
       @process_lines = true
     end
 
-    @path = if path
+    if path
       @includes << Helpers.rootname(path)
-      path
+      @path = path
     else
-      '<stdin>'
+      @path = '<stdin>'
     end
 
     @lineno = lineno
 
-    if attributes.has_key? 'depth'
+    if attributes.key? 'depth'
       depth = attributes['depth'].to_i
       depth = 1 if depth <= 0
       @maxdepth = {:abs => (@include_stack.size - 1) + depth, :rel => depth}
@@ -1046,14 +1072,14 @@ class PreprocessorReader < Reader
       pop_include
     else
       # FIXME we eventually want to handle leveloffset without affecting the lines
-      if attributes.has_key? 'leveloffset'
+      if attributes.key? 'leveloffset'
         @lines.unshift ''
         @lines.unshift %(:leveloffset: #{attributes['leveloffset']})
-        @lines.push ''
+        @lines << ''
         if (old_leveloffset = @document.attr 'leveloffset')
-          @lines.push %(:leveloffset: #{old_leveloffset})
+          @lines << %(:leveloffset: #{old_leveloffset})
         else
-          @lines.push ':leveloffset!:'
+          @lines << ':leveloffset!:'
         end
         # compensate for these extra lines
         @lineno -= 2
@@ -1113,7 +1139,7 @@ class PreprocessorReader < Reader
       data.shift
       @lineno += 1 if increment_linenos
       while !data.empty? && data[0] != '---'
-        front_matter.push data.shift
+        front_matter << data.shift
         @lineno += 1 if increment_linenos
       end
 
@@ -1171,9 +1197,7 @@ class PreprocessorReader < Reader
 
     # QUESTION should we substitute first?
     # QUESTION should we also require string to be single quoted (like block attribute values?)
-    if val.include? '{'
-      val = @document.sub_attributes val, :attribute_missing => 'drop'
-    end
+    val = @document.sub_attributes val, :attribute_missing => 'drop' if val.include? '{'
 
     if quoted
       val
@@ -1209,7 +1233,7 @@ class PreprocessorReader < Reader
   end
 
   def to_s
-    %(#<#{self.class}@#{object_id} {path: #{@path.inspect}, line #: #{@lineno}, include depth: #{@include_stack.size}, include stack: [#{@include_stack.map {|inc| inc.to_s}.join ', '}]}>)
+    %(#<#{self.class}@#{object_id} {path: #{@path.inspect}, line #: #{@lineno}, include depth: #{@include_stack.size}, include stack: [#{@include_stack.map {|inc| inc.to_s } * ', '}]}>)
   end
 end
 end