File

Returns the last component of the given path.

File.basename("/foo/bar/file.cr") # => "file.cr"

Returns the last component of the given path.

If suffix is present at the end of path, it is removed.

File.basename("/foo/bar/file.cr", ".cr") # => "file"

Changes the permissions of the specified file.

Symlinks are dereferenced, so that only the permissions of the symlink destination are changed, never the permissions of the symlink itself.

File.chmod("foo", 0o755)
File.stat("foo").perm # => 0o755

File.chmod("foo", 0o700)
File.stat("foo").perm # => 0o700

Changes the owner of the specified file.

File.chown("/foo/bar/baz.cr", 1001, 100)
File.chown("/foo/bar", gid: 100)

Unless follow_symlinks is set to true, then the owner symlink itself will be changed, otherwise the owner of the symlink destination file will be changed. For example, assuming symlinks as foo -> bar -> baz:

File.chown("foo", gid: 100)                        # changes foo's gid
File.chown("foo", gid: 100, follow_symlinks: true) # changes baz's gid

Delete the file at path. Deleting non-existent file will raise an exception.

File.write("foo", "")
File.delete("./foo")
File.delete("./bar") # raises Errno (No such file or directory)

Returns true if the given path exists and is a directory.

File.write("foo", "")
Dir.mkdir("dir2")
File.directory?("foo")    # => false
File.directory?("dir2")   # => true
File.directory?("foobar") # => false

Returns all components of the given path except the last one.

File.dirname("/foo/bar/file.cr") # => "/foo/bar"

Yields each line in filename to the given block.

File.write("foobar", "foo\nbar")

array = [] of String
File.each_line("foobar") do |line|
  array << line
end
array # => ["foo", "bar"]

Returns an Iterator for each line in filename.

Returns true if the file at path is empty, otherwise returns false. Raises Errno if the file at path does not exist-

File.write("foo", "")
File.empty?("foo") # => true
File.write("foo", "foo")
File.empty?("foo") # => false

Returns true if path is executable by the real user id of this process else returns false.

File.write("foo", "foo")
File.executable?("foo") # => false

Returns true if path exists else returns false

File.delete("foo") if File.exists?("foo")
File.exists?("foo") # => false
File.write("foo", "foo")
File.exists?("foo") # => true

Converts path to an absolute path. Relative paths are referenced from the current working directory of the process unless dir is given, in which case it will be used as the starting point.

File.expand_path("foo")             # => "/home/.../foo"
File.expand_path("~/crystal/foo")   # => "/home/crystal/foo"
File.expand_path("baz", "/foo/bar") # => "/foo/bar/baz"

Returns filename's extension, or an empty string if it has no extension.

File.extname("foo.cr") # => ".cr"

Returns true if given path exists and is a file.

File.write("foo", "")
Dir.mkdir("dir1")
File.file?("foo")    # => true
File.file?("dir1")   # => false
File.file?("foobar") # => false

Returns a new string formed by joining the strings using File::SEPARATOR.

File.join({"foo", "bar", "baz"})       # => "foo/bar/baz"
File.join({"foo/", "/bar/", "/baz"})   # => "foo/bar/baz"
File.join(["/foo/", "/bar/", "/baz/"]) # => "/foo/bar/baz/"

Returns a new string formed by joining the strings using File::SEPARATOR.

File.join("foo", "bar", "baz")       # => "foo/bar/baz"
File.join("foo/", "/bar/", "/baz")   # => "foo/bar/baz"
File.join("/foo/", "/bar/", "/baz/") # => "/foo/bar/baz/"

Creates a new link (also known as a hard link) at new_path to an existing file given by old_path.

Returns a File::Stat object for the file given by path or raises Errno in case of an error- In case of a symbolic link information about it is returned-

File.write("foo", "foo")
File.lstat("foo").size  # => 3
File.lstat("foo").mtime # => 2015-09-23 06:24:19 UTC

Opens the file named by filename. If a file is being created, its initial permissions may be set using the perm parameter.

Opens the file named by filename. If a file is being created, its initial permissions may be set using the perm parameter. Then given block will be passed the opened file as an argument, the file will be automatically closed when the block returns.

Returns the content of filename as a string.

File.write("bar", "foo")
File.read("bar") # => "foo"

Returns all lines in filename as an array of strings.

File.write("foobar", "foo\nbar")
File.read_lines("foobar") # => ["foo", "bar"]

Returns true if path is readable by the real user id of this process else returns false.

File.write("foo", "foo")
File.readable?("foo") # => true

Resolves the real path of path by following symbolic links.

Moves old_filename to new_filename.

File.write("afile", "foo")
File.exists?("afile") # => true

File.rename("afile", "afile.cr")
File.exists?("afile")    # => false
File.exists?("afile.cr") # => true

Returns the size of filename bytes.

Returns a File::Stat object for the file given by path or raises Errno in case of an error- In case of a symbolic link it is followed and information about the target is returned-

File.write("foo", "foo")
File.stat("foo").size  # => 3
File.stat("foo").mtime # => 2015-09-23 06:24:19 UTC

Creates a symbolic link at new_path to an existing file given by *old_path.

Returns true if the path is a symbolic link.

Attempts to set the access and modification times of the file named in the filename parameter to the value given in time.

If the file does not exist, it will be created.

Sets the access and modification times of filename.

Returns true if path is writable by the real user id of this process else returns false.

File.write("foo", "foo")
File.writable?("foo") # => true

Write the given content to filename.

An existing file will be overwritten, else a file will be created.

File.write("foo", "bar")

NOTE If the content is a Slice(UInt8), those bytes will be written. If it's an IO, all bytes from the IO will be written. Otherwise, the string representation of content will be written (the result of invoking to_s on content).

Place an exclusive advisory lock. Only one process may hold an exclusive lock for a given file at a given time. Errno::EWOULDBLOCK is raised if blocking is set to false and any existing lock is set.

Place a shared advisory lock. More than one process may hold a shared lock for a given file at a given time. Errno::EWOULDBLOCK is raised if blocking is set to false and an existing exclusive lock is set.

Remove an existing advisory lock held by this process.

Yields an IO to read a section inside this file- Mutliple sections can be read concurrently-

Truncates the file to the specified size. Requires that the current file is opened for writing.