class Sprockets::DirectiveProcessor

def compat?
  @compat
end

def constants
  if compat?
    pathname = Pathname.new(context.root_path).join("constants.yml")
    stat(pathname) ? YAML.load_file(pathname) : {}
  else
    {}
  end
end

def directives
  @directives ||= header.lines.each_with_index.map { |line, index|
    if directive = line[DIRECTIVE_PATTERN, 1]
      name, *args = Shellwords.shellwords(directive)
      if respond_to?("process_#{name}_directive", true)
        [index + 1, name, *args]
      end
    end
  }.compact
end

def each_entry(root, &block)
  context.environment.each_entry(root, &block)
end

def entries(path)
  context.environment.entries(path)
end

def evaluate(context, locals, &block)
  @context = context
  @result = ""
  @result.force_encoding(body.encoding) if body.respond_to?(:encoding)
  @has_written_body = false
  process_directives
  process_source
  @result
end

def prepare
  @pathname = Pathname.new(file)
  @header = data[HEADER_PATTERN, 0] || ""
  @body   = $' || data
  # Ensure body ends in a new line
  @body  += "\n" if @body != "" && @body !~ /\n\Z/m
  @included_pathnames = []
  @compat             = false
end

def process_compat_directive
  @compat = true
end

def process_depend_on_asset_directive(path)
  context.depend_on_asset(path)
end

def process_depend_on_directive(path)
  context.depend_on(path)
end

def process_directives
  directives.each do |line_number, name, *args|
    context.__LINE__ = line_number
    send("process_#{name}_directive", *args)
    context.__LINE__ = nil
  end
end

def process_include_directive(path)
  pathname = context.resolve(path)
  context.depend_on_asset(pathname)
  included_pathnames << pathname
end

def process_provide_directive(path)
end

def process_require_directive(path)
  if @compat
    if path =~ /<([^>]+)>/
      path = $1
    else
      path = "./#{path}" unless relative?(path)
    end
  end
  context.require_asset(path)
end

def process_require_directory_directive(path = ".")
  if relative?(path)
    root = pathname.dirname.join(path).expand_path
    unless (stats = stat(root)) && stats.directory?
      raise ArgumentError, "require_directory argument must be a directory"
    end
    context.depend_on(root)
    entries(root).each do |pathname|
      pathname = root.join(pathname)
      if pathname.to_s == self.file
        next
      elsif context.asset_requirable?(pathname)
        context.require_asset(pathname)
      end
    end
  else
    # The path must be relative and start with a `./`.
    raise ArgumentError, "require_directory argument must be a relative path"
  end
end

def process_require_self_directive
  if @has_written_body
    raise ArgumentError, "require_self can only be called once per source file"
  end
  context.require_asset(pathname)
  process_source
  included_pathnames.clear
  @has_written_body = true
end

def process_require_tree_directive(path = ".")
  if relative?(path)
    root = pathname.dirname.join(path).expand_path
    unless (stats = stat(root)) && stats.directory?
      raise ArgumentError, "require_tree argument must be a directory"
    end
    context.depend_on(root)
    each_entry(root) do |pathname|
      if pathname.to_s == self.file
        next
      elsif stat(pathname).directory?
        context.depend_on(pathname)
      elsif context.asset_requirable?(pathname)
        context.require_asset(pathname)
      end
    end
  else
    # The path must be relative and start with a `./`.
    raise ArgumentError, "require_tree argument must be a relative path"
  end
end

def process_source
  unless @has_written_body || processed_header.empty?
    @result << processed_header << "\n"
  end
  included_pathnames.each do |pathname|
    @result << context.evaluate(pathname)
  end
  unless @has_written_body
    @result << body
  end
  if compat? && constants.any?
    @result.gsub!(/<%=(.*?)%>/) { constants[$1.strip] }
  end
end

def process_stub_directive(path)
  context.stub_asset(path)
end

def processed_header
  lineno = 0
  @processed_header ||= header.lines.map { |line|
    lineno += 1
    # Replace directive line with a clean break
    directives.assoc(lineno) ? "\n" : line
  }.join.chomp
end

def processed_source
  @processed_source ||= processed_header + body
end

def relative?(path)
  path =~ /^\.($|\.?\/)/
end

def stat(path)
  context.environment.stat(path)
end