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
 
# 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)
	else
		Rush::File.new(full_path, box)
	end
end

Instance Method Details

#==(other) ⇒ Object

:nodoc:



169
170
171
 
# File 'lib/rush/entry.rb', line 169

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



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

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 }



148
149
150
 
# File 'lib/rush/entry.rb', line 148

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

#connection ⇒ Object 



38
39
40
 
# File 'lib/rush/entry.rb', line 38

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:



99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/rush/entry.rb', line 99

def copy_to(dir)
	raise 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

#created_at ⇒ Object

Timestamp of entry creation.



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

def created_at
	stat[:ctime]
end

#destroy ⇒ Object

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



165
166
167
 
# File 'lib/rush/entry.rb', line 165

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:



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

def duplicate(new_name)
	raise 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) 


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

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

#full_path ⇒ Object 



47
48
49
 
# File 'lib/rush/entry.rb', line 47

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

#hidden? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

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

#inspect ⇒ Object

:nodoc:



34
35
36
 
# File 'lib/rush/entry.rb', line 34

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

#last_accessed ⇒ Object

Timestamp that entry was last accessed on.



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

def last_accessed
	stat[:atime]
end

#last_modified ⇒ Object

Timestamp that entry was last modified on.



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

def last_modified
	stat[:mtime]
end

#mimic(from) ⇒ Object

:nodoc:



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

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.



115
116
117
118
119
 
# File 'lib/rush/entry.rb', line 115

def move_to(dir)
	moved = copy_to(dir)
	destroy
	mimic(moved)
end

#parent ⇒ Object

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



43
44
45
 
# File 'lib/rush/entry.rb', line 43

def parent
	@parent ||= Rush::Dir.new(@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.



82
83
84
85
 
# File 'lib/rush/entry.rb', line 82

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

#to_s ⇒ Object

:nodoc:



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

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