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:



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

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



167
168
169
 
# File 'lib/rush/entry.rb', line 167

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 }



155
156
157
 
# File 'lib/rush/entry.rb', line 155

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) ⇒ Object

Copy the entry to another dir. Returns an object representing the new copy.

Raises:



106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/rush/entry.rb', line 106

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

	if box == dir.box
		connection.copy(full_path, dir.full_path)
	else
		archive = connection.read_archive(full_path)
		dir.box.connection.write_archive(archive, dir.full_path)
	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.



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

def destroy
	connection.destroy(full_path)
end

#duplicate(new_name) ⇒ 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.

Raises:



97
98
99
100
101
102
 
# File 'lib/rush/entry.rb', line 97

def duplicate(new_name)
	raise Rush::NameCannotContainSlash if new_name.match(/\//)
	new_full_path = "#{@path}/#{new_name}"
	connection.copy(full_path, new_full_path)
	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) 


135
136
137
 
# File 'lib/rush/entry.rb', line 135

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:



128
129
130
131
132
 
# File 'lib/rush/entry.rb', line 128

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

#move_to(dir) ⇒ Object

Move the entry to another dir. The object will be updated to show its new location.



122
123
124
125
126
 
# File 'lib/rush/entry.rb', line 122

def move_to(dir)
	moved = copy_to(dir)
	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) ⇒ 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.



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

def rename(new_name)
	connection.rename(@path, @name, new_name)
	@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