class Rake::FileList


list of file names.
FileList/Array is requested, the pending patterns are resolved into a real
actually used. The key is that the first time an element of the
files, but only search out the actual files when then FileList itself is
This allows us to define a number of FileList to match any number of
to find the files, a FileList holds the pattern for latter use.
to be included in the file list, instead of searching the file structures
FileLists are lazy. When given a list of glob patterns for possible files
make file manipulation a bit easier.
A FileList is essentially an array with a few helper methods defined to
#########################################################################

def *(other)

Redefine * to return either a string or a new file list. 
def *(other)
  result = @items * other
  case result
  when Array
    FileList.new.import(result)
  else
    result
  end
end

def ==(array)

Define equality. 
def ==(array)
  to_ary == array
end

def [](*args)

FileList.new(*args)

Create a new file list including the files listed. Similar to: 
def [](*args)
  new(*args)
end

def add_matching(pattern)

Add matching glob patterns. 
def add_matching(pattern)
  Rake.glob(pattern).each do |fn|
    self << fn unless exclude?(fn)
  end
end

def clear_exclude

Clear all the exclude patterns so that we exclude nothing. 
def clear_exclude
  @exclude_patterns = []
  @exclude_procs = []
  self
end

def egrep(pattern, *options)

standard out. Returns the number of matched items.
a standard emacs style file:linenumber:line message will be printed to
name, line number, and the matching line of text. If no block is given,
block is given, call the block on each matching line, passing the file
Grep each of the files in the filelist using the given pattern. If a 
def egrep(pattern, *options)
  matched = 0
  each do |fn|
    begin
      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)


FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
If "a.c" is not a file, then ...

FileList['a.c', 'b.c'].exclude("a.*") => ['b.c']
If "a.c" is a file, then ...

FileList['a.c', 'b.c'].exclude(/^a/) => ['b.c']
FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
Examples:

file.
system, then an glob pattern in the exclude list will not exclude the
is explicitly added to a file list, but does not exist in the file
Note that glob patterns are expanded against the file system. If a file

return true when given to the block.
strings. In addition, a block given to exclude will remove entries that
list. Patterns may be regular expressions, glob patterns or regular
Register a list of file name patterns that should be excluded from the 
def exclude(*patterns, &block)
  patterns.each do |pat|
    @exclude_patterns << pat
  end
  if block_given?
    @exclude_procs << block
  end
  resolve_exclude if ! @pending
  self
end

def exclude?(fn)

Should the given file name be excluded? 
def exclude?(fn)
  return true if @exclude_patterns.any? do |pat|
    case pat
    when Regexp
      fn =~ pat
    when /[*?]/
      File.fnmatch?(pat, fn, File::FNM_PATHNAME)
    else
      fn == pat
    end
  end
  @exclude_procs.any? { |p| p.call(fn) }
end

def existing

file list that exist on the file system.
Return a new file list that only contains file names from the current 
def existing
  select { |fn| File.exist?(fn) }
end

def existing!

exist on the file system.
Modify the current file list so that it contains only file name that 
def existing!
  resolve
  @items = @items.select { |fn| File.exist?(fn) }
  self
end

def ext(newext='')

+ext+ is a user added method for the Array class.

array.collect { |item| item.ext(newext) }

This method is a shortcut for:

each member of the array.
Return a new FileList with String#ext method applied to 
def ext(newext='')
  collect { |fn| fn.ext(newext) }
end

def gsub(pat, rep)


=> ['lib\\test\\file', 'x\\y']
FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
Example:

element of the original list.
Return a new FileList with the results of running +gsub+ against each 
def gsub(pat, rep)
  inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) }
end

def gsub!(pat, rep)

Same as +gsub+ except that the original file list is modified. 
def gsub!(pat, rep)
  each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) }
  self
end

def import(array) 

def import(array)
  @items = array
  self
end

def include(*filenames)


file_list.include %w( math.c lib.h *.o )
file_list.include("*.java", "*.cfg")
Example:

is given, add each element of the array.
Add file names defined by glob patterns to the file list. If an array 
def include(*filenames)
  # TODO: check for pending
  filenames.each do |fn|
    if fn.respond_to? :to_ary
      include(*fn.to_ary)
    else
      @pending_add << fn
    end
  end
  @pending = true
  self
end

def initialize(*patterns)


end
fl.exclude(/\bCVS\b/)
pkg_files = FileList.new('lib/**/*') do |fl|

file_list = FileList.new('lib/**/*.rb', 'test/test*.rb')
Example:

"yield self" pattern.
perform multiple includes or excludes at object build time, use the
Create a file list from the globbable patterns given. If you wish to 
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)

Lie about our class. 
def is_a?(klass)
  klass == Array || super(klass)
end

def partition(&block) # :nodoc:

:nodoc:
be FileLists in this version.
FileList version of partition. Needed because the nested arrays should 
def partition(&block)       # :nodoc:
  resolve
  result = @items.partition(&block)
  [
    FileList.new.import(result[0]),
    FileList.new.import(result[1]),
  ]
end

def pathmap(spec=nil)

details.)
new file list with the modified paths. (See String#pathmap for
Apply the pathmap spec to each of the included file names, returning a 
def pathmap(spec=nil)
  collect { |fn| fn.pathmap(spec) }
end

def resolve

Resolve all the pending adds now. 
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) 

def resolve_add(fn)
  case fn
  when %r{[*?\[\{]}
    add_matching(fn)
  else
    self << fn
  end
end

def resolve_exclude 

def resolve_exclude
  reject! { |fn| exclude?(fn) }
  self
end

def sub(pat, rep)


FileList['a.c', 'b.c'].sub(/\.c$/, '.o') => ['a.o', 'b.o']
Example:

element of the original list.
Return a new FileList with the results of running +sub+ against each 
def sub(pat, rep)
  inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) }
end

def sub!(pat, rep)

Same as +sub+ except that the original file list is modified. 
def sub!(pat, rep)
  each_with_index { |fn, i| self[i] = fn.sub(pat,rep) }
  self
end

def to_a

Return the internal array object. 
def to_a
  resolve
  @items
end

def to_ary

Return the internal array object. 
def to_ary
  to_a
end

def to_s

Convert a FileList to a string by joining all elements with a space. 
def to_s
  resolve
  self.join(' ')
end