Class: Rush::Entry

Inherits:
Object
  • Object
show all
Defined in:
lib/rush/entry.rb

Overview

Rush::Entry is the base class for Rush::File and Rush::Dir. One or more of these is instantiated whenever you use square brackets to access the filesystem on a box, as well as any other operation that returns an entry or list of entries.

Direct Known Subclasses

Dir, File

Defined Under Namespace

Classes: NameAlreadyExists, NameCannotContainSlash

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(full_path, box = nil) ⇒ Entry

Initialize with full path to the file or dir, and the box it resides on.



9
10
11
12
13
14
 
# File 'lib/rush/entry.rb', line 9

def initialize(full_path, box=nil)
  full_path = ::File.expand_path(full_path, '/')
  @path = ::File.dirname(full_path)
  @name = ::File.basename(full_path)
  @box = box || Rush::Box.new('localhost')
end

Instance Attribute Details

#box ⇒ Object (readonly)

Returns the value of attribute box.



6
7
8
 
# File 'lib/rush/entry.rb', line 6

def box
  @box
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



6
7
8
 
# File 'lib/rush/entry.rb', line 6

def name
  @name
end

#path ⇒ Object (readonly)

Returns the value of attribute path.



6
7
8
 
# File 'lib/rush/entry.rb', line 6

def path
  @path
end

Class Method Details

.factory(full_path, box = nil) ⇒ Object

The factory checks to see if the full path has a trailing slash for creating a Rush::Dir rather than the default Rush::File.



18
19
20
21
22
23
24
25
26
 
# File 'lib/rush/entry.rb', line 18

def self.factory(full_path, box=nil)
  if full_path.tail(1) == '/'
    Rush::Dir.new(full_path, box)
  elsif File.directory?(full_path)
    Rush::Dir.new(full_path, box)
  else
    Rush::File.new(full_path, box)
  end
end

Instance Method Details

#==(other) ⇒ Object

:nodoc:



180
181
182
 
# File 'lib/rush/entry.rb', line 180

def ==(other)       # :nodoc:
  full_path == other.full_path and box == other.box
end

#access ⇒ Object

Returns a hash with up to nine values, combining user/group/other with read/write/execute. The key is omitted if the value is false.

Examples:

entry.access                   # -> { :user_can_read => true, :user_can_write => true, :group_can_read => true }
entry.access[:other_can_read]  # -> true or nil



171
172
173
 
# File 'lib/rush/entry.rb', line 171

def access
  Rush::Access.new.from_octal(stat[:mode]).display_hash
end

#access=(options) ⇒ Object

Set the access permissions for the entry.

Permissions are set by role and permissions combinations which can be specified individually or grouped together. :user_can => :read, :user_can => :write is the same as :user_can => :read_write.

You can also insert ‘and’ if you find it reads better, like :user_and_group_can => :read_and_write.

Any permission excluded is set to deny access. The access call does not set partial permissions which combine with the existing state of the entry, like “chmod o+r” would.

Examples:

file.access = { :user_can => :read_write, :group_other_can => :read }
dir.access = { :user => 'adam', :group => 'users', :read_write_execute => :user_group }



159
160
161
 
# File 'lib/rush/entry.rb', line 159

def access=(options)
  connection.set_access(full_path, Rush::Access.parse(options))
end

#changed_at ⇒ Object

Timestamp of most recent change to the entry (permissions, contents, etc).



66
67
68
 
# File 'lib/rush/entry.rb', line 66

def changed_at
  stat[:ctime]
end

#connection ⇒ Object 



40
41
42
 
# File 'lib/rush/entry.rb', line 40

def connection
  box ? box.connection : Rush::Connection::Local.new
end

#copy_to(dir, force = false) ⇒ Object

Copy the entry to another dir. Returns an object representing the new copy. If force is true, it will overwrite existed entry.

Raises:



109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/rush/entry.rb', line 109

def copy_to(dir, force = false)
  raise Rush::NotADir unless dir.class == Rush::Dir

  if box == dir.box
    connection.copy(full_path, dir.full_path, force)
  else
    archive = connection.read_archive(full_path)
    dir.box.connection.write_archive(archive, dir.full_path, force)
  end

  new_full_path = "#{dir.full_path}#{name}"
  self.class.new(new_full_path, dir.box)
end

#destroy ⇒ Object

Destroy the entry. If it is a dir, everything inside it will also be destroyed.



176
177
178
 
# File 'lib/rush/entry.rb', line 176

def destroy
  connection.destroy(full_path)
end

#duplicate(new_name, force = false) ⇒ Object

Rename an entry to another name within the same dir. The existing object will not be affected, but a new object representing the newly-created entry will be returned. If force is true, it will overwrite existed entry.

Raises:



99
100
101
102
103
104
 
# File 'lib/rush/entry.rb', line 99

def duplicate(new_name, force = false)
  raise Rush::NameCannotContainSlash if new_name.match(/\//)
  new_full_path = "#{@path}/#{new_name}"
  connection.copy(full_path, new_full_path, force)
  self.class.new(new_full_path, box)
end

#exists? ⇒ Boolean

Return true if the entry currently exists on the filesystem of the box.

Returns:

  • (Boolean) 


58
59
60
61
62
63
 
# File 'lib/rush/entry.rb', line 58

def exists?
  stat
  true
rescue Rush::DoesNotExist
  false
end

#full_path ⇒ Object 



49
50
51
 
# File 'lib/rush/entry.rb', line 49

def full_path
  "#{@path}/#{@name}"
end

#hidden? ⇒ Boolean

Unix convention considers entries starting with a . to be hidden.

Returns:

  • (Boolean) 


139
140
141
 
# File 'lib/rush/entry.rb', line 139

def hidden?
  name.slice(0, 1) == '.'
end

#inspect ⇒ Object

:nodoc:



36
37
38
 
# File 'lib/rush/entry.rb', line 36

def inspect   # :nodoc:
  "#{box}:#{full_path}"
end

#last_accessed ⇒ Object

Timestamp that entry was last accessed (read from or written to).



76
77
78
 
# File 'lib/rush/entry.rb', line 76

def last_accessed
  stat[:atime]
end

#last_modified ⇒ Object

Timestamp of last modification of the contents.



71
72
73
 
# File 'lib/rush/entry.rb', line 71

def last_modified
  stat[:mtime]
end

#mimic(from) ⇒ Object

:nodoc:



132
133
134
135
136
 
# File 'lib/rush/entry.rb', line 132

def mimic(from)      # :nodoc:
  @box = from.box
  @path = from.path
  @name = from.name
end

#move_to(dir, force = false) ⇒ Object

Move the entry to another dir. The object will be updated to show its new location. If force is true, it will overwrite existed entry.



126
127
128
129
130
 
# File 'lib/rush/entry.rb', line 126

def move_to(dir, force = false)
  moved = copy_to(dir, force)
  destroy
  mimic(moved)
end

#parent ⇒ Object

The parent dir. For example, box.parent == box



45
46
47
 
# File 'lib/rush/entry.rb', line 45

def parent
  @parent ||= Rush::Dir.new(@path)
end

#quoted_path ⇒ Object 



53
54
55
 
# File 'lib/rush/entry.rb', line 53

def quoted_path
  Rush.quote(full_path)
end

#rename(new_name, force = false) ⇒ Object

Rename an entry to another name within the same dir. The object’s name will be updated to match the change on the filesystem. If force is true, it will overwrite existed entry.



89
90
91
92
93
 
# File 'lib/rush/entry.rb', line 89

def rename(new_name, force = false)
  connection.rename(@path, @name, new_name, force)
  @name = new_name
  self
end

#to_s ⇒ Object

:nodoc:



28
29
30
31
32
33
34
 
# File 'lib/rush/entry.rb', line 28

def to_s      # :nodoc:
  if box.host == 'localhost'
    "#{full_path}"
  else
    inspect
  end
end