aleksi-rush 0.6.6

data/lib/rush/commands.rb

@@ -0,0 +1,55 @@
+# The commands module contains operations against Rush::File entries, and is
+# mixed in to Rush::Entry and Array.  This means you can run these commands against a single
+# file, a dir full of files, or an arbitrary list of files.
+#
+# Examples:
+#
+#   box['/etc/hosts'].search /localhost/       # single file
+#   box['/etc/'].search /localhost/            # entire directory
+#   box['/etc/**/*.conf'].search /localhost/   # arbitrary list
+module Rush::Commands
+	# The entries command must return an array of Rush::Entry items.  This
+	# varies by class that it is mixed in to.
+	def entries
+		raise "must define me in class mixed in to for command use"
+	end
+
+	# Search file contents for a regular expression.  A Rush::SearchResults
+	# object is returned.
+	def search(pattern)
+		results = Rush::SearchResults.new(pattern)
+		entries.each do |entry|
+			if !entry.dir? and matches = entry.search(pattern)
+				results.add(entry, matches)
+			end
+		end
+		results
+	end
+
+	# Search and replace file contents.
+	def replace_contents!(pattern, with_text)
+		entries.each do |entry|
+			entry.replace_contents!(pattern, with_text) unless entry.dir?
+		end
+	end
+
+	# Count the number of lines in the contained files.
+	def line_count
+		entries.inject(0) do |count, entry|
+			count += entry.lines.size if !entry.dir?
+			count
+		end
+	end
+
+	# Invoke vi on one or more files - only works locally.
+	def vi(*args)
+		names = entries.map { |f| f.quoted_path }.join(' ')
+		system "vim #{names} #{args.join(' ')}"
+	end
+
+	# Invoke TextMate on one or more files - only works locally.
+	def mate(*args)
+		names = entries.map { |f| f.quoted_path }.join(' ')
+		system "mate #{names} #{args.join(' ')}"
+	end
+end

data/lib/rush/config.rb

@@ -0,0 +1,154 @@
+# The config class accesses files in ~/.rush to load and save user preferences.
+class Rush::Config
+	DefaultPort = 7770
+
+	attr_reader :dir
+
+	# By default, reads from the dir ~/.rush, but an optional parameter allows
+	# using another location.
+	def initialize(location=nil)
+		@dir = Rush::Dir.new(location || "#{ENV['HOME']}/.rush")
+		@dir.create
+	end
+
+	# History is a flat file of past commands in the interactive shell,
+	# equivalent to .bash_history.
+	def history_file
+		dir['history']
+	end
+
+	def save_history(array)
+		history_file.write(array.join("\n") + "\n")
+	end
+
+	def load_history
+		history_file.contents_or_blank.split("\n")
+	end
+
+	# The environment file is executed when the interactive shell starts up.
+	# Put aliases and your own functions here; it is the equivalent of .bashrc
+	# or .profile.
+	#
+	# Example ~/.rush/env.rb:
+	#
+	#   server = Rush::Box.new('www@my.server')
+	#   myproj = home['projects/myproj/']
+	def env_file
+		dir['env.rb']
+	end
+
+	def load_env
+		env_file.contents_or_blank
+	end
+
+	# Commands are mixed in to Array and Rush::Entry, alongside the default
+	# commands from Rush::Commands.  Any methods here should reference "entries"
+	# to get the list of entries to operate on.
+	#
+	# Example ~/.rush/commands.rb:
+	#
+	#   def destroy_svn(*args)
+	#     entries.select { |e| e.name == '.svn' }.destroy
+	#   end
+	def commands_file
+		dir['commands.rb']
+	end
+
+	def load_commands
+		commands_file.contents_or_blank
+	end
+
+	# Passwords contains a list of username:password combinations used for
+	# remote access via rushd.  You can fill this in manually, or let the remote
+	# connection publish it automatically.
+	def passwords_file
+		dir['passwords']
+	end
+
+	def passwords
+		hash = {}
+		passwords_file.lines_or_empty.each do |line|
+			user, password = line.split(":", 2)
+			hash[user] = password
+		end
+		hash
+	end
+
+	# Credentials is the client-side equivalent of passwords.  It contains only
+	# one username:password combination that is transmitted to the server when
+	# connecting.  This is also autogenerated if it does not exist.
+	def credentials_file
+		dir['credentials']
+	end
+
+	def credentials
+		credentials_file.lines.first.split(":", 2)
+	end
+
+	def save_credentials(user, password)
+		credentials_file.write("#{user}:#{password}\n")
+	end
+
+	def credentials_user
+		credentials[0]
+	end
+
+	def credentials_password
+		credentials[1]
+	end
+
+	def ensure_credentials_exist
+		generate_credentials if credentials_file.contents_or_blank == ""
+	end
+
+	def generate_credentials
+		save_credentials(generate_user, generate_password)
+	end
+
+	def generate_user
+		generate_secret(4, 8)
+	end
+
+	def generate_password
+		generate_secret(8, 15)
+	end
+
+	def generate_secret(min, max)
+		chars = self.secret_characters
+		len = rand(max - min + 1) + min
+		password = ""
+		len.times do |index|
+			password += chars[rand(chars.length)]
+		end
+		password
+	end
+
+	def secret_characters
+		[ ('a'..'z'), ('1'..'9') ].inject([]) do |chars, range|
+			chars += range.to_a
+		end
+	end
+
+	# ~/.rush/tunnels contains a list of previously created ssh tunnels.  The
+	# format is host:port, where port is the local port that the tunnel is
+	# listening on.
+	def tunnels_file
+		dir['tunnels']
+	end
+
+	def tunnels
+		tunnels_file.lines_or_empty.inject({}) do |hash, line|
+			host, port = line.split(':', 2)
+			hash[host] = port.to_i
+			hash
+		end
+	end
+
+	def save_tunnels(hash)
+		string = ""
+		hash.each do |host, port|
+			string += "#{host}:#{port}\n"
+		end
+		tunnels_file.write string
+	end
+end

data/lib/rush/dir.rb

@@ -0,0 +1,160 @@
+# A dir is a subclass of Rush::Entry that contains other entries.  Also known
+# as a directory or a folder.
+#
+# Dirs can be operated on with Rush::Commands the same as an array of files.
+# They also offer a square bracket accessor which can use globbing to get a
+# list of files.
+#
+# Example:
+#
+#   dir = box['/home/adam/']
+#   dir['**/*.rb'].line_count
+#
+# In the interactive shell, dir.ls is a useful command.
+class Rush::Dir < Rush::Entry
+	def dir?
+		true
+	end
+
+	def full_path
+		"#{super}/"
+	end
+
+	# Entries contained within this dir - not recursive.
+	def contents
+		find_by_glob('*')
+	end
+
+	# Files contained in this dir only.
+	def files
+		contents.select { |entry| !entry.dir? }
+	end
+
+	# Other dirs contained in this dir only.
+	def dirs
+		contents.select { |entry| entry.dir? }
+	end
+
+	# Access subentries with square brackets, e.g. dir['subdir/file'] 
+	def [](key)
+		key = key.to_s
+		if key == '**'
+			files_flattened
+		elsif key.match(/\*/)
+			find_by_glob(key)
+		else
+			find_by_name(key)
+		end
+	end
+	# Slashes work as well, e.g. dir/'subdir/file'
+	alias_method :/, :[]
+
+	def find_by_name(name)    # :nodoc:
+		Rush::Entry.factory("#{full_path}/#{name}", box)
+	end
+
+	def find_by_glob(glob)    # :nodoc:
+		connection.index(full_path, glob).map do |fname|
+			Rush::Entry.factory("#{full_path}/#{fname}", box)
+		end
+	end
+
+	# A list of all the recursively contained entries in flat form.
+	def entries_tree
+		find_by_glob('**/*')
+	end
+
+	# Recursively contained files.
+	def files_flattened
+		entries_tree.select { |e| !e.dir? }
+	end
+
+	# Recursively contained dirs.
+	def dirs_flattened
+		entries_tree.select { |e| e.dir? }
+	end
+
+	# Given a list of flat filenames, product a list of entries under this dir.
+	# Mostly for internal use.
+	def make_entries(filenames)
+		filenames.map do |fname|
+			Rush::Entry.factory("#{full_path}/#{fname}")
+		end
+	end
+
+	# Create a blank file within this dir.
+	def create_file(name)
+		file = self[name].create
+		file.write('')
+		file
+	end
+
+	# Create an empty subdir within this dir.
+	def create_dir(name)
+		name += '/' unless name.tail(1) == '/'
+		self[name].create
+	end
+
+	# Create an instantiated but not yet filesystem-created dir.
+	def create
+		connection.create_dir(full_path)
+		self
+	end
+
+	# Get the total disk usage of the dir and all its contents.
+	def size
+		connection.size(full_path)
+	end
+
+	# Contained dirs that are not hidden.
+	def nonhidden_dirs
+		dirs.select do |dir|
+			!dir.hidden?
+		end
+	end
+
+	# Contained files that are not hidden.
+	def nonhidden_files
+		files.select do |file|
+			!file.hidden?
+		end
+	end
+
+	# Run a bash command starting in this directory.  Options are the same as Rush::Box#bash.
+	def bash(command, options={})
+		box.bash "cd #{quoted_path} && #{command}", options
+	end
+
+	# Destroy all of the contents of the directory, leaving it fresh and clean.
+	def purge
+		connection.purge full_path
+	end
+
+	# Text output of dir listing, equivalent to the regular unix shell's ls command.
+	def ls
+		out = [ "#{self}" ]
+		nonhidden_dirs.each do |dir|
+			out << "  #{dir.name}/"
+		end
+		nonhidden_files.each do |file|
+			out << "  #{file.name}"
+		end
+		out.join("\n")
+	end
+
+	# Run rake within this dir.
+	def rake(*args)
+		bash "rake #{args.join(' ')}"
+	end
+
+	# Run git within this dir.
+	def git(*args)
+		bash "git #{args.join(' ')}"
+	end
+
+	include Rush::Commands
+
+	def entries
+		contents
+	end
+end

data/lib/rush/embeddable_shell.rb

@@ -0,0 +1,26 @@
+require 'rush/shell'
+
+module Rush
+	# This is a class that can be embedded in other applications 
+	# rake tasks, utility scripts, etc
+	# 
+	# Delegates unknown method calls to a Rush::Shell instance
+	class EmbeddableShell
+		attr_accessor :shell
+		def initialize(suppress_output = true)
+			self.shell = Rush::Shell.new
+			shell.suppress_output = suppress_output
+		end
+		
+		# evalutes any unkown method call against the rush shell
+		def method_missing(sym, *args, &block)
+			shell.execute sym.to_s
+			$last_res
+		end
+		
+		# take a whole block and execute it as if it were inside a shell
+		def execute_in_shell(&block)
+			self.instance_eval(&block)
+		end
+	end
+end

data/lib/rush/entry.rb

@@ -0,0 +1,189 @@
+# 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.
+class Rush::Entry
+	attr_reader :box, :name, :path
+
+	# Initialize with full path to the file or dir, and the box it resides on.
+	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
+
+	# The factory checks to see if the full path has a trailing slash for
+	# creating a Rush::Dir rather than the default Rush::File.
+	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
+
+	def to_s      # :nodoc:
+		if box.host == 'localhost'
+			"#{full_path}"
+		else
+			inspect
+		end
+	end
+
+	def inspect   # :nodoc:
+		"#{box}:#{full_path}"
+	end
+
+	def connection
+		box ? box.connection : Rush::Connection::Local.new
+	end
+
+	# The parent dir.  For example, box['/etc/hosts'].parent == box['etc/']
+	def parent
+		@parent ||= Rush::Dir.new(@path)
+	end
+
+	def full_path
+		"#{@path}/#{@name}"
+	end
+
+	def quoted_path
+		Rush.quote(full_path)
+	end
+
+	# Return true if the entry currently exists on the filesystem of the box.
+	def exists?
+		stat
+		true
+	rescue Rush::DoesNotExist
+		false
+	end
+
+	# Timestamp of most recent change to the entry (permissions, contents, etc).
+	def changed_at
+		stat[:ctime]
+	end
+
+	# Timestamp of last modification of the contents.
+	def last_modified
+		stat[:mtime]
+	end
+
+	# Timestamp that entry was last accessed (read from or written to).
+	def last_accessed
+		stat[:atime]
+	end
+
+	# Attempts to rename, copy, or otherwise place an entry into a dir that already contains an entry by that name will fail with this exception.
+	class NameAlreadyExists < Exception; end
+
+	# Do not use rename or duplicate with a slash; use copy_to or move_to instead.
+	class NameCannotContainSlash < Exception; end
+
+	# Rename an entry to another name within the same dir.  The object's name
+	# will be updated to match the change on the filesystem.
+	# If +force+ is true, it will overwrite existed entry.
+	def rename(new_name, force = false)
+		connection.rename(@path, @name, new_name, force)
+		@name = new_name
+		self
+	end
+
+	# 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.
+	# If +force+ is true, it will overwrite existed entry.
+	def duplicate(new_name, force = false)
+		raise Rush::NameCannotContainSlash if new_name.match(/\//)
+		new_full_path = "#{@path}/#{new_name}"
+		connection.copy(full_path, new_full_path, force)
+		self.class.new(new_full_path, box)
+	end
+
+	# Copy the entry to another dir.  Returns an object representing the new
+	# copy.
+	# If +force+ is true, it will overwrite existed entry.
+	def copy_to(dir, force = false)
+		raise Rush::NotADir unless dir.class == Rush::Dir
+
+		if box == dir.box
+			connection.copy(full_path, dir.full_path, force)
+		else
+			archive = connection.read_archive(full_path)
+			dir.box.connection.write_archive(archive, dir.full_path, force)
+		end
+
+		new_full_path = "#{dir.full_path}#{name}"
+		self.class.new(new_full_path, dir.box)
+	end
+
+	# Move the entry to another dir.  The object will be updated to show its new
+	# location.
+	# If +force+ is true, it will overwrite existed entry.
+	def move_to(dir, force = false)
+		moved = copy_to(dir, force)
+		destroy
+		mimic(moved)
+	end
+
+	def mimic(from)      # :nodoc:
+		@box = from.box
+		@path = from.path
+		@name = from.name
+	end
+
+	# Unix convention considers entries starting with a . to be hidden.
+	def hidden?
+		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)
+	end
+
+	def ==(other)       # :nodoc:
+		full_path == other.full_path and box == other.box
+	end
+
+private
+
+	def stat
+		connection.stat(full_path)
+	end
+end