class File

Defined in:

file.cr
file/flock.cr
file/stat.cr

Constant Summary

SEPARATOR = '/'

The file/directory separator character. '/' in unix, '\\' in windows.

SEPARATOR_STRING = "/"

The file/directory separator string. "/" in unix, "\\" in windows.

Class Method Summary

Instance Method Summary

Instance methods inherited from class IO::FileDescriptor

blocking blocking, blocking=(value) blocking=, close_on_exec=(arg : Bool) close_on_exec=, close_on_exec? close_on_exec?, closed? closed?, fcntl(cmd, arg = 0) fcntl, fd fd, finalize finalize, pos pos, pos=(value) pos=, read_timed_out read_timed_out, read_timed_out=(read_timed_out) read_timed_out=, read_timeout=(read_timeout : Number)
read_timeout=(read_timeout : Time::Span)
read_timeout=(read_timeout : Nil)
read_timeout=
, reopen(other : IO::FileDescriptor) reopen, seek(offset, whence = Seek::Set : Seek) seek, stat stat, tell tell, to_fd_io to_fd_io, tty? tty?, write_timed_out write_timed_out, write_timed_out=(write_timed_out) write_timed_out=, write_timeout=(write_timeout : Number)
write_timeout=(write_timeout : Time::Span)
write_timeout=(write_timeout : Nil)
write_timeout=

Class methods inherited from class IO::FileDescriptor

fcntl(fd, cmd, arg = 0) fcntl, new(fd, blocking = false, edge_triggerable = false) new

Instance methods inherited from module IO::Buffered

close close, flush flush, flush_on_newline=(flush_on_newline) flush_on_newline=, flush_on_newline? flush_on_newline?, read(slice : Slice(UInt8)) read, rewind rewind, sync=(sync) sync=, sync? sync?, unbuffered_close unbuffered_close, unbuffered_flush unbuffered_flush, unbuffered_read(slice : Slice(UInt8)) unbuffered_read, unbuffered_rewind unbuffered_rewind, unbuffered_write(slice : Slice(UInt8)) unbuffered_write, write(slice : Slice(UInt8)) write

Instance methods inherited from module IO

<<(obj) : self <<, close close, cooked(&block) cooked, cooked! cooked!, each_byte
each_byte(&block)
each_byte
, each_char(&block)
each_char
each_char
, each_line(*args, &block)
each_line(*args)
each_line
, flush flush, gets(limit : Int) : String | Nil
gets(delimiter : Char, limit : Int) : String | Nil
gets(delimiter : Char) : String | Nil
gets : String | Nil
gets(delimiter : String) : String | Nil
gets
, gets_to_end : String gets_to_end, print(*objects : _) : Nil
print(obj) : Nil
print
, printf(format_string, args : Array | Tuple) : Nil
printf(format_string, *args) : Nil
printf
, puts : Nil
puts(*objects : _) : Nil
puts(string : String) : Nil
puts(obj) : Nil
puts
, raw(&block) raw, raw! raw!, read(slice : Slice(UInt8)) read, read_byte : UInt8 | Nil read_byte, read_bytes(type, format = IO::ByteFormat::SystemEndian : IO::ByteFormat) read_bytes, read_char : Char | Nil read_char, read_fully(slice : Slice(UInt8)) read_fully, read_line(*args) : String | Nil read_line, read_nonblock(size) read_nonblock, skip(bytes_count : Int) : Nil skip, tty? : Bool tty?, write(slice : Slice(UInt8)) : Nil write, write_byte(byte : UInt8) write_byte, write_bytes(object, format = IO::ByteFormat::SystemEndian : IO::ByteFormat) write_bytes

Class methods inherited from module IO

copy(src, dst) copy, pipe(read_blocking = false, write_blocking = false, &block)
pipe(read_blocking = false, write_blocking = false)
pipe
, select(read_ios, write_ios, error_ios, timeout_sec : LibC::TimeT | Int | Float | Nil)
select(read_ios, write_ios = nil, error_ios = nil)
select

Instance methods inherited from module JSON::Builder

json_array(&block) json_array, json_object(&block) json_object

Instance methods inherited from class Reference

! !, ==(other)
==(other : self)
==
, hash hash, inspect(io : IO) : Nil inspect, nil? nil?, object_id object_id, same?(other : Nil)
same?(other : Reference)
same?
, to_s(io : IO) : Nil to_s

Instance methods inherited from class Object

! !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other) ===, =~(other) =~, class class, clone clone, crystal_type_id crystal_type_id, dup dup, hash hash, inspect
inspect(io : IO)
inspect
, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(io : IO)
to_pretty_json
to_pretty_json
, to_s
to_s(io : IO)
to_s
, to_yaml(io : IO)
to_yaml
to_yaml
, try(&block) try

Class methods inherited from class Object

==(other : Class) ==, ===(other) ===, cast(other) : self cast, from_json(string_or_io) from_json, from_yaml(string : String) from_yaml, hash hash, inspect(io) inspect, name : String name, to_s(io) to_s

Class Method Detail

def self.basename(filename) #

[View source]
def self.basename(filename, suffix) #

[View source]
def self.delete(filename) #

Delete a file. Deleting non-existent file will raise an exception.

# touch foo
File.delete("./foo")
# => nil
File.delete("./bar")
# => Error deleting file './bar': No such file or directory (Errno)

[View source]
def self.directory?(path) #

Returns true if the given path exists and is a directory

# touch foo
# mkdir bar
File.directory?("foo")    # => false
File.directory?("bar")    # => true
File.directory?("foobar") # => false

[View source]
def self.dirname(filename) #

[View source]
def self.each_line(filename, &block) #

Yields each line of the given file to the given block.

File.each_line("./foo") do |line|
  # loop
end

[View source]
def self.executable?(filename) #

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

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

[View source]
def self.exists?(filename) #

Returns true if file exists else returns false

File.exists?("foo") # => false
echo "foo" > foo
File.exists?("foo") # => true

[View source]
def self.expand_path(path, dir = nil) #

[View source]
def self.extname(filename) #

Returns a file's extension, or an empty string if the file has no extension.

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

[View source]
def self.file?(path) #

Returns true if given path exists and is a file

# touch foo
# mkdir bar
File.file?("foo")    # => true
File.file?("bar")    # => false
File.file?("foobar") # => false

[View source]
def self.join(parts : Array | Tuple) #

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]
def self.join(*parts) #

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]
def self.link(old_path, new_path) #

Creates a new link (also known as a hard link) to an existing file.


[View source]
def self.lstat(path) #

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

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

[View source]
def self.open(filename, mode = "r", perm = DEFAULT_CREATE_MODE) #

[View source]
def self.open(filename, mode = "r", perm = DEFAULT_CREATE_MODE, &block) #

[View source]
def self.read(filename) #

Returns the content of the given file as a string.

# echo "foo" >> bar
File.read("./bar")
# => foo

[View source]
def self.read_lines(filename) #

Returns all lines of the given file as an array of strings.

# echo "foo" >> foobar
# echo "bar" >> foobar
File.read_lines("./foobar")
# => ["foo\n","bar\n"]

[View source]
def self.readable?(filename) #

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

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

[View source]
def self.rename(old_filename, new_filename) #

[View source]
def self.size(filename) #

Returns the size of the given file in bytes.


[View source]
def self.stat(path) #

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

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

[View source]
def self.symlink(old_path, new_path) #

Creates a symbolic link to an existing file.


[View source]
def self.symlink?(filename) #

Returns true if the pointed file is a symlink.


[View source]
def self.writable?(filename) #

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

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

[View source]
def self.write(filename, content, perm = DEFAULT_CREATE_MODE) #

Write the given content to the given filename. An existing file will be overwritten, or a file will be created with the given filename.

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

[View source]
def self.new(filename, mode = "r", perm = DEFAULT_CREATE_MODE) #

[View source]

Instance Method Detail

def flock_exclusive(blocking = true, &block) #

[View source]
def flock_exclusive(blocking = true) #

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.


[View source]
def flock_shared(blocking = true, &block) #

[View source]
def flock_shared(blocking = true) #

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.


[View source]
def flock_unlock #

Remove an existing advisory lock held by this process.


[View source]
def path #

[View source]
def size #

[View source]
def to_s(io) #

[View source]
def truncate(size = 0) #

Truncates the file to the specified size. Requires a write file descriptor


[View source]