class Dir # Dir.open( string ) -> aDir # Dir.open( string, encoding: enc ) -> aDir # Dir.open( string ) {| aDir | block } -> anObject # Dir.open( string, encoding: enc ) {| aDir | block } -> anObject # # The optional encoding keyword argument specifies the encoding of the directory. # If not specified, the filesystem encoding is used. # # With no block, open is a synonym for Dir::new. If a # block is present, it is passed aDir as a parameter. The # directory is closed at the end of the block, and Dir::open returns # the value of the block. def self.open(name, encoding: nil, &block) dir = Primitive.dir_s_open(name, encoding) if block begin yield dir ensure Primitive.dir_s_close(dir) end else dir end end # Dir.new( string ) -> aDir # Dir.new( string, encoding: enc ) -> aDir # # Returns a new directory object for the named directory. # # The optional encoding keyword argument specifies the encoding of the directory. # If not specified, the filesystem encoding is used. def initialize(name, encoding: nil) Primitive.dir_initialize(name, encoding) end # Dir[ string [, string ...] [, base: path] [, sort: true] ] -> array # # Equivalent to calling # Dir.glob([string,...], 0). def self.[](*args, base: nil, sort: true) Primitive.dir_s_aref(args, base, sort) end # Dir.glob( pattern, [flags], [base: path] [, sort: true] ) -> array # Dir.glob( pattern, [flags], [base: path] [, sort: true] ) { |filename| block } -> nil # # Expands +pattern+, which is a pattern string or an Array of pattern # strings, and returns an array containing the matching filenames. # If a block is given, calls the block once for each matching filename, # passing the filename as a parameter to the block. # # The optional +base+ keyword argument specifies the base directory for # interpreting relative pathnames instead of the current working directory. # As the results are not prefixed with the base directory name in this # case, you will need to prepend the base directory name if you want real # paths. # # The results which matched single wildcard or character set are sorted in # binary ascending order, unless false is given as the optional +sort+ # keyword argument. The order of an Array of pattern strings and braces # are preserved. # # Note that the pattern is not a regexp, it's closer to a shell glob. # See File::fnmatch for the meaning of the +flags+ parameter. # Case sensitivity depends on your system (File::FNM_CASEFOLD is ignored). # # *:: # Matches any file. Can be restricted by other values in the glob. # Equivalent to / .* /mx in regexp. # # *:: Matches all files # c*:: Matches all files beginning with c # *c:: Matches all files ending with c # \*c\*:: Match all files that have c in them # (including at the beginning or end). # # Note, this will not match Unix-like hidden files (dotfiles). In order # to include those in the match results, you must use the # File::FNM_DOTMATCH flag or something like "{*,.*}". # # **:: # Matches directories recursively. # # ?:: # Matches any one character. Equivalent to /.{1}/ in regexp. # # [set]:: # Matches any one character in +set+. Behaves exactly like character sets # in Regexp, including set negation ([^a-z]). # # {p,q}:: # Matches either literal p or literal q. # Equivalent to pattern alternation in regexp. # # Matching literals may be more than one character in length. More than # two literals may be specified. # # \\ :: # Escapes the next metacharacter. # # Note that this means you cannot use backslash on windows as part of a # glob, i.e. Dir["c:\\foo*"] will not work, use # Dir["c:/foo*"] instead. # # Examples: # # Dir["config.?"] #=> ["config.h"] # Dir.glob("config.?") #=> ["config.h"] # Dir.glob("*.[a-z][a-z]") #=> ["main.rb"] # Dir.glob("*.[^r]*") #=> ["config.h"] # Dir.glob("*.{rb,h}") #=> ["main.rb", "config.h"] # Dir.glob("*") #=> ["config.h", "main.rb"] # Dir.glob("*", File::FNM_DOTMATCH) #=> [".", "..", "config.h", "main.rb"] # Dir.glob(["*.rb", "*.h"]) #=> ["main.rb", "config.h"] # # rbfiles = File.join("**", "*.rb") # Dir.glob(rbfiles) #=> ["main.rb", # # "lib/song.rb", # # "lib/song/karaoke.rb"] # # Dir.glob(rbfiles, base: "lib") #=> ["song.rb", # # "song/karaoke.rb"] # # libdirs = File.join("**", "lib") # Dir.glob(libdirs) #=> ["lib"] # # librbfiles = File.join("**", "lib", "**", "*.rb") # Dir.glob(librbfiles) #=> ["lib/song.rb", # # "lib/song/karaoke.rb"] # # librbfiles = File.join("**", "lib", "*.rb") # Dir.glob(librbfiles) #=> ["lib/song.rb"] def self.glob(pattern, _flags = 0, flags: _flags, base: nil, sort: true) Primitive.dir_s_glob(pattern, flags, base, sort) end end