method

glob

v1_8_6_287 - Show latest stable - Class: Dir

glob(...)

public

Returns the filenames found by expanding pattern which is an Array of the patterns or the pattern String, either as an array or as parameters to the block. Note that this pattern is not a regexp (it’s closer to a shell glob). See File::fnmatch for the meaning of the flags parameter. Note that case sensitivity depends on your system (so File::FNM_CASEFOLD is ignored)

`*`:	Matches any file. Can be restricted by other values in the glob. `` will match all files; `c` will match all files beginning with `c;` `c` will match all files ending with `c;` and `c`* will match all files that have `c` in them (including at the beginning or end). Equivalent to `/ .* /x` in regexp.
`**`:	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`. Matching literals may be more than one character in length. More than two literals may be specified. Equivalent to pattern alternation in regexp.
<code></code>:	Escapes the next metacharacter.

   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"]

   rbfiles = File.join("**", "*.rb")
   Dir.glob(rbfiles)                   #=> ["main.rb",
                                            "lib/song.rb",
                                            "lib/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"]

/*
 *  call-seq:
 *     Dir.glob( pattern, [flags] ) => array
 *     Dir.glob( pattern, [flags] ) {| filename | block }  => nil
 *
 *  Returns the filenames found by expanding <i>pattern</i> which is
 *  an +Array+ of the patterns or the pattern +String+, either as an
 *  <i>array</i> or as parameters to the block. Note that this pattern
 *  is not a regexp (it's closer to a shell glob). See
 *  <code>File::fnmatch</code> for the meaning of the <i>flags</i>
 *  parameter. Note that case sensitivity depends on your system (so
 *  <code>File::FNM_CASEFOLD</code> is ignored)
 *
 *  <code>*</code>::        Matches any file. Can be restricted by
 *                          other values in the glob. <code>*</code>
 *                          will match all files; <code>c*</code> will
 *                          match all files beginning with
 *                          <code>c</code>; <code>*c</code> will match
 *                          all files ending with <code>c</code>; and
 *                          <code>*c*</code> will match all files that
 *                          have <code>c</code> in them (including at
 *                          the beginning or end). Equivalent to
 *                          <code>/ .* /x</code> in regexp.
 *  <code>**</code>::       Matches directories recursively.
 *  <code>?</code>::        Matches any one character. Equivalent to
 *                          <code>/.{1}/</code> in regexp.
 *  <code>[set]</code>::    Matches any one character in +set+.
 *                          Behaves exactly like character sets in
 *                          Regexp, including set negation
 *                          (<code>[^a-z]</code>).
 *  <code>{p,q}</code>::    Matches either literal <code>p</code> or
 *                          literal <code>q</code>. Matching literals
 *                          may be more than one character in length.
 *                          More than two literals may be specified.
 *                          Equivalent to pattern alternation in
 *                          regexp.
 *  <code>\</code>::        Escapes the next metacharacter.
 *
 *     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"]
 *
 *     rbfiles = File.join("**", "*.rb")
 *     Dir.glob(rbfiles)                   #=> ["main.rb",
 *                                              "lib/song.rb",
 *                                              "lib/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"]
 */
static VALUE
dir_s_glob(argc, argv, obj)
    int argc;
    VALUE *argv;
    VALUE obj;
{
    VALUE str, rflags, ary;
    int flags;

    if (rb_scan_args(argc, argv, "11", &str, &rflags) == 2)
        flags = NUM2INT(rflags);
    else
        flags = 0;

    ary = rb_check_array_type(str);
    if (NIL_P(ary)) {
        ary = rb_push_glob(str, flags);
    }
    else {
        volatile VALUE v = ary;
        ary = dir_globs(RARRAY_LEN(v), RARRAY_PTR(v), flags);
    }

    if (rb_block_given_p()) {
        rb_ary_each(ary);
        return Qnil;
    }
    return ary;
}

4Notes

Getting relative path from absolute globbing

Mange · Oct 19, 20092 thanks

Say you want to scan for files in directory +base_dir+ and you want to use the relative path from this base dir, you could do it like this:

base_dir = '/path/to/dir'
files = Dir[File.join(base_dir, '**', '*.yml')]

# files now contain absolute paths:
files.first # => "/path/to/dir/foo/bar.yml"

# let's make them relative
base_pathname = Pathname.new(base_dir)
files = files.collect do |file|
Pathname.new(file).relative_path_from(base_pathname)
end

files.first # => "foo/bar.yml"

Of course, a more common use-case could be the following:

def scan_for_documents!
base_path = Pathname.new(self.base_path)
self.contained_files = []
Dir[File.join(self.base_path, '**', '*.pdf')].each do |full_path|
  path = Pathname.new(full_path).relative_path_from(base_path)
  self.contained_files << path
end
end

Alternative way to show relative paths from absolute globbing

syborg · Aug 19, 2011

An alternative to show relative paths is using the well known String#sub! method

base_dir = File.expand_path("my_dir") << "/" # don't miss adding "/"
files = Dir[File.join(base_dir, '**', '*.html.gz')]
p files.map {|f| f.sub!(base_dir,"")}

And yet another way to get relative path from absolute globbing

lazylester · May 2, 2017

If you execute glob within a block passed to Dir.chdir, you get the paths relative to the directory specified by Dir.chdir... like this... base_dir = '/path/to/dir' files = Dir.chdir(base_dir) do Dir.glob("**/*.yml") end files.first # => 'foo/bar.yml'

Faker Gem: Fake Data Generation in Ruby

rubyonrailsdevelopment · Jun 28, 2017

Gems are libraries in Rails that generally enable you to write the application code faster and thereby making a great product in far lesser time. Usually, whenever we start developing any application, there comes a point when we need data which we can use to see how the application will behave while doing some load testing or how it would look when we deploy it to the production. The manual process of creating the data can be daunting. Faker gem serves to take this pain away by generating the fake data just as needed and saving us all the time and effort otherwise wasted in the manual process of data-generation.

It can generate almost any kind of data suitable for our application. For example, it can generate the fake data for fields such as name, email, passwords, phone-numbers, paragraphs, etc. It is therefore, an awesome way of populating the model (which is a database layer in Rails)

Let’s take a look at this gem by creating a sample project. Read More: http://www.railscarma.com/blog/technical-articles/faker-gem-fake-data-generation-ruby/