class Rake::FileList

def *(other)
  result = @items * other
  case result
  when Array
    self.class.new.import(result)
  else
    result
  end
end

def <<(obj)
  resolve
  @items << Rake.from_pathname(obj)
  self
end

def ==(array)
  to_ary == array
end

def [](*args)
  new(*args)
end

def add_matching(pattern)
  self.class.glob(pattern).each do |fn|
    self << fn unless excluded_from_list?(fn)
  end
end

def clear_exclude
  @exclude_patterns = []
  @exclude_procs = []
  self
end

def egrep(pattern, *options)
  matched = 0
  each do |fn|
    begin
      File.open(fn, "r", *options) do |inf|
        count = 0
        inf.each do |line|
          count += 1
          if pattern.match(line)
            matched += 1
            if block_given?
              yield fn, count, line
            else
              puts "#{fn}:#{count}:#{line}"
            end
          end
        end
      end
    rescue StandardError => ex
      $stderr.puts "Error while processing '#{fn}': #{ex}"
    end
  end
  matched
end

def exclude(*patterns, &block)
  patterns.each do |pat|
    if pat.respond_to? :to_ary
      exclude(*pat.to_ary)
    else
      @exclude_patterns << Rake.from_pathname(pat)
    end
  end
  @exclude_procs << block if block_given?
  resolve_exclude unless @pending
  self
end

def excluded_from_list?(fn)
  return true if @exclude_patterns.any? do |pat|
    case pat
    when Regexp
      fn =~ pat
    when GLOB_PATTERN
      flags = File::FNM_PATHNAME
      # Ruby <= 1.9.3 does not support File::FNM_EXTGLOB
      flags |= File::FNM_EXTGLOB if defined? File::FNM_EXTGLOB
      File.fnmatch?(pat, fn, flags)
    else
      fn == pat
    end
  end
  @exclude_procs.any? { |p| p.call(fn) }
end

def existing
  select { |fn| File.exist?(fn) }.uniq
end

def existing!
  resolve
  @items = @items.select { |fn| File.exist?(fn) }.uniq
  self
end

def ext(newext="")
  collect { |fn| fn.ext(newext) }
end

def glob(pattern, *args)
  Dir.glob(pattern, *args).sort
end

def gsub(pat, rep)
  inject(self.class.new) { |res, fn| res << fn.gsub(pat, rep) }
end

def gsub!(pat, rep)
  each_with_index { |fn, i| self[i] = fn.gsub(pat, rep) }
  self
end

def import(array) # :nodoc:
  @items = array
  self
end

def include(*filenames)
  # TODO: check for pending
  filenames.each do |fn|
    if fn.respond_to? :to_ary
      include(*fn.to_ary)
    else
      @pending_add << Rake.from_pathname(fn)
    end
  end
  @pending = true
  self
end

def initialize(*patterns)
  @pending_add = []
  @pending = false
  @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
  @exclude_procs = DEFAULT_IGNORE_PROCS.dup
  @items = []
  patterns.each { |pattern| include(pattern) }
  yield self if block_given?
end

def is_a?(klass)
  klass == Array || super(klass)
end

def partition(&block)       # :nodoc:
  resolve
  result = @items.partition(&block)
  [
    self.class.new.import(result[0]),
    self.class.new.import(result[1]),
  ]
end

def pathmap(spec=nil, &block)
  collect { |fn| fn.pathmap(spec, &block) }
end

def resolve
  if @pending
    @pending = false
    @pending_add.each do |fn| resolve_add(fn) end
    @pending_add = []
    resolve_exclude
  end
  self
end

def resolve_add(fn) # :nodoc:
  case fn
  when GLOB_PATTERN
    add_matching(fn)
  else
    self << fn
  end
end

def resolve_exclude # :nodoc:
  reject! { |fn| excluded_from_list?(fn) }
  self
end

def sub(pat, rep)
  inject(self.class.new) { |res, fn| res << fn.sub(pat, rep) }
end

def sub!(pat, rep)
  each_with_index { |fn, i| self[i] = fn.sub(pat, rep) }
  self
end

def to_a
  resolve
  @items
end

def to_ary
  to_a
end

def to_s
  resolve
  self.join(" ")
end