Class: Rake::FileList
Overview
######################################################################### A FileList is essentially an array with a few helper methods defined to make file manipulation a bit easier.
FileLists are lazy. When given a list of glob patterns for possible files to be included in the file list, instead of searching the file structures to find the files, a FileList holds the pattern for latter use.
This allows us to define a number of FileList to match any number of files, but only search out the actual files when then FileList itself is actually used. The key is that the first time an element of the FileList/Array is requested, the pending patterns are resolved into a real list of file names.
Constant Summary collapse
- ARRAY_METHODS =
List of array methods (that are not in
Object
) that need to be delegated. (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
- MUST_DEFINE =
List of additional methods that must be delegated.
%w[to_a inspect]
- MUST_NOT_DEFINE =
List of methods that should not be delegated here (we define special versions of them explicitly below).
%w[to_a to_ary partition *]
- SPECIAL_RETURN =
List of delegated methods that return new array values which need wrapping.
%w[ map collect sort sort_by select find_all reject grep compact flatten uniq values_at + - & | ]
- DELEGATING_METHODS =
(ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq
- DEFAULT_IGNORE_PATTERNS =
[ /(^|[\/\\])CVS([\/\\]|$)/, /(^|[\/\\])\.svn([\/\\]|$)/, /\.bak$/, /~$/ ]
- DEFAULT_IGNORE_PROCS =
[ proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) } ]
Class Method Summary collapse
-
.[](*args) ⇒ Object
Create a new file list including the files listed.
Instance Method Summary collapse
-
#*(other) ⇒ Object
Redefine * to return either a string or a new file list.
-
#==(array) ⇒ Object
Define equality.
- #calculate_exclude_regexp ⇒ Object
-
#clear_exclude ⇒ Object
Clear all the exclude patterns so that we exclude nothing.
-
#egrep(pattern) ⇒ Object
Grep each of the files in the filelist using the given pattern.
-
#exclude(*patterns, &block) ⇒ Object
Register a list of file name patterns that should be excluded from the list.
-
#exclude?(fn) ⇒ Boolean
Should the given file name be excluded?.
-
#existing ⇒ Object
Return a new file list that only contains file names from the current file list that exist on the file system.
-
#existing! ⇒ Object
Modify the current file list so that it contains only file name that exist on the file system.
-
#ext(newext = '') ⇒ Object
Return a new array with
String#ext
method applied to each member of the array. -
#gsub(pat, rep) ⇒ Object
Return a new FileList with the results of running
gsub
against each element of the original list. -
#gsub!(pat, rep) ⇒ Object
Same as
gsub
except that the original file list is modified. -
#import(array) ⇒ Object
@exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup.
-
#include(*filenames) ⇒ Object
(also: #add)
Add file names defined by glob patterns to the file list.
-
#initialize(*patterns) {|_self| ... } ⇒ FileList
constructor
Create a file list from the globbable patterns given.
-
#is_a?(klass) ⇒ Boolean
(also: #kind_of?)
Lie about our class.
-
#partition(&block) ⇒ Object
FileList version of partition.
-
#pathmap(spec = nil) ⇒ Object
Apply the pathmap spec to each of the included file names, returning a new file list with the modified paths.
-
#resolve ⇒ Object
Resolve all the pending adds now.
-
#sub(pat, rep) ⇒ Object
Return a new FileList with the results of running
sub
against each element of the oringal list. -
#sub!(pat, rep) ⇒ Object
Same as
sub
except that the oringal file list is modified. -
#to_a ⇒ Object
Return the internal array object.
-
#to_ary ⇒ Object
Return the internal array object.
-
#to_s ⇒ Object
Convert a FileList to a string by joining all elements with a space.
Methods included from Cloneable
Constructor Details
#initialize(*patterns) {|_self| ... } ⇒ FileList
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 |
# File 'lib/rake.rb', line 1273 def initialize(*patterns) @pending_add = [] @pending = false @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup @exclude_procs = DEFAULT_IGNORE_PROCS.dup @exclude_re = nil @items = [] patterns.each { |pattern| include(pattern) } yield self if block_given? end |
Class Method Details
Instance Method Details
#*(other) ⇒ Object
Redefine * to return either a string or a new file list.
1368 1369 1370 1371 1372 1373 1374 1375 1376 |
# File 'lib/rake.rb', line 1368 def *(other) result = @items * other case result when Array FileList.new.import(result) else result end end |
#==(array) ⇒ Object
Define equality.
1346 1347 1348 |
# File 'lib/rake.rb', line 1346 def ==(array) to_ary == array end |
#calculate_exclude_regexp ⇒ Object
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 |
# File 'lib/rake.rb', line 1389 def calculate_exclude_regexp ignores = [] @exclude_patterns.each do |pat| case pat when Regexp ignores << pat when /[*?]/ Dir[pat].each do |p| ignores << p end else ignores << Regexp.quote(pat) end end if ignores.empty? @exclude_re = /^$/ else re_str = ignores.collect { |p| "(" + p.to_s + ")" }.join("|") @exclude_re = Regexp.new(re_str) end end |
#clear_exclude ⇒ Object
Clear all the exclude patterns so that we exclude nothing.
1338 1339 1340 1341 1342 1343 |
# File 'lib/rake.rb', line 1338 def clear_exclude @exclude_patterns = [] @exclude_procs = [] calculate_exclude_regexp if ! @pending self end |
#egrep(pattern) ⇒ Object
Grep each of the files in the filelist using the given pattern. If a block is given, call the block on each matching line, passing the file name, line number, and the matching line of text. If no block is given, a standard emac style file:linenumber:line message will be printed to standard out.
1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 |
# File 'lib/rake.rb', line 1484 def egrep(pattern) each do |fn| open(fn) do |inf| count = 0 inf.each do |line| count += 1 if pattern.match(line) if block_given? yield fn, count, line else puts "#{fn}:#{count}:#{line}" end end end end end end |
#exclude(*patterns, &block) ⇒ Object
Register a list of file name patterns that should be excluded from the list. Patterns may be regular expressions, glob patterns or regular strings. In addition, a block given to exclude will remove entries that return true when given to the block.
Note that glob patterns are expanded against the file system. If a file is explicitly added to a file list, but does not exist in the file system, then an glob pattern in the exclude list will not exclude the file.
Examples:
FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
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']
If “a.c” is not a file, then …
FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 |
# File 'lib/rake.rb', line 1325 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 |
#exclude?(fn) ⇒ Boolean
Should the given file name be excluded?
1542 1543 1544 1545 |
# File 'lib/rake.rb', line 1542 def exclude?(fn) calculate_exclude_regexp unless @exclude_re fn =~ @exclude_re || @exclude_procs.any? { |p| p.call(fn) } end |
#existing ⇒ Object
Return a new file list that only contains file names from the current file list that exist on the file system.
1504 1505 1506 |
# File 'lib/rake.rb', line 1504 def existing select { |fn| File.exist?(fn) } end |
#existing! ⇒ Object
Modify the current file list so that it contains only file name that exist on the file system.
1510 1511 1512 1513 1514 |
# File 'lib/rake.rb', line 1510 def existing! resolve @items = @items.select { |fn| File.exist?(fn) } self end |
#ext(newext = '') ⇒ Object
Return a new array with String#ext
method applied to each member of the array.
This method is a shortcut for:
array.collect { |item| item.ext(newext) }
ext
is a user added method for the Array class.
1474 1475 1476 |
# File 'lib/rake.rb', line 1474 def ext(newext='') collect { |fn| fn.ext(newext) } end |
#gsub(pat, rep) ⇒ Object
Return a new FileList with the results of running gsub
against each element of the original list.
Example:
FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
=> ['lib\\test\\file', 'x\\y']
1443 1444 1445 |
# File 'lib/rake.rb', line 1443 def gsub(pat, rep) inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) } end |
#gsub!(pat, rep) ⇒ Object
Same as gsub
except that the original file list is modified.
1454 1455 1456 1457 |
# File 'lib/rake.rb', line 1454 def gsub!(pat, rep) each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) } self end |
#import(array) ⇒ Object
@exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
1558 1559 1560 1561 |
# File 'lib/rake.rb', line 1558 def import(array) @items = array self end |
#include(*filenames) ⇒ Object Also known as: add
Add file names defined by glob patterns to the file list. If an array is given, add each element of the array.
Example:
file_list.include("*.java", "*.cfg")
file_list.include %w( math.c lib.h *.o )
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 |
# File 'lib/rake.rb', line 1291 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 |
#is_a?(klass) ⇒ Boolean Also known as: kind_of?
Lie about our class.
1362 1363 1364 |
# File 'lib/rake.rb', line 1362 def is_a?(klass) klass == Array || super(klass) end |
#partition(&block) ⇒ Object
FileList version of partition. Needed because the nested arrays should be FileLists in this version.
1518 1519 1520 1521 1522 1523 1524 1525 |
# File 'lib/rake.rb', line 1518 def partition(&block) # :nodoc: resolve result = @items.partition(&block) [ FileList.new.import(result[0]), FileList.new.import(result[1]), ] end |
#pathmap(spec = nil) ⇒ Object
Apply the pathmap spec to each of the included file names, returning a new file list with the modified paths. (See String#pathmap for details.)
1462 1463 1464 |
# File 'lib/rake.rb', line 1462 def pathmap(spec=nil) collect { |fn| fn.pathmap(spec) } end |
#resolve ⇒ Object
Resolve all the pending adds now.
1379 1380 1381 1382 1383 1384 1385 1386 1387 |
# File 'lib/rake.rb', line 1379 def resolve if @pending @pending = false @pending_add.each do |fn| resolve_add(fn) end @pending_add = [] resolve_exclude end self end |
#sub(pat, rep) ⇒ Object
Return a new FileList with the results of running sub
against each element of the oringal list.
Example:
FileList['a.c', 'b.c'].sub(/\.c$/, '.o') => ['a.o', 'b.o']
1432 1433 1434 |
# File 'lib/rake.rb', line 1432 def sub(pat, rep) inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) } end |
#sub!(pat, rep) ⇒ Object
Same as sub
except that the oringal file list is modified.
1448 1449 1450 1451 |
# File 'lib/rake.rb', line 1448 def sub!(pat, rep) each_with_index { |fn, i| self[i] = fn.sub(pat,rep) } self end |
#to_a ⇒ Object
Return the internal array object.
1351 1352 1353 1354 |
# File 'lib/rake.rb', line 1351 def to_a resolve @items end |
#to_ary ⇒ Object
Return the internal array object.
1357 1358 1359 |
# File 'lib/rake.rb', line 1357 def to_ary to_a end |
#to_s ⇒ Object
Convert a FileList to a string by joining all elements with a space.
1528 1529 1530 1531 |
# File 'lib/rake.rb', line 1528 def to_s resolve self.join(' ') end |