class File
inherits IO::FileDescriptor

A File instance represents a file entry in the local file system and allows using it as an IO.

file = File.new("path/to/file")
content = file.gets_to_end
file.close

# Implicit close with `open`
content = File.open("path/to/file") do |file|
  file.gets_to_end
end

# Shortcut:
content = File.read("path/to/file")

Temporary Files

Every tempfile is operated as a File, including initializing, reading and writing.

tempfile = File.tempfile("foo")

File.size(tempfile.path)                   # => 6
File.info(tempfile.path).modification_time # => 2015-10-20 13:11:12 UTC
File.exists?(tempfile.path)                # => true
File.read_lines(tempfile.path)             # => ["foobar"]

Files created from tempfile are stored in a directory that handles temporary files (Dir.tempdir):

File.tempfile("foo").path # => "/tmp/foo.ulBCPS"

It is encouraged to delete a tempfile after using it, which ensures they are not left behind in your filesystem until garbage collected.

tempfile = File.tempfile("foo")
tempfile.delete

Included modules

Crystal::System::File

Constants

NULL = {% if flag?(:win32) %}"NUL"{% else %}"/dev/null"{% end %}

The name of the null device on the host platform. /dev/null on UNIX and NUL on win32.

When this device is opened using File.open, read operations will always return EOF, and any data written will be immediately discarded.

File.open(File::NULL, "w") do |file|
  file.puts "this is discarded"
end

SEPARATOR = '/'

The file/directory separator character. '/' on all platforms.

SEPARATOR_STRING = "/"

The file/directory separator string. "/" on all platforms.

Class methods

.basename(path : Path | String, suffix : String) : String

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"

View source

.basename(path : Path | String) : String

Returns the last component of the given path.

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

View source

.chmod(path : Path | String, permissions : Int | Permissions)

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.info("foo").permissions.value # => 0o755

File.chmod("foo", 0o700)
File.info("foo").permissions.value # => 0o700

View source

.chown(path : Path | String, uid : Int = -1, gid : Int = -1, follow_symlinks = false)

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

View source

.copy(src : String | Path, dst : String | Path)

Copies the file src to the file dst. Permission bits are copied too.

File.touch("afile")
File.chmod("afile", 0o600)
File.copy("afile", "afile_copy")
File.info("afile_copy").permissions.value # => 0o600

View source

.delete(path : Path | String)

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

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

View source

.directory?(path : Path | String) : Bool

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

View source

.dirname(path : Path | String) : String

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

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

View source

.each_line(filename : Path | String, encoding = nil, invalid = nil, chomp = true

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

View source

.empty?(path : Path | String) : Bool

Returns true if the file at path is empty, otherwise returns false. Raises File::NotFoundError if the file at path does not exist.

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

View source

.executable?(path : Path | String) : Bool

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

View source

.exists?(path : Path | String) : Bool

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

View source

.expand_path(path : Path | String, dir = nil, *, home = false) : String

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. "~" is expanded to the value passed to home. If it is false (default), home is not expanded. If true, it is expanded to the user's home directory (Path.home).

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

View source

.extname(filename : Path | String) : String

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

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

View source

.file?(path : Path | String) : Bool

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

View source

.info(path : Path | String, follow_symlinks = true) : Info

Returns a File::Info object for the file given by path or raises File::Error in case of an error.

If follow_symlinks is set (the default), symbolic links are followed. Otherwise, symbolic links return information on the symlink itself.

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

File.symlink("foo", "bar")
File.info("bar", follow_symlinks: false).type.symlink? # => true

View source

.info?(path : Path | String, follow_symlinks = true) : Info?

Returns a File::Info object for the file given by path or returns nil if the file does not exist.

If follow_symlinks is set (the default), symbolic links are followed. Otherwise, symbolic links return information on the symlink itself.

File.write("foo", "foo")
File.info?("foo").try(&.size) # => 3
File.info?("non_existent")    # => nil

File.symlink("foo", "bar")
File.info?("bar", follow_symlinks: false).try(&.type.symlink?) # => true

View source

.join(parts : Array | Tuple) : String

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

View source

.join(*parts : String | Path) : String

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

View source

.link(old_path : Path | String, new_path : Path | String)

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

View source

.match?(pattern : String, path : Path | String)

Matches path against pattern.

The pattern syntax is similar to shell filename globbing. It may contain the following metacharacters:

• * matches an unlimited number of arbitrary characters excluding /.
• "*" matches all regular files.
• "c*" matches all files beginning with c.
• "*c" matches all files ending with c.
• "*c*" matches all files that have c in them (including at the beginning or end).
• ** matches an unlimited number of arbitrary characters including /.
• ? matches any one character excluding /.
• character sets:
• [abc] matches any one of these character.
• [^abc] matches any one character other than these.
• [a-z] matches any one character in the range.
• {a,b} matches subpattern a or b.
• \\ escapes the next character.

Note

Only / is recognized as path separator in both pattern and path.

View source

.open(filename : Path | String, mode = "r", perm = DEFAULT_CREATE_PERMISSIONS, encoding = nil, invalid = nil

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.

See self.new for what mode can be.

View source

.read(filename : Path | String, encoding = nil, invalid = nil) : String

Returns the content of filename as a string.

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

View source

.read_lines(filename : Path | String, encoding = nil, invalid = nil, chomp = true) : Array(String)

Returns all lines in filename as an array of strings.

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

View source

.readable?(path : Path | String) : Bool

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

View source

.readlink(path : Path | String) : String

Returns value of a symbolic link .

View source

.real_path(path : Path | String) : String

Resolves the real path of path by following symbolic links.

View source

.rename(old_filename : Path | String, new_filename : Path | String) : Nil

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

View source

.same?(path1 : Path | String, path2 : Path | String, follow_symlinks = false) : Bool

Returns true if path1 and path2 represents the same file. The comparison take symlinks in consideration if follow_symlinks is true.

View source

.same_content?(path1 : Path | String, path2 : Path | String) : Bool

Compares two files filename1 to filename2 to determine if they are identical. Returns true if content are the same, false otherwise.

File.write("file.cr", "1")
File.write("bar.cr", "1")
File.same_content?("file.cr", "bar.cr") # => true

View source

.size(filename : Path | String) : Int64

Returns the size of the file at filename in bytes. Raises File::NotFoundError if the file at filename does not exist.

File.size("foo") # raises File::NotFoundError
File.write("foo", "foo")
File.size("foo") # => 3

View source

.symlink(old_path : Path | String, new_path : Path | String)

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

View source

.symlink?(path : Path | String) : Bool

Returns true if the path is a symbolic link.

View source

.tempfile(prefix : String?, suffix : String?, *, dir : String = Dir.tempdir, encoding = nil, invalid = nil)

Creates a temporary file.

tempfile = File.tempfile("foo", ".bar")
tempfile.delete

prefix and suffix are appended to the front and end of the file name, respectively. These values may contain directory separators.

The file will be placed in dir which defaults to the standard temporary directory Dir.tempdir.

encoding and invalid are passed to IO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

View source

.tempfile(suffix : String? = nil, *, dir : String = Dir.tempdir, encoding = nil, invalid = nil)

Creates a temporary file.

tempfile = File.tempfile(".bar")
tempfile.delete

prefix and suffix are appended to the front and end of the file name, respectively. These values may contain directory separators.

The file will be placed in dir which defaults to the standard temporary directory Dir.tempdir.

encoding and invalid are passed to IO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

View source

.tempfile(prefix : String?, suffix : String?, *, dir : String = Dir.tempdir, encoding = nil, invalid = nil

Creates a temporary file and yields it to the given block. It is closed and returned at the end of this method call.

tempfile = File.tempfile("foo", ".bar") do |file|
  file.print("bar")
end
File.read(tempfile.path) # => "bar"
tempfile.delete

prefix and suffix are appended to the front and end of the file name, respectively. These values may contain directory separators.

The file will be placed in dir which defaults to the standard temporary directory Dir.tempdir.

encoding and invalid are passed to IO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

View source

.tempfile(suffix : String? = nil, *, dir : String = Dir.tempdir, encoding = nil, invalid = nil

Creates a temporary file and yields it to the given block. It is closed and returned at the end of this method call.

tempfile = File.tempfile(".bar") do |file|
  file.print("bar")
end
File.read(tempfile.path) # => "bar"
tempfile.delete

prefix and suffix are appended to the front and end of the file name, respectively. These values may contain directory separators.

The file will be placed in dir which defaults to the standard temporary directory Dir.tempdir.

encoding and invalid are passed to IO#set_encoding.

It is the caller's responsibility to remove the file when no longer needed.

View source

.tempname(prefix : String?, suffix : String?, *, dir : String = Dir.tempdir)

Returns a fully-qualified path to a temporary file. The file is not actually created on the file system.

File.tempname("foo", ".sock") # => "/tmp/foo20171206-1234-449386.sock"

prefix and suffix are appended to the front and end of the file name, respectively. These values may contain directory separators.

The path will be placed in dir which defaults to the standard temporary directory Dir.tempdir.

View source

.tempname(suffix : String? = nil, *, dir : String = Dir.tempdir)

Returns a fully-qualified path to a temporary file. The optional suffix is appended to the file name.

File.tempname          # => "/tmp/20171206-1234-449386"
File.tempname(".sock") # => "/tmp/20171206-1234-449386.sock"

View source

.touch(filename : Path | String, time : Time = Time.utc)

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.

View source

.utime(atime : Time, mtime : Time, filename : Path | String) : Nil

Sets the access and modification times of filename.

View source

.writable?(path : Path | String) : Bool

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

View source

.write(filename : Path | String, content, perm = DEFAULT_CREATE_PERMISSIONS, encoding = nil, invalid = nil, mode = "w")

Writes the given content to filename.

By default, an existing file will be overwritten.

filename will be created if it does not already exist.

File.write("foo", "bar")
File.write("foo", "baz", mode: "a")

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).

See self.new for what mode can be.

View source

.new(filename : Path | String, mode = "r", perm = DEFAULT_CREATE_PERMISSIONS, encoding = nil, invalid = nil)

Opens the file named by filename.

mode must be one of the following file open modes:

Mode | Description
-----+------------------------------------------------------
r    | Read-only, starts at the beginning of the file.
r+   | Read-write, starts at the beginning of the file.
w    | Write-only, truncates existing file to zero length or
     | creates a new file if the file doesn't exist.
w+   | Read-write, truncates existing file to zero length or
     | creates a new file if the file doesn't exist.
a    | Write-only, starts at the end of the file,
     | creates a new file if the file doesn't exist.
a+   | Read-write, starts at the end of the file,
     | creates a new file if the file doesn't exist.
rb   | Same as 'r' but in binary file mode.
wb   | Same as 'w' but in binary file mode.
ab   | Same as 'a' but in binary file mode.

In binary file mode, line endings are not converted to CRLF on Windows.

View source

.open(filename : Path | String, mode = "r", perm = DEFAULT_CREATE_PERMISSIONS, encoding = nil, invalid = nil) : self

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

See self.new for what mode can be.

View source

Methods

#delete

Deletes this file.

View source

#inspect(io : IO) : Nil

Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

View source

#path : String

View source

#read_at(offset, bytesize, & : IO -> )

Yields an IO to read a section inside this file. Multiple sections can be read concurrently.

View source

#size

Returns the size in bytes of the currently opened file.

View source

#truncate(size = 0) : Nil

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

View source