rush3 3.0.0

data/lib/rush/embeddable_shell.rb

@@ -0,0 +1,26 @@
+require_relative '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 and unkown method call agains 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,238 @@
+# 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
+
+  def method_missing(meth, *args, &block)
+    if executables.include? meth.to_s
+      open_with meth, *args
+    else
+      super
+    end
+  end
+
+  def executables
+    Rush::Path.executables
+  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
+
+  # Rename an entry to another name within the same dir.  The object's name
+  # will be updated to match the change on the filesystem.
+  def rename(new_name)
+    connection.rename(@path, @name, new_name)
+    @name = new_name
+    self
+  end
+  alias_method :mv, :rename
+
+  # 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.
+  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
+
+  # Copy the entry to another dir.  Returns an object representing the new
+  # copy.
+  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
+
+  # Move the entry to another dir.  The object will be updated to show its new
+  # location.
+  def move_to(dir)
+    moved = copy_to(dir)
+    destroy
+    mimic(moved)
+  end
+
+  # Symlink the file (see File.ln for options)
+  def symlink(dst, options = {})
+    connection.ln_s(full_path, dst, options)
+    self.class.new(dst, box)
+  end
+
+  # Return true if the entry is a symlink.
+  def symlink?
+    connection.symlink? full_path
+  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
+
+  # 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.
+  #
+  # @param user [string/integer] The user to own the file
+  # @param group [string/integer] The group to own the file
+  # @param options [hash] the options to pass to FileUtils.chown (eg. 'noop', 'verbose' or 'recursive' )
+  #
+  def chown(user = nil, group = nil, options = {})
+    connection.chown(full_path, user, group, options)
+    self
+  end
+
+  # Shortcut to Entry::chown to pass the 'recursive' option by default
+  #
+  def chown_R(user = nil, group = nil, options = {})
+    options[:recursive] = true
+    chown(user, group, options)
+  end
+
+  # Chown in ruby way. Ruby way is creating accessors.
+  def owner
+    stat = ::File.stat(full_path)
+    { user: Etc.getpwuid(stat.uid).name, group: Etc.getgrgid(stat.gid).name }
+  end
+
+  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
+
+  # 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

data/lib/rush/exceptions.rb

@@ -0,0 +1,32 @@
+module Rush
+  # Base class for all rush exceptions.
+  class Exception < ::RuntimeError; end
+
+  # Client was not authorized by remote server; check credentials.
+  class NotAuthorized < Exception; end
+
+  # rushd is not running on the remote box.
+  class RushdNotRunning < Exception; end
+
+  # An unrecognized status code was returned by rushd.
+  class FailedTransmit < Exception; end
+
+  # The entry (file or dir) referenced does not exist.  Message is the entry's full path.
+  class DoesNotExist < Exception; end
+
+  # The bash command had a non-zero return value.  Message is stderr.
+  class BashFailed < Exception; 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
+
+  # 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/file.rb

@@ -0,0 +1,100 @@
+# Files are a subclass of Rush::Entry.  Most of the file-specific operations
+# relate to manipulating the file's contents, like search and replace.
+class Rush::File < Rush::Entry
+  def dir?
+    false
+  end
+
+  def dirname
+    ::File.dirname full_path
+  end
+
+  # Create a blank file.
+  def create
+    write('')
+    self
+  end
+  alias_method :touch, :create
+
+  # Hardlink the file (see File.ln for options)
+  def link(dst, options = {})
+    connection.ln(full_path, dst, options)
+    self.class.new(dst, box)
+  end
+
+  # Size in bytes on disk.
+  def size
+    stat[:size]
+  end
+
+  # Raw contents of the file.  For non-text files, you probably want to avoid
+  # printing this on the screen.
+  def contents
+    connection.file_contents(full_path)
+  end
+
+  alias_method :read, :contents
+  alias_method :cat, :contents
+
+  # Write to the file, overwriting whatever was already in it.
+  #
+  # Example: file.write "hello, world\n"
+  def write(new_contents)
+    connection.write_file(full_path, new_contents)
+  end
+
+  # Append new contents to the end of the file, keeping what was in it.
+  def append(contents)
+    connection.append_to_file(full_path, contents)
+  end
+  alias_method :<<, :append
+
+  # Return an array of lines from the file, similar to stdlib's File#readlines.
+  def lines
+    contents.split("\n")
+  end
+
+  # Search the file's for a regular expression.  Returns nil if no match, or
+  # each of the matching lines in its entirety.
+  #
+  # Example: box['/etc/hosts'].search(/localhost/) # -> [ "127.0.0.1 localhost\n", "::1 localhost\n" ]
+  def search(pattern)
+    matching_lines = lines.select { |line| line.match(pattern) }
+    matching_lines.size == 0 ? nil : matching_lines
+  end
+
+  # Search-and-replace file contents.
+  #
+  # Example: box['/etc/hosts'].replace_contents!(/localhost/, 'local.host')
+  def replace_contents!(pattern, replace_with)
+    write contents.gsub(pattern, replace_with)
+  end
+  alias_method :gsub, :replace_contents!
+  # Because I like vim.
+  alias_method :s, :replace_contents!
+
+  # Return the file's contents, or if it doesn't exist, a blank string.
+  def contents_or_blank
+    contents
+  rescue Rush::DoesNotExist
+    ""
+  end
+
+  # Count the number of lines in the file.
+  def line_count
+    lines.size
+  end
+
+  # Return an array of lines, or an empty array if the file does not exist.
+  def lines_or_empty
+    lines
+  rescue Rush::DoesNotExist
+    []
+  end
+
+  include Rush::Commands
+
+  def entries
+    [ self ]
+  end
+end

data/lib/rush/find_by.rb

@@ -0,0 +1,39 @@
+# Generic find_by (returns first match) and find_all_by (returns all matches)
+# against arrays.
+#
+# Examples:
+#
+#   processes.find_by_pid(::Process.pid)
+#   processes.find_all_by_cmdline(/mongrel_rails/)
+#
+module Rush::FindBy
+  def method_missing(meth, *args)
+    if m = meth.to_s.match(/^find_by_([a-z_]+)$/)
+      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
+
+  def find_by(field, arg)
+    detect do |item|
+      item.respond_to?(field) and compare_or_match(item.send(field), arg)
+    end
+  end
+
+  def find_all_by(field, arg)
+    select do |item|
+      item.respond_to?(field) and compare_or_match(item.send(field), arg)
+    end
+  end
+
+  def compare_or_match(value, against)
+    if against.class == Regexp
+      value.match(against) ? true : false
+    else
+      value == against
+    end
+  end
+end

data/lib/rush/head_tail.rb

@@ -0,0 +1,11 @@
+# Mixin for array and string for methods I wish they had.
+module Rush::HeadTail
+	def head(n)
+		slice(0, n)
+	end
+
+	def tail(n)
+		n = [ n, length ].min
+		slice(-n, n)
+	end
+end