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

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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(meth, *args, &block) ⇒ Object 



16
17
18
19
20
21
22
 
# File 'lib/rush/entry.rb', line 16

def method_missing(meth, *args, &block)
  if executables.include? meth.to_s
    open_with meth, *args
  else
    super
  end
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.



30
31
32
33
34
35
36
37
38
 
# File 'lib/rush/entry.rb', line 30

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:



229
230
231
 
# File 'lib/rush/entry.rb', line 229

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



185
186
187
 
# File 'lib/rush/entry.rb', line 185

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 }



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

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).



78
79
80
 
# File 'lib/rush/entry.rb', line 78

def changed_at
  stat[:ctime]
end

#chown(user = nil, group = nil, options = {}) ⇒ Object

Change entry ownership

Changes owner and group on the named files (in list) to the user user and the group group. user and group may be an ID (Integer/String) or a name (String). If user or group is nil, this method does not change the attribute.

Parameters:

  • user (string/integer) (defaults to: nil) —

    The user to own the file

  • group (string/integer) (defaults to: nil) —

    The group to own the file

  • options (hash) (defaults to: {}) —

    the options to pass to FileUtils.chown (eg. ‘noop’, ‘verbose’ or ‘recursive’ )



197
198
199
200
 
# File 'lib/rush/entry.rb', line 197

def chown(user = nil, group = nil, options = {})
  connection.chown(full_path, user, group, options)
  self
end

#chown_R(user = nil, group = nil, options = {}) ⇒ Object

Shortcut to Entry::chown to pass the ‘recursive’ option by default



204
205
206
207
 
# File 'lib/rush/entry.rb', line 204

def chown_R(user = nil, group = nil, options = {})
  options[:recursive] = true
  chown(user, group, options)
end

#connection ⇒ Object 



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

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:



113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/rush/entry.rb', line 113

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.



225
226
227
 
# File 'lib/rush/entry.rb', line 225

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:



104
105
106
107
108
109
 
# File 'lib/rush/entry.rb', line 104

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

#executables ⇒ Object 



24
25
26
 
# File 'lib/rush/entry.rb', line 24

def executables
  Rush::Path.executables
end

#exists? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

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

#full_path ⇒ Object 



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

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

#hidden? ⇒ Boolean

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

Returns:

  • (Boolean) 


153
154
155
 
# File 'lib/rush/entry.rb', line 153

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

#inspect ⇒ Object

:nodoc:



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

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

#last_accessed ⇒ Object

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



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

def last_accessed
  stat[:atime]
end

#last_modified ⇒ Object

Timestamp of last modification of the contents.



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

def last_modified
  stat[:mtime]
end

#mimic(from) ⇒ Object

:nodoc:



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

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.



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

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

#owner ⇒ Object

Chown in ruby way. Ruby way is creating accessors.



210
211
212
213
 
# File 'lib/rush/entry.rb', line 210

def owner
  stat = ::File.stat(full_path)
  { user: Etc.getpwuid(stat.uid).name, group: Etc.getgrgid(stat.gid).name }
end

#owner=(params) ⇒ Object 



215
216
217
218
219
220
221
222
 
# File 'lib/rush/entry.rb', line 215

def owner=(params)
  case params
  when Hash then chown(params.delete(:user), params.delete(:group), params)
  when String then chown(params)
  when Numeric then chown(Etc.getpwuid(params).name)
  else raise 'Something wrong with params for chown'
  end
end

#parent ⇒ Object

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



57
58
59
 
# File 'lib/rush/entry.rb', line 57

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

#quoted_path ⇒ Object 



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

def quoted_path
  Rush.quote(full_path)
end

#rename(new_name) ⇒ Object Also known as: mv

Rename an entry to another name within the same dir. The object’s name will be updated to match the change on the filesystem.



94
95
96
97
98
 
# File 'lib/rush/entry.rb', line 94

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

#symlink(dst, options = {}) ⇒ Object

Symlink the file (see File.ln for options)



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

def symlink(dst, options = {})
  connection.ln_s(full_path, dst, options)
  self.class.new(dst, box)
end

#symlink? ⇒ Boolean

Return true if the entry is a symlink.

Returns:

  • (Boolean) 


142
143
144
 
# File 'lib/rush/entry.rb', line 142

def symlink?
  connection.symlink? full_path
end

#to_s ⇒ Object

:nodoc:



40
41
42
43
44
45
46
 
# File 'lib/rush/entry.rb', line 40

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