aleksi-rush 0.6.6

data/lib/rush/shell.rb

@@ -0,0 +1,187 @@
+require 'readline'
+
+module Rush
+	# Rush::Shell is used to create an interactive shell.  It is invoked by the rush binary.
+	class Shell
+		attr_accessor :suppress_output
+		# Set up the user's environment, including a pure binding into which
+		# env.rb and commands.rb are mixed.
+		def initialize
+			root = Rush::Dir.new('/')
+			home = Rush::Dir.new(ENV['HOME']) if ENV['HOME']
+			pwd = Rush::Dir.new(ENV['PWD']) if ENV['PWD']
+
+			@config = Rush::Config.new
+
+			@config.load_history.each do |item|
+				Readline::HISTORY.push(item)
+			end
+
+			Readline.basic_word_break_characters = ""
+			Readline.completion_append_character = nil
+			Readline.completion_proc = completion_proc
+
+			@box = Rush::Box.new
+			@pure_binding = @box.instance_eval "binding"
+			$last_res = nil
+
+			eval @config.load_env, @pure_binding
+
+			commands = @config.load_commands
+			Rush::Dir.class_eval commands
+			Array.class_eval commands
+		end
+
+		# Run a single command.
+		def execute(cmd)
+			res = eval(cmd, @pure_binding)
+			$last_res = res
+			eval("_ = $last_res", @pure_binding)
+			print_result res
+		rescue Rush::Exception => e
+			puts "Exception #{e.class} -> #{e.message}"
+		rescue ::Exception => e
+			puts "Exception #{e.class} -> #{e.message}"
+			e.backtrace.each do |t|
+				puts "   #{::File.expand_path(t)}"
+			end
+		end
+
+		# Run the interactive shell using readline.
+		def run
+			loop do
+				cmd = Readline.readline('rush> ')
+
+				finish if cmd.nil? or cmd == 'exit'
+				next if cmd == ""
+				Readline::HISTORY.push(cmd)
+
+				execute(cmd)
+			end
+		end
+
+		# Save history to ~/.rush/history when the shell exists.
+		def finish
+			@config.save_history(Readline::HISTORY.to_a)
+			puts
+			exit
+		end
+
+		# Nice printing of different return types, particularly Rush::SearchResults.
+		def print_result(res)
+			return if self.suppress_output
+			if res.kind_of? String
+				puts res
+			elsif res.kind_of? Rush::SearchResults
+				widest = res.entries.map { |k| k.full_path.length }.max
+				res.entries_with_lines.each do |entry, lines|
+					print entry.full_path
+					print ' ' * (widest - entry.full_path.length + 2)
+					print "=> "
+					print res.colorize(lines.first.strip.head(30))
+					print "..." if lines.first.strip.length > 30
+					if lines.size > 1
+						print " (plus #{lines.size - 1} more matches)"
+					end
+					print "\n"
+				end
+				puts "#{res.entries.size} matching files with #{res.lines.size} matching lines"
+			elsif res.respond_to? :each
+				counts = {}
+				res.each do |item|
+					puts item
+					counts[item.class] ||= 0
+					counts[item.class] += 1
+				end
+				if counts == {}
+					puts "=> (empty set)"
+				else
+					count_s = counts.map do |klass, count|
+						"#{count} x #{klass}"
+					end.join(', ')
+					puts "=> #{count_s}"
+				end
+			else
+				puts "=> #{res.inspect}"
+			end
+		end
+
+		def path_parts(input)		# :nodoc:
+			case input
+			when /((?:@{1,2}|\$|)\w+(?:\[[^\]]+\])*)([\[\/])(['"])([^\3]*)$/
+				$~.to_a.slice(1, 4).push($~.pre_match)
+			when /((?:@{1,2}|\$|)\w+(?:\[[^\]]+\])*)(\.)(\w*)$/
+				$~.to_a.slice(1, 3).push($~.pre_match)
+			when /((?:@{1,2}|\$|)\w+)$/
+				$~.to_a.slice(1, 1).push(nil).push($~.pre_match)
+			else
+				[ nil, nil, nil ]
+			end
+		end
+
+		def complete_method(receiver, dot, partial_name, pre)
+			path = eval("#{receiver}.full_path", @pure_binding) rescue nil
+			box = eval("#{receiver}.box", @pure_binding) rescue nil
+			if path and box
+				(box[path].methods - Object.methods).select do |e|
+					e.match(/^#{Regexp.escape(partial_name)}/)
+				end.map do |e|
+					(pre || '') + receiver + dot + e
+				end
+			end
+		end
+
+		def complete_path(possible_var, accessor, quote, partial_path, pre)		# :nodoc:
+			original_var, fixed_path = possible_var, ''
+			if /^(.+\/)([^\/]*)$/ === partial_path
+				fixed_path, partial_path = $~.captures
+				possible_var += "['#{fixed_path}']"
+			end
+			full_path = eval("#{possible_var}.full_path", @pure_binding) rescue nil
+			box = eval("#{possible_var}.box", @pure_binding) rescue nil
+			if full_path and box
+				Rush::Dir.new(full_path, box).entries.select do |e|
+					e.name.match(/^#{Regexp.escape(partial_path)}/)
+				end.map do |e|
+					(pre || '') + original_var + accessor + quote + fixed_path + e.name + (e.dir? ? "/" : "")
+				end
+			end
+		end
+
+		def complete_variable(partial_name, pre)
+			lvars = eval('local_variables', @pure_binding)
+			gvars = eval('global_variables', @pure_binding)
+			ivars = eval('instance_variables', @pure_binding)
+			(lvars + gvars + ivars).select do |e|
+				e.match(/^#{Regexp.escape(partial_name)}/)
+			end.map do |e|
+				(pre || '') + e
+			end
+		end
+
+		# Try to do tab completion on dir square brackets and slash accessors.
+		#
+		# Example:
+		#
+		# dir['subd    # presing tab here will produce dir['subdir/ if subdir exists
+		# dir/'subd    # presing tab here will produce dir/'subdir/ if subdir exists
+		#
+		# This isn't that cool yet, because it can't do multiple levels of subdirs.
+		# It does work remotely, though, which is pretty sweet.
+		def completion_proc
+			proc do |input|
+				receiver, accessor, *rest = path_parts(input)
+				if receiver
+					case accessor
+					when /^[\[\/]$/
+						complete_path(receiver, accessor, *rest)
+					when /^\.$/
+						complete_method(receiver, accessor, *rest)
+					when nil
+						complete_variable(receiver, *rest)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/rush/ssh_tunnel.rb

@@ -0,0 +1,122 @@
+# Internal class for managing an ssh tunnel, across which relatively insecure
+# HTTP commands can be sent by Rush::Connection::Remote.
+class Rush::SshTunnel
+	def initialize(real_host)
+		@real_host = real_host
+	end
+
+	def host
+		'localhost'
+	end
+
+	def port
+		@port
+	end
+
+	def ensure_tunnel(options={})
+		return if @port and tunnel_alive?
+
+		@port = config.tunnels[@real_host]
+
+		if !@port or !tunnel_alive?
+			setup_everything(options)
+		end
+	end
+
+	def setup_everything(options={})
+		display "Connecting to #{@real_host}..."
+		push_credentials
+		launch_rushd
+		establish_tunnel(options)
+	end
+
+	def push_credentials
+		display "Pushing credentials"
+		config.ensure_credentials_exist
+		ssh_append_to_credentials(config.credentials_file.contents.strip)
+	end
+
+	def ssh_append_to_credentials(string)
+		# the following horror is exactly why rush is needed
+		passwords_file = "~/.rush/passwords"
+		string = "'#{string}'"
+		ssh "M=`grep #{string} #{passwords_file} 2>/dev/null | wc -l`; if [ $M = 0 ]; then mkdir -p .rush; chmod 700 .rush; echo #{string} >> #{passwords_file}; chmod 600 #{passwords_file}; fi"
+	end
+
+	def launch_rushd
+		display "Launching rushd"
+		ssh("if [ `ps aux | grep rushd | grep -v grep | wc -l` -ge 1 ]; then exit; fi; rushd > /dev/null 2>&1 &")
+	end
+
+	def establish_tunnel(options={})
+		display "Establishing ssh tunnel"
+		@port = next_available_port
+
+		make_ssh_tunnel(options)
+
+		tunnels = config.tunnels
+		tunnels[@real_host] = @port
+		config.save_tunnels tunnels
+
+		sleep 0.5
+	end
+
+	def tunnel_options
+		{
+			:local_port => @port,
+			:remote_port => Rush::Config::DefaultPort,
+			:ssh_host => @real_host,
+		}
+	end
+
+	def tunnel_alive?
+		`#{tunnel_count_command}`.to_i > 0
+	end
+
+	def tunnel_count_command
+		"ps x | grep '#{ssh_tunnel_command_without_stall}' | grep -v grep | wc -l"
+	end
+
+	class SshFailed < Exception; end
+	class NoPortSelectedYet < Exception; end
+
+	def ssh(command)
+		raise SshFailed unless system("ssh #{@real_host} '#{command}'")
+	end
+
+	def make_ssh_tunnel(options={})
+		raise SshFailed unless system(ssh_tunnel_command(options))
+	end
+
+	def ssh_tunnel_command_without_stall
+		options = tunnel_options
+		raise NoPortSelectedYet unless options[:local_port]
+		"ssh -f -L #{options[:local_port]}:127.0.0.1:#{options[:remote_port]} #{options[:ssh_host]}"
+	end
+
+	def ssh_stall_command(options={})
+		if options[:timeout] == :infinite
+			"while [ 1 ]; do sleep 1000; done"
+		elsif options[:timeout].to_i > 10
+			"sleep #{options[:timeout].to_i}"
+		else
+			"sleep 9000"
+		end
+	end
+
+	def ssh_tunnel_command(options={})
+		ssh_tunnel_command_without_stall + ' "' + ssh_stall_command(options) + '"'
+	end
+
+	def next_available_port
+		(config.tunnels.values.max || Rush::Config::DefaultPort) + 1
+	end
+
+	def config
+		@config ||= Rush::Config.new
+	end
+
+	def display(msg)
+		puts msg
+	end
+end

data/lib/rush/string_ext.rb

@@ -0,0 +1,3 @@
+class String
+	include Rush::HeadTail
+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