darkroom 0.0.6 → 0.0.8

data/lib/darkroom/asset.rb

@@ -4,7 +4,6 @@ require('base64')
 require('digest')
 require('set')
 
-require_relative('darkroom')
 require_relative('errors/asset_error')
 require_relative('errors/asset_not_found_error')
 require_relative('errors/circular_reference_error')
@@ -18,18 +17,16 @@ class Darkroom
   #
   class Asset
     EXTENSION_REGEX = /(?=\.\w+)/.freeze
-
-    IMPORT_JOINER = "\n"
     DEFAULT_QUOTE = '\''
-
-    QUOTED_PATH = /(?<quote>['"])(?<path>[^'"]*)\k<quote>/.freeze
-    REFERENCE_PATH =
-      %r{
-        (?<quote>['"]?)(?<quoted>
-          (?<path>[^#{DISALLOWED_PATH_CHARS}]+)
-          \?asset-(?<entity>path|content)(=(?<format>\w*))?
-        )\k<quote>
-      }x.freeze
+    DISALLOWED_PATH_CHARS = '\'"`=<>? '
+    INVALID_PATH_REGEX = /[#{DISALLOWED_PATH_CHARS}]/.freeze
+    PATH_REGEX = /(?<path>[^#{DISALLOWED_PATH_CHARS}]*)/.freeze
+    QUOTED_PATH_REGEX = /(?<quote>['"])#{PATH_REGEX.source}\k<quote>/.freeze
+    REFERENCE_REGEX = /
+      (?<quote>['"]?)
+        (?<quoted>#{PATH_REGEX.source}\?asset-(?<entity>path|content)(=(?<format>\w*))?)
+      \k<quote>
+    /x.freeze
 
     # First item of each set is used as default, so order is important.
     REFERENCE_FORMATS = {
@@ -37,94 +34,60 @@ class Darkroom
       'content' => Set.new(%w[base64 utf8 displace]),
     }.freeze
 
-    attr_reader(:content, :error, :errors, :path, :path_unversioned, :path_versioned)
-
-    ##
-    # Holds information about how to handle a particular asset type.
-    #
-    # * +content_type+ - HTTP MIME type string.
-    # * +import_regex+ - Regex to find import statements. Must contain a named component called 'path'
-    #   (e.g. +/^import (?<path>.*)/+).
-    # * +reference_regex+ - Regex to find references to other assets. Must contain three named components:
-    #   * +path+ - Path of the asset being referenced.
-    #   * +entity+ - Desired entity (path or content).
-    #   * +format+ - Format to use (see REFERENCE_FORMATS).
-    # * +validate_reference+ - Lambda to call to validate a reference. Should return nil if there are no
-    #   errors and a string error message if validation fails. Three arguments are passed when called:
-    #   * +asset+ - Asset object of the asset being referenced.
-    #   * +match+ - MatchData object from the match against +reference_regex+.
-    #   * +format+ - Format of the reference (see REFERENCE_FORMATS).
-    # * +reference_content+ - Lambda to call to get the content for a reference. Should return nil if the
-    #   default behavior is desired or a string for custom content. Three arguments are passed when called:
-    #   * +asset+ - Asset object of the asset being referenced.
-    #   * +match+ - MatchData object from the match against +reference_regex+.
-    #   * +format+ - Format of the reference (see REFERENCE_FORMATS).
-    # * +compile_lib+ - Name of a library to +require+ that is needed by the +compile+ lambda.
-    # * +compile+ - Lambda to call that will return the compiled version of the asset's content. Two
-    #   arguments are passed when called:
-    #   * +path+ - Path of the asset being compiled.
-    #   * +content+ - Content to compile.
-    # * +minify_lib+ - Name of a library to +require+ that is needed by the +minify+ lambda.
-    # * +minify+ - Lambda to call that will return the minified version of the asset's content. One argument
-    #   is passed when called:
-    #   * +content+ - Content to minify.
-    #
-    Delegate = Struct.new(:content_type, :import_regex, :reference_regex, :validate_reference,
-      :reference_content, :compile_lib, :compile, :minify_lib, :minify, keyword_init: true)
+    attr_reader(:errors, :path, :path_unversioned)
 
     ##
     # Creates a new instance.
     #
-    # * +file+ - Path of file on disk.
-    # * +path+ - Path this asset will be referenced by (e.g. /js/app.js).
-    # * +darkroom+ - Darkroom instance that the asset is a member of.
-    # * +prefix+ - Prefix to apply to unversioned and versioned paths.
-    # * +minify+ - Boolean specifying whether or not the asset should be minified when processed.
-    # * +internal+ - Boolean indicating whether or not the asset is only accessible internally (i.e. as an
-    #   import or reference).
+    # [file] Path of file on disk.
+    # [path] Path this asset will be referenced by (e.g. /js/app.js).
+    # [darkroom] Darkroom instance that the asset is a member of.
+    # [prefix:] Prefix to apply to unversioned and versioned paths.
+    # [entry:] Boolean indicating whether or not the asset is an entry point (i.e. accessible externally).
+    # [minify:] Boolean specifying whether or not the asset should be minified when processed.
+    # [intermediate:] Boolean indicating whether or not the asset exists solely to provide an intermediate
+    #                 form (e.g. compiled) to another asset instance.
     #
-    def initialize(path, file, darkroom, prefix: nil, minify: false, internal: false)
+    def initialize(path, file, darkroom, prefix: nil, entry: true, minify: false, intermediate: false)
       @path = path
+      @dir = File.dirname(path)
       @file = file
       @darkroom = darkroom
       @prefix = prefix
+      @entry = entry
       @minify = minify
-      @internal = internal
 
       @path_unversioned = "#{@prefix}#{@path}"
       @extension = File.extname(@path).downcase
       @delegate = Darkroom.delegate(@extension) or raise(UnrecognizedExtensionError.new(@path))
 
+      @ran = Set.new
+
+      if @delegate.compile_delegate && !intermediate
+        @delegate = @delegate.compile_delegate
+        @intermediate_asset = Asset.new(@path, @file, @darkroom,
+          prefix: @prefix,
+          entry: false,
+          minify: false,
+          intermediate: true,
+        )
+      end
+
       require_libs
       clear
     end
 
     ##
-    # Processes the asset if modified (see #modified? for how modification is determined). File is read from
-    # disk, references are substituted (if supported), content is compiled (if required), imports are
-    # prefixed to its content (if supported), and content is minified (if supported and enabled). Returns
-    # true if asset was modified since it was last processed and false otherwise.
+    # Processes the asset if modified since the last run (see #modified? for how modification is
+    # determined). File is read from disk, references are substituted (if supported), content is compiled
+    # (if required), imports are prefixed to its content (if supported), and content is minified
+    # (if supported and enabled and the asset is an entry point).
     #
     def process
-      @process_key == @darkroom.process_key ? (return @processed) : (@process_key = @darkroom.process_key)
-      modified? ? (@processed = true) : (return @processed = false)
+      return if ran?(:process)
 
-      clear
-      read
-      build_imports
-      build_references
-      process_dependencies
       compile
-      minify
-
-      @fingerprint = Digest::MD5.hexdigest(@content)
-      @path_versioned = "#{@prefix}#{@path.sub(EXTENSION_REGEX, "-#{@fingerprint}")}"
-
-      @processed
-    rescue Errno::ENOENT
-      # File was deleted. Do nothing.
-    ensure
-      @error = @errors.empty? ? nil : ProcessingError.new(@errors)
+      content if entry?
     end
 
     ##
@@ -159,49 +122,139 @@ class Darkroom
       defined?(@is_image) ? @is_image : (@is_image = content_type.start_with?('image/'))
     end
 
+    ##
+    # Returns boolean indicating whether or not the asset is an entry point.
+    #
+    def entry?
+      @entry
+    end
+
+    ##
+    # DEPRECATED: use #entry? instead. Returns boolean indicating whether or not the asset is marked as
+    # internal.
+    #
+    def internal?
+      Darkroom.deprecated("#{self.class.name}#internal? is deprecated: use #entry? instead")
+
+      !entry?
+    end
+
+    ##
+    # Returns boolean indicating whether or not an error was encountered the last time the asset was
+    # processed.
+    #
+    def error?
+      !@errors.empty?
+    end
+
+    ##
+    # Returns ProcessingError wrapper of all errors if any exist, or nil if there are none.
+    #
+    def error
+      @error ||= @errors.empty? ? nil : ProcessingError.new(@errors)
+    end
+
+    ##
+    # Returns hash of content.
+    #
+    def fingerprint
+      content
+
+      @fingerprint
+    end
+
+    ##
+    # Returns versioned path.
+    #
+    def path_versioned
+      content
+
+      @path_versioned
+    end
+
     ##
     # Returns appropriate HTTP headers.
     #
-    # * +versioned+ - Uses Cache-Control header with max-age if +true+ and ETag header if +false+.
+    # [versioned:] Uses Cache-Control header with max-age if +true+ and ETag header if +false+.
     #
     def headers(versioned: true)
       {
         'Content-Type' => content_type,
         'Cache-Control' => ('public, max-age=31536000' if versioned),
-        'ETag' => ("\"#{@fingerprint}\"" if !versioned),
+        'ETag' => ("\"#{fingerprint}\"" if !versioned),
       }.compact!
     end
 
     ##
     # Returns subresource integrity string.
     #
-    # * +algorithm+ - Hash algorithm to use to generate the integrity string (one of :sha256, :sha384, or
-    #   :sha512).
+    # [algorithm] Hash algorithm to use to generate the integrity string (one of +:sha256+, +:sha384+, or
+    #             +:sha512+).
     #
     def integrity(algorithm = :sha384)
       @integrity[algorithm] ||= "#{algorithm}-#{Base64.strict_encode64(
         case algorithm
-        when :sha256 then Digest::SHA256.digest(@content)
-        when :sha384 then Digest::SHA384.digest(@content)
-        when :sha512 then Digest::SHA512.digest(@content)
+        when :sha256 then Digest::SHA256.digest(content)
+        when :sha384 then Digest::SHA384.digest(content)
+        when :sha512 then Digest::SHA512.digest(content)
         else raise("Unrecognized integrity algorithm: #{algorithm}")
         end
       )}".freeze
     end
 
     ##
-    # Returns boolean indicating whether or not the asset is marked as internal.
+    # Returns full asset content.
     #
-    def internal?
-      @internal
-    end
-
-    ##
-    # Returns boolean indicating whether or not an error was encountered the last time the asset was
-    # processed.
+    # [minified:] Boolean indicating whether or not to return minified version if it is available.
     #
-    def error?
-      !!@error
+    def content(minified: @minify)
+      unless ran?(:content)
+        compile
+
+        @content =
+          if imports.empty?
+            @own_content
+          else
+            (0..imports.size).inject(+'') do |content, i|
+              own_content = (imports[i] || self).own_content
+
+              content << "\n" unless (content[-1] == "\n" && own_content[0] == "\n") || content.empty?
+              content << own_content
+            end
+          end
+
+        begin
+          finalized = @delegate.finalize_handler&.call(
+            parse_data: @parse_data,
+            path: @path,
+            content: @content,
+          )
+
+          @content = finalized if finalized.kind_of?(String)
+        rescue => e
+          @errors << e
+        end
+      end
+
+      if @delegate.minify_handler && !@content_minified && (minified || @minify)
+        begin
+          @content_minified = @delegate.minify_handler.call(
+            parse_data: @parse_data,
+            path: @path,
+            content: @content,
+          )
+        rescue => e
+          @errors << e
+        end
+      end
+
+      @fingerprint ||= Digest::MD5.hexdigest((@minify && @content_minified) || @content).freeze
+      @path_versioned ||= "#{@prefix}#{@path.sub(EXTENSION_REGEX, "-#{@fingerprint}")}"
+
+      (minified && @content_minified) || @content
+    ensure
+      @content.freeze
+      @content_minified.freeze
     end
 
     ##
@@ -209,11 +262,11 @@ class Darkroom
     #
     def inspect
       "#<#{self.class}: "\
+        "@entry=#{@entry.inspect}, "\
         "@errors=#{@errors.inspect}, "\
         "@extension=#{@extension.inspect}, "\
         "@file=#{@file.inspect}, "\
         "@fingerprint=#{@fingerprint.inspect}, "\
-        "@internal=#{@internal.inspect}, "\
         "@minify=#{@minify.inspect}, "\
         "@mtime=#{@mtime.inspect}, "\
         "@path=#{@path.inspect}, "\
@@ -230,204 +283,252 @@ class Darkroom
     # error was recorded during the last processing run.
     #
     def modified?
-      @modified_key == @darkroom.process_key ? (return @modified) : (@modified_key = @darkroom.process_key)
+      @modified_key == @darkroom.process_key ? (return @modified) : @modified_key = @darkroom.process_key
 
       begin
         @modified = !!@error
-        @modified ||= @mtime != (@mtime = File.mtime(@file))
+        @modified ||= (@mtime != (@mtime = File.mtime(@file)))
+        @modified ||= @intermediate_asset.modified? if @intermediate_asset
         @modified ||= dependencies.any? { |d| d.modified? }
+
+        @ran.clear if @modified
+
+        @modified
       rescue Errno::ENOENT
         @modified = true
       end
     end
 
     ##
-    # Returns all dependencies (including dependencies of dependencies).
-    #
-    # * +ignore+ - Assets already accounted for as dependency tree is walked (to prevent infinite loops when
-    #   circular chains are encountered).
+    # Clears content, dependencies, and errors so asset is ready for (re)processing.
     #
-    def dependencies(ignore = nil)
-      return @dependencies if @dependencies
+    def clear
+      return if ran?(:clear)
+
+      @own_dependencies = []
+      @own_imports = []
+      @parse_matches = []
+      @parse_data = {}
+
+      @dependencies = nil
+      @imports = nil
 
-      dependencies = accumulate(:dependencies, ignore)
-      @dependencies = dependencies unless ignore
+      @own_content = nil
+      @content = nil
+      @content_minified = nil
 
-      dependencies
+      @fingerprint = nil
+      @path_versioned = nil
+      @integrity = {}
+
+      @error = nil
+      @errors = []
     end
 
     ##
-    # Returns all imports (including imports of imports).
-    #
-    # * +ignore+ - Assets already accounted for as import tree is walked (to prevent infinite loops when
-    #   circular chains are encountered).
+    # Reads the asset file into memory.
     #
-    def imports(ignore = nil)
-      return @imports if @imports
+    def read
+      return if ran?(:read)
 
-      imports = accumulate(:imports, ignore)
-      @imports = imports unless ignore
+      clear
 
-      imports
+      if @intermediate_asset
+        @own_content = @intermediate_asset.own_content.dup
+        @errors.concat(@intermediate_asset.errors)
+      else
+        begin
+          @own_content = File.read(@file)
+        rescue Errno::ENOENT
+          # Gracefully handle file deletion.
+          @own_content = ''
+        end
+      end
     end
 
     ##
-    # Returns the processed content of the asset without dependencies concatenated.
+    # Parses own content to build list of imports and references.
     #
-    def own_content
-      @own_content
-    end
+    def parse
+      return if ran?(:parse)
 
-    private
+      read
 
-    ##
-    # Clears content, dependencies, and errors so asset is ready for (re)processing.
-    #
-    def clear
-      @dependencies = nil
-      @imports = nil
-      @error = nil
-      @fingerprint = nil
-      @path_versioned = nil
+      @delegate.each_parser do |kind, regex, _|
+        @own_content.scan(regex) do
+          match = Regexp.last_match
+          asset = nil
 
-      (@own_dependencies ||= []).clear
-      (@own_imports ||= []).clear
-      (@dependency_matches ||= []).clear
-      (@errors ||= []).clear
-      (@content ||= +'').clear
-      (@own_content ||= +'').clear
-      (@integrity ||= {}).clear
+          if kind == :import || kind == :reference
+            path = File.expand_path(match[:path], @dir)
+            asset = @darkroom.manifest(path)
+
+            @own_dependencies << asset if asset
+            @own_imports << asset if asset && kind == :import
+          end
+
+          @parse_matches << [kind, match, asset]
+        end
+      end
     end
 
     ##
-    # Reads the asset file into memory.
+    # Returns direct dependencies (ones explicitly specified in the asset's own content.)
     #
-    def read
-      @own_content = File.read(@file)
+    def own_dependencies
+      parse
+
+      @own_dependencies
     end
 
     ##
-    # Builds reference info.
+    # Returns all dependencies (including dependencies of dependencies).
     #
-    def build_references
-      return unless @delegate.reference_regex
-
-      @own_content.scan(@delegate.reference_regex) do
-        match = Regexp.last_match
-        path = match[:path]
-        format = match[:format]
-        format = REFERENCE_FORMATS[match[:entity]].first if format.nil? || format == ''
-
-        if (asset = @darkroom.manifest(path))
-          if !REFERENCE_FORMATS[match[:entity]].include?(format)
-            @errors << AssetError.new("Invalid reference format '#{format}' (must be one of "\
-              "'#{REFERENCE_FORMATS[match[:entity]].join("', '")}')", match[0], @path, line_num(match))
-          elsif match[:entity] == 'content' && format != 'base64' && asset.binary?
-            @errors << AssetError.new('Base64 encoding is required for binary assets', match[0], @path,
-              line_num(match))
-          elsif (error = @delegate.validate_reference&.(asset, match, format))
-            @errors << AssetError.new(error, match[0], @path, line_num(match))
-          else
-            @own_dependencies << asset
-            @dependency_matches << [:reference, asset, match, format]
-          end
-        else
-          @errors << not_found_error(path, match)
-        end
+    def dependencies
+      unless ran?(:dependencies)
+        parse
+        @dependencies = accumulate(:own_dependencies)
       end
+
+      @dependencies
     end
 
     ##
-    # Builds import info.
+    # Returns direct imports (ones explicitly specified in the asset's own content.)
     #
-    def build_imports
-      return unless @delegate.import_regex
+    def own_imports
+      parse
 
-      @own_content.scan(@delegate.import_regex) do
-        match = Regexp.last_match
-        path = match[:path]
+      @own_imports
+    end
 
-        if (asset = @darkroom.manifest(path))
-          @own_dependencies << asset
-          @own_imports << asset
-          @dependency_matches << [:import, asset, match]
-        else
-          @errors << not_found_error(path, match)
-        end
+    ##
+    # Returns all imports (including imports of imports).
+    #
+    def imports
+      unless ran?(:imports)
+        parse
+        @imports = accumulate(:own_imports)
       end
+
+      @imports
     end
 
     ##
-    # Processes imports and references.
-    #
-    def process_dependencies
-      @dependency_matches.sort_by! { |_, __, match| -match.begin(0) }.each do |kind, asset, match, format|
-        if kind == :import
-          @own_content[match.begin(0)...match.end(0)] = ''
-        elsif asset.dependencies.include?(self)
-          @errors << CircularReferenceError.new(match[0], @path, line_num(match))
-        else
-          value, start, finish = @delegate.reference_content&.(asset, match, format)
+    # Performs import and reference substitutions based on parse matches.
+    #
+    def substitute
+      return if ran?(:substitute)
+
+      parse
+      substitutions = []
+
+      @parse_matches.sort_by! { |_, match, __| match.begin(0) }.each do |kind, match, asset|
+        format = nil
+
+        handler = @delegate.handler(kind)
+        handler_args = {
+          parse_data: @parse_data,
+          match: match,
+        }
+        handler_args[:asset] = asset if asset
+
+        if !asset && (kind == :import || kind == :reference)
+          add_parse_error(match, AssetNotFoundError)
+          next
+        elsif kind == :reference
+          format = match[:format]
+          format = REFERENCE_FORMATS[match[:entity]].first if format.nil? || format == ''
+
+          handler_args[:format] = format
+
+          if asset.dependencies.include?(self)
+            add_parse_error(match, CircularReferenceError)
+            next
+          elsif !REFERENCE_FORMATS[match[:entity]].include?(format)
+            formats = REFERENCE_FORMATS[match[:entity]].join("', '")
+            add_parse_error(match, "Invalid reference format '#{format}' (must be one of '#{formats}')")
+            next
+          elsif match[:entity] == 'content' && format != 'base64' && asset.binary?
+            add_parse_error(match, 'Base64 encoding is required for binary assets')
+            next
+          end
+        end
+
+        error = catch(:error) do
+          substitution, start, finish = handler&.call(**handler_args)
+
           min_start, max_finish = match.offset(0)
-          start ||= format == 'displace' ? min_start : match.begin(:quoted)
-          finish ||= format == 'displace' ? max_finish : match.end(:quoted)
+          start ||= (!format || format == 'displace') ? min_start : match.begin(:quoted)
+          finish ||= (!format || format == 'displace') ? max_finish : match.end(:quoted)
           start = [[start, min_start].max, max_finish].min
           finish = [[finish, max_finish].min, min_start].max
 
-          @own_content[start...finish] =
+          if kind == :reference
             case "#{match[:entity]}-#{format}"
             when 'path-versioned'
-              value || asset.path_versioned
+              substitution ||= asset.path_versioned
             when 'path-unversioned'
-              value || asset.path_unversioned
+              substitution ||= asset.path_unversioned
             when 'content-base64'
               quote = DEFAULT_QUOTE if match[:quote] == ''
-              data = Base64.strict_encode64(value || asset.content)
-              "#{quote}data:#{asset.content_type};base64,#{data}#{quote}"
+              data = Base64.strict_encode64(substitution || asset.content)
+              substitution = "#{quote}data:#{asset.content_type};base64,#{data}#{quote}"
             when 'content-utf8'
               quote = DEFAULT_QUOTE if match[:quote] == ''
-              "#{quote}data:#{asset.content_type};utf8,#{value || asset.content}#{quote}"
+              data = substitution || asset.content
+              substitution = "#{quote}data:#{asset.content_type};utf8,#{data}#{quote}"
             when 'content-displace'
-              value || asset.content
+              substitution ||= asset.content
             end
+          end
+
+          substitutions << [substitution || '', start, finish]
+          nil
         end
+
+        add_parse_error(match, error) if error
       end
 
-      @content << imports.map { |d| d.own_content }.join(IMPORT_JOINER)
+      substitutions.reverse_each do |content, start, finish|
+        @own_content[start...finish] = content
+      end
     end
 
     ##
-    # Compiles the asset if compilation is supported for the asset's type and appends the asset's own
-    # content to the overall content string.
+    # Compiles the asset if compilation is supported for the asset's type.
     #
     def compile
-      if @delegate.compile
-        begin
-          @own_content = @delegate.compile.(@path, @own_content)
-        rescue => e
-          @errors << e
-        end
-      end
+      return if ran?(:compile)
+
+      substitute
 
-      @content << @own_content
+      begin
+        compiled = @delegate.compile_handler&.call(
+          parse_data: @parse_data,
+          path: @path,
+          own_content: @own_content
+        )
+
+        @own_content = compiled if compiled.kind_of?(String)
+      rescue => e
+        @errors << e
+      ensure
+        @own_content.freeze
+      end
     end
 
     ##
-    # Minifies the asset if minification is supported for the asset's type, asset is marked as minifiable
-    # (i.e. it's not already minified), and the asset is not marked as internal-only.
+    # Returns the processed content of the asset without dependencies concatenated.
     #
-    def minify
-      if @delegate.minify && @minify && !@internal
-        begin
-          @content = @delegate.minify.(@content)
-        rescue => e
-          @errors << e
-        end
-      end
+    def own_content
+      compile
 
-      @content
+      @own_content
     end
 
+    private
+
     ##
     # Requires any libraries necessary for compiling and minifying the asset based on its type. Raises a
     # MissingLibraryError if library cannot be loaded.
@@ -455,46 +556,66 @@ class Darkroom
     end
 
     ##
-    # Utility method used by #dependencies and #imports to recursively build arrays.
+    # Returns boolean indicating if a method has already been run during the current round of processing.
     #
-    # * +name+ - Name of the array to accumulate (:dependencies or :imports).
-    # * +ignore+ - Set of assets already accumulated which can be ignored (used to avoid infinite loops when
-    #   circular references are encountered).
+    # [name] Name of the method.
     #
-    def accumulate(name, ignore)
-      ignore ||= Set.new
-      ignore << self
-
-      process
-
-      instance_variable_get(:"@own_#{name}").each_with_object([]) do |asset, assets|
-        next if ignore.include?(asset)
+    def ran?(name)
+      modified?
 
-        asset.process
-        assets.push(*asset.send(name, ignore), asset)
-        assets.uniq!
-        assets.delete(self)
+      if @ran.member?(name)
+        true
+      else
+        @ran << name
+        false
       end
     end
 
     ##
-    # Utility method that returns the appropriate error for a dependency that doesn't exist.
+    # Utility method used by #dependencies and #imports to recursively build arrays.
     #
-    # * +path+ - Path of the asset which cannot be found.
-    # * +match+ - MatchData object of the regex for the asset that cannot be found.
+    # [name] Name of the array to accumulate (:dependencies or :imports).
     #
-    def not_found_error(path, match)
-      klass = Darkroom.delegate(File.extname(path)) ? AssetNotFoundError : UnrecognizedExtensionError
-      klass.new(path, @path, line_num(match))
+    def accumulate(name)
+      done = Set.new
+      assets = [self]
+      index = 0
+
+      while index
+        asset = assets[index]
+        done << asset
+        additional = asset.send(name).reject { |a| done.include?(a) }
+        assets.insert(index, *additional).uniq!
+        index = assets.index { |a| !done.include?(a) }
+      end
+
+      assets.delete(self)
+      assets
     end
 
     ##
-    # Utility method that returns the line number where a regex match was found.
-    #
-    # * +match+ - MatchData object of the regex.
-    #
-    def line_num(match)
-      @own_content[0..match.begin(:path)].count("\n") + 1
+    # Utility method to create a parse error of the appropriate class and append it to the errors array.
+    #
+    # [match] MatchData object for where the parse error occurred.
+    # [error] Error class or message.
+    #
+    def add_parse_error(match, error)
+      klass = error
+      args = []
+
+      if error == AssetNotFoundError
+        klass = UnrecognizedExtensionError unless Darkroom.delegate(File.extname(match[:path]))
+        args << match[:path]
+      else
+        if error.kind_of?(String)
+          klass = AssetError
+          args << error
+        end
+
+        args << match[0].strip
+      end
+
+      @errors << klass.new(*args, @path, @own_content[0..match.begin(:path)].count("\n") + 1)
     end
   end
 end