Resurrect rush

.gitignore

@@ -1,3 +1,4 @@
 rdoc
 pkg
 .rbenv-version
+*.swp

Rakefile

@@ -46,7 +46,7 @@ task :default => :spec
 
 ######################################################
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 Rake::RDocTask.new do |t|
 	t.rdoc_dir = 'rdoc'

bin/rush

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/rush'
-require File.dirname(__FILE__) + '/../lib/rush/shell'
+require_relative '../lib/rush'
+require_relative '../lib/rush/shell'
 
 shell = Rush::Shell.new
 

lib/rush.rb

@@ -3,62 +3,62 @@
 # The top-level Rush module has some convenience methods for accessing the
 # local box.
 module Rush
-	# Access the root filesystem of the local box.  Example:
-	#
-	#   Rush['/etc/hosts'].contents
-	#
-	def self.[](key)
-		box[key]
-	end
+  # Access the root filesystem of the local box.  Example:
+  #
+  #   Rush['/etc/hosts'].contents
+  #
+  def self.[](key)
+    box[key]
+  end
 
-	# Create a dir object from the path of a provided file.  Example:
-	#
-	#   Rush.dir(__FILE__).files
-	#
-	def self.dir(filename)
-		box[::File.expand_path(::File.dirname(filename)) + '/']
-	end
+  # Create a dir object from the path of a provided file.  Example:
+  #
+  #   Rush.dir(__FILE__).files
+  #
+  def self.dir(filename)
+    box[::File.expand_path(::File.dirname(filename)) + '/']
+  end
 
-	# Create a dir object based on the shell's current working directory at the
-	# time the program was run.  Example:
-	#
-	#   Rush.launch_dir.files
-	#
-	def self.launch_dir
-		box[::Dir.pwd + '/']
-	end
+  # Create a dir object based on the shell's current working directory at the
+  # time the program was run.  Example:
+  #
+  #   Rush.launch_dir.files
+  #
+  def self.launch_dir
+    box[::Dir.pwd + '/']
+  end
 
-	# Run a bash command in the root of the local machine.  Equivalent to
-	# Rush::Box.new.bash.
-	def self.bash(command, options={})
-		box.bash(command, options)
-	end
+  # Run a bash command in the root of the local machine.  Equivalent to
+  # Rush::Box.new.bash.
+  def self.bash(command, options={})
+    box.bash(command, options)
+  end
 
-	# Pull the process list for the local machine.  Example:
+  # Pull the process list for the local machine.  Example:
    #
    #   Rush.processes.filter(:cmdline => /ruby/)
-	#
-	def self.processes
-		box.processes
-	end
+  #
+  def self.processes
+    box.processes
+  end
 
-	# Get the process object for this program's PID.  Example:
+  # Get the process object for this program's PID.  Example:
    #
    #   puts "I'm using #{Rush.my_process.mem} blocks of memory"
-	#
-	def self.my_process
-		box.processes.filter(:pid => ::Process.pid).first
-	end
+  #
+  def self.my_process
+    box.processes.filter(:pid => ::Process.pid).first
+  end
 
-	# Create a box object for localhost.
-	def self.box
-		@@box = Rush::Box.new
-	end
+  # Create a box object for localhost.
+  def self.box
+    @@box = Rush::Box.new
+  end
 
-	# Quote a path for use in backticks, say.
-	def self.quote(path)
-		path.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
-	end
+  # Quote a path for use in backticks, say.
+  def self.quote(path)
+    path.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
+  end
 end
 
 module Rush::Connection; end

lib/rush/access.rb

@@ -1,130 +1,120 @@
 # A class to hold permissions (read, write, execute) for files and dirs.
 # See Rush::Entry#access= for information on the public-facing interface.
 class Rush::Access
-	attr_accessor :user_can_read, :user_can_write, :user_can_execute
-	attr_accessor :group_can_read, :group_can_write, :group_can_execute
-	attr_accessor :other_can_read, :other_can_write, :other_can_execute
-
-	def self.roles
-		%w(user group other)
-	end
-
-	def self.permissions
-		%w(read write execute)
-	end
-
-	def parse(options)
-		options.each do |key, value|
-			next unless m = key.to_s.match(/(.*)_can$/)
-			key = m[1].to_sym
-			roles = extract_list('role', key, self.class.roles)
-			perms = extract_list('permission', value, self.class.permissions)
-			set_matrix(perms, roles)
-		end
-		self
-	end
-
-	def self.parse(options)
-		new.parse(options)
-	end
-
-	def apply(full_path)
-		FileUtils.chmod(octal_permissions, full_path)
-	rescue Errno::ENOENT
-		raise Rush::DoesNotExist, full_path
-	end
-
-	def to_hash
-		hash = {}
-		self.class.roles.each do |role|
-			self.class.permissions.each do |perm|
-				key = "#{role}_can_#{perm}".to_sym
-				hash[key] = send(key) ? 1 : 0
-			end
-		end
-		hash
-	end
-
-	def display_hash
-		hash = {}
-		to_hash.each do |key, value|
-			hash[key] = true if value == 1
-		end
-		hash
-	end
-
-	def from_hash(hash)
-		self.class.roles.each do |role|
-			self.class.permissions.each do |perm|
-				key = "#{role}_can_#{perm}"
-				send("#{key}=".to_sym, hash[key.to_sym].to_i == 1 ? true : false)
-			end
-		end
-		self
-	end
-
-	def self.from_hash(hash)
-		new.from_hash(hash)
-	end
-
-	def octal_permissions
-		perms = [ 0, 0, 0 ]
-		perms[0] += 4 if user_can_read
-		perms[0] += 2 if user_can_write
-		perms[0] += 1 if user_can_execute
-
-		perms[1] += 4 if group_can_read
-		perms[1] += 2 if group_can_write
-		perms[1] += 1 if group_can_execute
-
-		perms[2] += 4 if other_can_read
-		perms[2] += 2 if other_can_write
-		perms[2] += 1 if other_can_execute
-
-		eval("0" + perms.join)
-	end
-
-	def from_octal(mode)
-		perms = octal_integer_array(mode)
-
-		self.user_can_read = (perms[0] & 4) > 0 ? true : false
-		self.user_can_write = (perms[0] & 2) > 0 ? true : false
-		self.user_can_execute = (perms[0] & 1) > 0 ? true : false
-
-		self.group_can_read = (perms[1] & 4) > 0 ? true : false
-		self.group_can_write = (perms[1] & 2) > 0 ? true : false
-		self.group_can_execute = (perms[1] & 1) > 0 ? true : false
-
-		self.other_can_read = (perms[2] & 4) > 0 ? true : false
-		self.other_can_write = (perms[2] & 2) > 0 ? true : false
-		self.other_can_execute = (perms[2] & 1) > 0 ? true : false
-
-		self
-	end
-
-	def octal_integer_array(mode)
-		mode %= 01000                      # filter out everything but the bottom three digits
-		mode = sprintf("%o", mode)         # convert to string
-		mode.split("").map { |p| p.to_i }  # and finally, array of integers
-	end
-
-	def set_matrix(perms, roles)
-		perms.each do |perm|
-			roles.each do |role|
-				meth = "#{role}_can_#{perm}=".to_sym
-				send(meth, true)
-			end
-		end
-	end
-
-	def extract_list(type, value, choices)
-		list = parts_from(value)
-		list.each do |value|
-			raise(Rush::BadAccessSpecifier, "Unrecognized #{type}: #{value}") unless choices.include? value
-		end
-	end
-
-	def parts_from(value)
-		value.to_s.split('_').reject { |r| r == 'and' }
-	end
+  ROLES = %w(user group other)
+  PERMISSIONS = %w(read write execute)
+  ACCESS_UNITS = ROLES.product(PERMISSIONS).
+    map { |r, p| "#{r}_can_#{p}".to_sym }
+
+  attr_accessor *ACCESS_UNITS
+
+  def self.roles
+    ROLES
+  end
+
+  def self.permissions
+    PERMISSIONS
+  end
+
+  def parse(options)
+    options.each do |key, value|
+      next unless m = key.to_s.match(/(.*)_can$/)
+      key = m[1].to_sym
+      roles = extract_list('role', key, self.class.roles)
+      perms = extract_list('permission', value, self.class.permissions)
+      set_matrix(perms, roles)
+    end
+    self
+  end
+
+  def self.parse(options)
+    new.parse(options)
+  end
+
+  def apply(full_path)
+    FileUtils.chmod(octal_permissions, full_path)
+  rescue Errno::ENOENT
+    raise Rush::DoesNotExist, full_path
+  end
+
+  def to_hash
+    ACCESS_UNITS.inject({}) do |hash, unit|
+      hash.merge(unit => send(unit) ? 1 : 0)
+    end
+  end
+
+  def display_hash
+    to_hash.select { |_, v| v == 1 }.
+      inject({}) { |r, (k, _)| r.merge k => true }
+  end
+
+  def from_hash(hash)
+    ACCESS_UNITS.each do |unit|
+      send("#{unit}=".to_sym, hash[unit].to_i == 1 ? true : false)
+    end
+    self
+  end
+
+  def self.from_hash(hash)
+    new.from_hash(hash)
+  end
+
+  def octal_permissions
+    perms = [ 0, 0, 0 ]
+    perms[0] += 4 if user_can_read
+    perms[0] += 2 if user_can_write
+    perms[0] += 1 if user_can_execute
+
+    perms[1] += 4 if group_can_read
+    perms[1] += 2 if group_can_write
+    perms[1] += 1 if group_can_execute
+
+    perms[2] += 4 if other_can_read
+    perms[2] += 2 if other_can_write
+    perms[2] += 1 if other_can_execute
+
+    eval("0" + perms.join)
+  end
+
+  def from_octal(mode)
+    perms = octal_integer_array(mode)
+
+    self.user_can_read = (perms[0] & 4) > 0 ? true : false
+    self.user_can_write = (perms[0] & 2) > 0 ? true : false
+    self.user_can_execute = (perms[0] & 1) > 0 ? true : false
+
+    self.group_can_read = (perms[1] & 4) > 0 ? true : false
+    self.group_can_write = (perms[1] & 2) > 0 ? true : false
+    self.group_can_execute = (perms[1] & 1) > 0 ? true : false
+
+    self.other_can_read = (perms[2] & 4) > 0 ? true : false
+    self.other_can_write = (perms[2] & 2) > 0 ? true : false
+    self.other_can_execute = (perms[2] & 1) > 0 ? true : false
+
+    self
+  end
+
+  def octal_integer_array(mode)
+    mode %= 01000                      # filter out everything but the bottom three digits
+    mode = sprintf("%o", mode)         # convert to string
+    mode.split("").map { |p| p.to_i }  # and finally, array of integers
+  end
+
+  def set_matrix(perms, roles)
+    ROLES.product(PERMISSIONS).
+      select { |r, p| perms.include?(p) && roles.include?(r) }.
+      map    { |r, p| "#{r}_can_#{p}=".to_sym }.
+      each   { |unit| send unit, true }
+  end
+
+  def extract_list(type, value, choices)
+    list = parts_from(value)
+    list.each do |value|
+      raise(Rush::BadAccessSpecifier, "Unrecognized #{type}: #{value}") unless choices.include? value
+    end
+  end
+
+  def parts_from(value)
+    value.to_s.split('_').reject { |r| r == 'and' }
+  end
 end