struct
   File::Info
 
  
  Overview
A File::Info contains metadata regarding a file.
It is returned by File.info, File#info and File.info?.
Included Modules
- Crystal::System::FileInfo
Defined in:
file/info.crClass Method Summary
- 
        .executable?(path : Path | String) : Bool
        
          Returns trueif path is executable by the real user id of this process else returnsfalse.
- 
        .readable?(path : Path | String) : Bool
        
          Returns trueif path is readable by the real user id of this process else returnsfalse.
- 
        .writable?(path : Path | String) : Bool
        
          Returns trueif path is writable by the real user id of this process else returnsfalse.
Instance Method Summary
- 
        #directory?
        
          Returns true if this Inforepresents a directory.
- 
        #file?
        
          Returns true if this Inforepresents a standard file.
- 
        #flags : Flags
        
          The special flags this file has set. 
- 
        #group_id : String
        
          The group ID that the file belongs to. 
- 
        #modification_time : Time
        
          The last time this file was modified. 
- 
        #owner_id : String
        
          The user ID that the file belongs to. 
- 
        #permissions : Permissions
        
          The permissions of the file. 
- 
        #same_file?(other : self) : Bool
        
          Returns true if this Infoand other are of the same file.
- 
        #size : Int64
        
          Size of the file, in bytes. 
- 
        #symlink?
        
          Returns true if this Inforepresents a symbolic link to another file.
- 
        #type : Type
        
          The type of the file. 
Instance methods inherited from module Crystal::System::FileInfo
  
  
    
      system_flags : ::File::Flags
    system_flags, 
    
  
    
      system_group_id : String
    system_group_id, 
    
  
    
      system_modification_time : ::Time
    system_modification_time, 
    
  
    
      system_owner_id : String
    system_owner_id, 
    
  
    
      system_permissions : ::File::Permissions
    system_permissions, 
    
  
    
      system_same_file?(other : self) : Bool
    system_same_file?, 
    
  
    
      system_size : Int64
    system_size, 
    
  
    
      system_type : ::File::Type
    system_type
    
  
      
  Constructor methods inherited from module Crystal::System::FileInfo
  
  
    
      new(stat : LibC::Stat)
    new
    
  
      
      
    
      
  Instance methods inherited from struct Struct
  
  
    
      ==(other) : Bool
    ==, 
    
  
    
      hash(hasher)
    hash, 
    
  
    
      inspect(io : IO) : Nil
    inspect, 
    
  
    
      pretty_print(pp) : Nil
    pretty_print, 
    
  
    
      to_s(io : IO) : Nil
    to_s
    
  
      
      
  Class methods inherited from struct Struct
  
  
    
      pre_initialize(address : Pointer) : Nil
    pre_initialize
    
  
      
    
      
  Instance methods inherited from struct Value
  
  
    
      ==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
Instance methods inherited from class Object
  
  
    
      ! : Bool
    !, 
    
  
    
      !=(other)
    !=, 
    
  
    
      !~(other)
    !~, 
    
  
    
      ==(other)
    ==, 
    
  
    
      ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
  
  
    
      from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Class Method Detail
Returns true if path is executable by the real user id of this process else returns false.
File.write("foo", "foo")
File::Info.executable?("foo") # => falseThis method returns the readable property as reported by the file system
which provides no indication of whether Process.execute would be a valid
operation because it applies to all file types, including directories
(which typically are executable to signal it's allowed to list their
contents).
Returns true if path is readable by the real user id of this process else returns false.
File.write("foo", "foo")
File::Info.readable?("foo") # => trueThis method returns the readable property as reported by the file system
which provides no indication of whether File.read would be a valid
operation because it applies to all file types, including directories.
Returns true if path is writable by the real user id of this process else returns false.
File.write("foo", "foo")
File::Info.writable?("foo") # => trueThis method returns the readable property as reported by the file system
which provides no indication of whether File.write would be a valid
operation because it applies to all file types, including directories.
Instance Method Detail
Returns true if this Info and other are of the same file.
On Unix-like systems, this compares device and inode fields, and will compare equal for hard linked files.