rush 0.2 → 0.3

data/Rakefile

@@ -31,7 +31,7 @@ require 'rake/rdoctask'
 require 'fileutils'
 include FileUtils
 
-version = "0.2"
+version = "0.3"
 name = "rush"
 
 spec = Gem::Specification.new do |s|

data/bin/rush

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

data/bin/rushd

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../lib/rush'
-require 'server'
+require File.dirname(__FILE__) + '/../lib/rush/server'
+
 RushServer.new.run
 

data/lib/rush.rb

@@ -3,22 +3,23 @@ require 'rubygems'
 module Rush; end
 module Rush::Connection; end
 
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/rush')
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require 'exceptions'
-require 'config'
-require 'commands'
-require 'entry'
-require 'file'
-require 'dir'
-require 'search_results'
-require 'head_tail'
-require 'find_by'
-require 'string_ext'
-require 'fixnum_ext'
-require 'array_ext'
-require 'process'
-require 'local'
-require 'remote'
-require 'ssh_tunnel'
-require 'box'
+require 'rush/exceptions'
+require 'rush/config'
+require 'rush/commands'
+require 'rush/access'
+require 'rush/entry'
+require 'rush/file'
+require 'rush/dir'
+require 'rush/search_results'
+require 'rush/head_tail'
+require 'rush/find_by'
+require 'rush/string_ext'
+require 'rush/fixnum_ext'
+require 'rush/array_ext'
+require 'rush/process'
+require 'rush/local'
+require 'rush/remote'
+require 'rush/ssh_tunnel'
+require 'rush/box'

data/lib/rush/access.rb

@@ -0,0 +1,130 @@
+# 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
+end

data/lib/rush/box.rb

@@ -49,10 +49,27 @@ class Rush::Box
 		end
 	end
 
-	# Execute a command in the standard unix shell.  Until the day when it's no
-	# longer needed...
-	def bash(command)
-		connection.bash(command)
+	# Execute a command in the standard unix shell.  Options:
+	#
+	# :user => unix username to become via sudo
+	# :env => hash of environment variables
+	#
+	# Example:
+	#
+	#   box.bash '/etc/init.d/mysql restart', :user => 'root'
+	#   box.bash 'rake db:migrate', :user => 'www', :env => { :RAILS_ENV => 'production' }
+	#
+	def bash(command, options={})
+		connection.bash(command_with_environment(command, options[:env]), options[:user])
+	end
+
+	def command_with_environment(command, env)   # :nodoc:
+		return command unless env
+
+		vars = env.map do |key, value|
+			"export #{key}='#{value}'"
+		end
+		vars.push(command).join("\n")
 	end
 
 	# Returns true if the box is responding to commands.

data/lib/rush/dir.rb

@@ -118,9 +118,9 @@ class Rush::Dir < Rush::Entry
 		end
 	end
 
-	# Run a bash command starting in this directory.
-	def bash(command)
-		box.bash "cd #{full_path} && #{command}"
+	# Run a bash command starting in this directory.  Options are the same as Rush::Box#bash.
+	def bash(command, options={})
+		box.bash "cd #{full_path} && #{command}", options
 	end
 
 	# Destroy all of the contents of the directory, leaving it fresh and clean.

data/lib/rush/entry.rb

@@ -129,6 +129,38 @@ class Rush::Entry
 		name.slice(0, 1) == '.'
 	end
 
+	# 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 }
+	#
+	def access=(options)
+		connection.set_access(full_path, Rush::Access.parse(options))
+	end
+
+	# 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
+	#
+	def access
+		Rush::Access.new.from_octal(stat[:mode]).display_hash
+	end
+
 	# Destroy the entry.  If it is a dir, everything inside it will also be destroyed.
 	def destroy
 		connection.destroy(full_path)

data/lib/rush/exceptions.rb

@@ -23,4 +23,7 @@ module Rush
 
 	# You cannot move or copy entries to a path that is not a dir (should end with trailing slash).
 	class NotADir < Exception; end
+
+	# A user or permission value specified to set access was not valid.
+	class BadAccessSpecifier < Exception; end
 end

data/lib/rush/find_by.rb

@@ -12,6 +12,8 @@ module Rush::FindBy
 			find_by(m[1], args.first)
 		elsif m = meth.to_s.match(/^find_all_by_([a-z_]+)$/)
 			find_all_by(m[1], args.first)
+		else
+			super
 		end
 	end
 

data/lib/rush/local.rb

@@ -114,11 +114,16 @@ class Rush::Connection::Local
 			:ctime => s.ctime,
 			:atime => s.atime,
 			:mtime => s.mtime,
+			:mode => s.mode
 		}
 	rescue Errno::ENOENT
 		raise Rush::DoesNotExist, full_path
 	end
 
+	def set_access(full_path, access)
+		access.apply(full_path)
+	end
+
 	# Fetch the size of a dir, since a standard file stat does not include the
 	# size of the contents.
 	def size(full_path)
@@ -253,11 +258,17 @@ class Rush::Connection::Local
 		::Process.kill('KILL', pid) rescue nil
 	end
 
-	def bash(command)
+	def bash(command, user=nil)
 		require 'session'
 
 		sh = Session::Bash.new
-		out, err = sh.execute command
+
+		if user and user != ""
+			out, err = sh.execute "sudo -u #{user} bash", :stdin => command
+		else
+			out, err = sh.execute command
+		end
+
 		retval = sh.status
 		sh.close!
 
@@ -288,11 +299,12 @@ class Rush::Connection::Local
 			when 'write_archive'  then write_archive(params[:payload], params[:dir])
 			when 'index'          then index(params[:base_path], params[:glob]).join("\n") + "\n"
 			when 'stat'           then YAML.dump(stat(params[:full_path]))
+			when 'set_access'     then set_access(params[:full_path], Rush::Access.from_hash(params))
 			when 'size'           then size(params[:full_path])
 			when 'processes'      then YAML.dump(processes)
 			when 'process_alive'  then process_alive(params[:pid]) ? '1' : '0'
 			when 'kill_process'   then kill_process(params[:pid].to_i)
-			when 'bash'           then bash(params[:payload])
+			when 'bash'           then bash(params[:payload], params[:user])
 		else
 			raise UnknownAction
 		end

data/lib/rush/remote.rb

@@ -58,6 +58,10 @@ class Rush::Connection::Remote
 		YAML.load(transmit(:action => 'stat', :full_path => full_path))
 	end
 
+	def set_access(full_path, access)
+		transmit access.to_hash.merge(:action => 'set_access', :full_path => full_path)
+	end
+
 	def size(full_path)
 		transmit(:action => 'size', :full_path => full_path)
 	end
@@ -74,8 +78,8 @@ class Rush::Connection::Remote
 		transmit(:action => 'kill_process', :pid => pid)
 	end
 
-	def bash(command)
-		transmit(:action => 'bash', :payload => command)
+	def bash(command, user)
+		transmit(:action => 'bash', :payload => command, :user => user)
 	end
 
 	# Given a hash of parameters (converted by the method call on the connection

data/lib/rush/shell.rb

@@ -46,9 +46,9 @@ module Rush
 					eval("_ = $last_res", @pure_binding)
 					print_result res
 				rescue Rush::Exception => e
-					puts "Exception #{e.class} -> #{e}"
+					puts "Exception #{e.class} -> #{e.message}"
 				rescue ::Exception => e
-					puts "Exception #{e.class} -> #{e}"
+					puts "Exception #{e.class} -> #{e.message}"
 					e.backtrace.each do |t|
 						puts "   #{::File.expand_path(t)}"
 					end
@@ -119,7 +119,7 @@ module Rush
 					if full_path and box
 						dir = Rush::Dir.new(full_path, box)
 						return dir.entries.select do |e|
-							e.name.match(/^#{partial_path}/)
+							e.name.match(/^#{Regexp.escape(partial_path)}/)
 						end.map do |e|
 							(pre || '') + original_var + '[' + quote + fixed_path + e.name + (e.dir? ? "/" : "")
 						end

data/spec/access_spec.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Access do
+	before do
+		@access = Rush::Access.new
+	end
+
+	it "has roles: user, group, other" do
+		@access.class.roles == %w(user group other)
+	end
+
+	it "has permissions: read, write, execute" do
+		@access.class.permissions == %w(read write execute)
+	end
+
+	it "gets parts from a one-part symbol like :user" do
+		@access.parts_from(:user).should == %w(user)
+	end
+
+	it "gets parts from a two-part symbol like :read_write" do
+		@access.parts_from(:read_write).should == %w(read write)
+	end
+
+	it "allows use of 'and' in multipart symbols, like :user_and_group" do
+		@access.parts_from(:user_and_group).should == %w(user group)
+	end
+
+	it "extract_list verifies that all the parts among the valid choices" do
+		@access.should_receive(:parts_from).with(:red_green).and_return(%w(red green))
+		@access.extract_list('type', :red_green, %w(red blue green)).should == %w(red green)
+	end
+
+	it "extract_list raises a BadAccessSpecifier when there is part not in the list of choices" do
+		lambda do
+			@access.extract_list('role', :user_bork, %w(user group))
+		end.should raise_error(Rush::BadAccessSpecifier, "Unrecognized role: bork")
+	end
+
+	it "sets one value in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user))
+		@access.user_can_read.should == true
+	end
+
+	it "sets two values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+	end
+
+	it "sets four values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read write), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+		@access.user_can_write.should == true
+		@access.group_can_write.should == true
+	end
+
+	it "parse options hash" do
+		@access.parse(:user_can => :read)
+		@access.user_can_read.should == true
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.octal_permissions.should == 0400
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.user_can_write = true
+		@access.user_can_execute = true
+		@access.group_can_read = true
+		@access.group_can_execute = true
+		@access.octal_permissions.should == 0750
+	end
+
+	it "applies its settings to a file" do
+		file = "/tmp/rush_spec_#{Process.pid}"
+		begin
+			system "rm -rf #{file}; touch #{file}; chmod 770 #{file}"
+			@access.user_can_read = true
+			@access.apply(file)
+			`ls -l #{file}`.should match(/^-r--------/)
+		ensure
+			system "rm -rf #{file}; touch #{file}"
+		end
+	end
+
+	it "serializes itself to a hash" do
+		@access.user_can_read = true
+		@access.to_hash.should == {
+			:user_can_read => 1, :user_can_write => 0, :user_can_execute => 0,
+			:group_can_read => 0, :group_can_write => 0, :group_can_execute => 0,
+			:other_can_read => 0, :other_can_write => 0, :other_can_execute => 0,
+		}
+	end
+
+	it "unserializes from a hash" do
+		@access.from_hash(:user_can_read => '1')
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a serialized hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.from_hash(:user_can_read => '1').should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a parsed options hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.parse(:user_and_group_can => :read).should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "converts and octal integer into an array of integers" do
+		@access.octal_integer_array(0740).should == [ 7, 4, 0 ]
+	end
+
+	it "filters out anything above the top three digits (File.stat returns some extra data there)" do
+		@access.octal_integer_array(0100644).should == [ 6, 4, 4 ]
+	end
+
+	it "taskes permissions from an octal representation" do
+		@access.from_octal(0644)
+		@access.user_can_read.should == true
+		@access.user_can_write.should == true
+		@access.user_can_execute.should == false
+	end
+
+	it "computes a display hash by dropping false keys and converting the 1s to trues" do
+		@access.should_receive(:to_hash).and_return(:red => 1, :green => 0, :blue => 1)
+		@access.display_hash.should == { :red => true, :blue => true }
+	end
+end

data/spec/box_spec.rb

@@ -22,10 +22,25 @@ describe Rush::Box do
 	end
 
 	it "executes bash commands" do
-		@box.connection.should_receive(:bash).with('cmd').and_return('output')
+		@box.connection.should_receive(:bash).with('cmd', nil).and_return('output')
 		@box.bash('cmd').should == 'output'
 	end
 
+	it "executes bash commands with an optional user" do
+		@box.connection.should_receive(:bash).with('cmd', 'user')
+		@box.bash('cmd', :user => 'user')
+	end
+
+	it "builds a script of environment variables to prefix the bash command" do
+		@box.command_with_environment('cmd', { :a => 'b' }).should == "export a='b'\ncmd"
+	end
+
+	it "sets the environment variables from the provided hash" do
+		@box.connection.stub!(:bash)
+		@box.should_receive(:command_with_environment).with('cmd', { 1 => 2 })
+		@box.bash('cmd', :env => { 1 => 2 })
+	end
+
 	it "checks the connection to determine if it is alive" do
 		@box.connection.should_receive(:alive?).and_return(true)
 		@box.should be_alive

data/spec/dir_spec.rb

@@ -150,4 +150,10 @@ describe Rush::Dir do
 		system "echo test > #{@dir.full_path}/file"
 		@dir.bash("cat file").should == "test\n"
 	end
+
+	it "passes bash options (e.g., :user) through to the box bash command" do
+		@box.should_receive(:bash).with('cmd', 'options')
+		@box.bash('cmd', 'options')
+	end
+
 end

data/spec/entry_spec.rb

@@ -115,4 +115,15 @@ describe Rush::Entry do
 		copy.mimic(@entry)
 		copy.path.should == @entry.path
 	end
+
+	it "can update the read access permission" do
+		system "chmod 666 #{@filename}"
+		@entry.access = { :user_can => :read }
+		`ls -l #{@filename}`.should match(/^-r--------/)
+	end
+
+	it "reads the file permissions in the access hash" do
+		system "chmod 640 #{@filename}"
+		@entry.access.should == { :user_can_read => true, :user_can_write => true, :group_can_read => true }
+	end
 end

data/spec/find_by_spec.rb

@@ -7,8 +7,7 @@ describe Rush::FindBy do
 
 			def initialize(bar)
 				@bar = bar
-			end
-		end
+			end end
 
 		@one = Foo.new('one')
 		@two = Foo.new('two')
@@ -52,4 +51,8 @@ describe Rush::FindBy do
 	it "find_by_ with field not recognized by objects raises no errors" do
 		@list.find_by_nothing('x')
 	end
+
+	it "raises NoMethodError for things other than find_by" do
+		lambda { @list.does_not_exist }.should raise_error(NoMethodError)
+	end
 end

data/spec/local_spec.rb

@@ -67,6 +67,14 @@ describe Rush::Connection::Local do
 		@con.receive(:action => 'stat', :full_path => 'full_path').should == YAML.dump(1 => 2)
 	end
 
+	it "receive -> set_access(full_path, user, group, permissions)" do
+		access = mock("access")
+		Rush::Access.should_receive(:from_hash).with(:action => 'set_access', :full_path => 'full_path', :user => 'joe').and_return(access)
+
+		@con.should_receive(:set_access).with('full_path', access)
+		@con.receive(:action => 'set_access', :full_path => 'full_path', :user => 'joe')
+	end
+
 	it "receive -> size(full_path)" do
 		@con.should_receive(:size).with('full_path').and_return("1024")
 		@con.receive(:action => 'size', :full_path => 'full_path').should == "1024"
@@ -88,8 +96,8 @@ describe Rush::Connection::Local do
 	end
 
 	it "receive -> bash" do
-		@con.should_receive(:bash).with('cmd').and_return('output')
-		@con.receive(:action => 'bash', :payload => 'cmd').should == 'output'
+		@con.should_receive(:bash).with('cmd', 'user').and_return('output')
+		@con.receive(:action => 'bash', :payload => 'cmd', :user => 'user').should == 'output'
 	end
 
 	it "receive -> unknown action exception" do
@@ -132,7 +140,7 @@ describe Rush::Connection::Local do
 		system "cd #{@sandbox_dir}; touch .killme"
 		@con.purge(@sandbox_dir)
 		File.exists?(@sandbox_dir).should be_true
-		`cd #{@sandbox_dir}; ls -lA | wc -l`.to_i.should == 0
+		`cd #{@sandbox_dir}; ls -lA | grep -v total | wc -l`.to_i.should == 0
 	end
 
 	it "create_dir creates a directory" do
@@ -196,11 +204,21 @@ describe Rush::Connection::Local do
 		@con.stat(@sandbox_dir).should have_key(:size)
 	end
 
+	it "stat fetches the octal permissions" do
+		@con.stat(@sandbox_dir)[:mode].should be_kind_of(Fixnum)
+	end
+
 	it "stat raises DoesNotExist if the entry does not exist" do
 		fname = "#{@sandbox_dir}/does_not_exist"
 		lambda { @con.stat(fname) }.should raise_error(Rush::DoesNotExist, fname)
 	end
 
+	it "set_access invokes the access object" do
+		access = mock("access")
+		access.should_receive(:apply).with('/some/path')
+		@con.set_access('/some/path', access)
+	end
+
 	if !RUBY_PLATFORM.match(/darwin/)   # doesn't work on OS X 'cause du switches are different
 		it "size gives size of a directory and all its contents recursively" do
 			system "mkdir -p #{@sandbox_dir}/a/b/; echo 1234 > #{@sandbox_dir}/a/b/c"
@@ -253,6 +271,10 @@ EOPS
 		lambda { @con.bash("no_such_bin") }.should raise_error(Rush::BashFailed, /command not found/)
 	end
 
+	it "executes a bash command as another user using sudo" do
+		@con.bash("echo test2", ENV['user']).should == "test2\n"
+	end
+
 	it "ensure_tunnel to match with remote connection" do
 		@con.ensure_tunnel
 	end

data/spec/remote_spec.rb

@@ -67,6 +67,11 @@ describe Rush::Connection::Local do
 		@con.stat('full_path').should == { 1 => 2 }
 	end
 
+	it "transmits set_access" do
+		@con.should_receive(:transmit).with(:action => 'set_access', :full_path => 'full_path', :user => 'joe', :user_read => 1)
+		@con.set_access('full_path', :user => 'joe', :user_read => 1)
+	end
+
 	it "transmits size" do
 		@con.should_receive(:transmit).with(:action => 'size', :full_path => 'full_path').and_return("")
 		@con.size('full_path')
@@ -88,8 +93,8 @@ describe Rush::Connection::Local do
 	end
 
 	it "transmits bash" do
-		@con.should_receive(:transmit).with(:action => 'bash', :payload => 'cmd').and_return('output')
-		@con.bash('cmd').should == 'output'
+		@con.should_receive(:transmit).with(:action => 'bash', :payload => 'cmd', :user => 'user').and_return('output')
+		@con.bash('cmd', 'user').should == 'output'
 	end
 
 	it "an http result code of 401 raises NotAuthorized" do

data/spec/shell_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/base'
-require 'shell'
+require 'rush/shell'
 
 describe Rush::Shell do
 	before do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rush
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.3"
 platform: ruby
 authors: 
 - Adam Wiggins
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-12 00:00:00 -07:00
+date: 2008-03-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,6 +53,7 @@ files:
 - bin/rush
 - bin/rushd
 - lib/rush
+- lib/rush/access.rb
 - lib/rush/array_ext.rb
 - lib/rush/box.rb
 - lib/rush/commands.rb
@@ -73,6 +74,7 @@ files:
 - lib/rush/ssh_tunnel.rb
 - lib/rush/string_ext.rb
 - lib/rush.rb
+- spec/access_spec.rb
 - spec/array_ext_spec.rb
 - spec/base.rb
 - spec/box_spec.rb