rush2 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 385d84f8643d09bdcccc441ea72f25e2ff699bb5
+  data.tar.gz: d06dc973e041477d3cecc357000ac5ce9cc8eaa7
+SHA512:
+  metadata.gz: 88083d80994df10c2c6108f675c76cb068f8d30f650dbee91561ba0fa33ad503a40b96858e8e88d28843cc83ea2df68985c2850be74018e1fdcc4af254028d0a
+  data.tar.gz: 911e93db558683391f408b1efe48eb6362e72b3e9ba187a183d9bd6ac8a11aca430dbe50a8f612c92be45aaf9966216f36779d24574de069fca8ef5970f6ab28

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem 'session'
+gem 'coolline'
+gem 'coderay'
+gem 'net-ssh'
+
+group :development do
+  gem 'pry'
+  gem 'rake'
+  gem 'jeweler'
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,86 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.6)
+    builder (3.2.2)
+    coderay (1.1.0)
+    coolline (0.5.0)
+      unicode_utils (~> 1.4)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.2.5)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.8)
+    github_api (0.12.1)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.3)
+      oauth2
+    hashie (3.3.1)
+    highline (1.6.21)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (1.0.0)
+    method_source (0.8.2)
+    mini_portile (0.6.0)
+    multi_json (1.10.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    net-ssh (2.9.1)
+    nokogiri (1.6.3.1)
+      mini_portile (= 0.6.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.5.2)
+    rake (10.3.2)
+    rdoc (4.1.2)
+      json (~> 1.4)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.6)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    session (3.2.0)
+    slop (3.6.0)
+    thread_safe (0.3.4)
+    unicode_utils (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coderay
+  coolline
+  jeweler
+  net-ssh
+  pry
+  rake
+  rspec
+  session

data/README.rdoc

@@ -0,0 +1,125 @@
+= rush -- manage your unix systems with pure Ruby
+
+rush is a unix integration library and an interactive shell which uses pure Ruby syntax.  Walk directory trees; create, copy, search, and destroy files; find and kill processes - everything you'd normally do with shell commands, now in the strict and elegant world of Ruby.
+
+{<img src="https://travis-ci.org/s-mage/rush.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/s-mage/rush]
+
+
+== Install
+
+Install v.0.6.8 from rubygems.org ~ no longer maintained
+
+  sudo gem install rush
+
+
+Or for the bleeding edge:
+
+  git clone git://github.com/s-mage/rush.git
+  cd rush
+  gem build *.gemspec
+  sudo gem install *.gem
+
+
+If you want the development version, you will need the development headers for ruby (eg. ruby-dev in most package managers) and change that last command to:
+
+  git clone git://github.com/s-mage/rush.git
+  cd rush
+  bundle install     # to get the dependencies
+  rake spec          # to run the tests
+  rake rdoc          # to generate a local copy of the docs from your sourcetree (optional)
+
+  sudo rake install  # install your default gem location
+
+
+To uninstall
+
+  sudo gem uninstall rush
+
+
+== Usage
+
+Count the number of classes in your project using bash:
+
+  find myproj -name \*.rb | xargs grep '^\s*class' | wc -l
+
+In rush, this is:
+
+  myproj['**/*.rb'].search(/^\s*class/).lines.size
+
+Pesky stray mongrels?  In bash:
+
+  kill `ps aux | grep mongrel_rails | grep -v grep | cut -c 10-20`
+
+In rush:
+
+  processes.filter(:cmdline => /mongrel_rails/).kill
+
+== As a library
+
+  require 'rubygems'
+  require 'rush'
+
+  file = Rush['/tmp/myfile']
+  file.write "hello"
+  puts file.contents
+  file.destroy
+
+  puts Rush.my_process.pid
+  puts Rush.processes.size
+  puts Rush.bash("echo SHELL COMMAND | tr A-Z a-z")
+  puts Rush.launch_dir['*.rb'].search(/Rush/).entries.inspect
+
+== Invoking the shell
+
+Run the "rush" binary to enter the interactive shell.
+
+== Remote access and clustering
+
+rush can control any number of remote machines from a single location. Copy files or directories between servers as seamlessly as if it was all local.
+
+Example of remote access:
+
+  local = Rush::Box.new('localhost')
+  remote = Rush::Box.new('my.remote.server.com')
+  local_dir = local['/Users/adam/myproj/']
+  remote_dir = remote['/home/myproj/app/']
+
+  local_dir.copy_to remote_dir
+  remote_dir['**/.svn/'].each { |d| d.destroy }
+
+Clustering:
+
+  local_dir = Rush::Box.new('localhost')['/Users/adam/server_logs/'].create
+  servers = %w(www1 www2 www3).map { |n| Rush::Box.new(n) }
+  servers.each { |s| s['/var/log/nginx/access.log'].copy_to local_dir["#{s.host}_access.log"] }
+
+== Reference
+
+For more details on syntax and commands, see:
+
+* Rush
+* Rush::Entry
+* Rush::File
+* Rush::Dir
+* Rush::Commands
+* Rush::Box
+* Rush::Process
+
+== Meta
+
+What follows is the meta from the original project, which is no longer maintained.
+The mailinglist is still functional and the new website for this fork is:
+https://github.com/s-mage/rush
+
+Created by Adam Wiggins
+
+Patches contributed by Chihiro Ito, Gabriel Ware, Michael Schutte, Ricardo Chimal Jr., and Nicholas Schlueter, Pedro Belo, and Martin Kuehl
+
+Logo by James Lindenbaum
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+http://rush.heroku.com
+
+http://groups.google.com/group/ruby-shell
+

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+  s.name = "rush2"
+  s.summary = "A Ruby replacement for bash+ssh."
+  s.description = "A Ruby replacement for bash+ssh, providing both an interactive shell and a library.  Manage both local and remote unix systems from a single client."
+  s.author = "Sergey Smagin"
+  s.email = "smaginsergey1310@gmail.com"
+  s.homepage = "https://github.com/s-mage/rush"
+  s.licenses = ['MIT']
+  s.executables = [ "rush", "rushd" ]
+  s.has_rdoc = true
+
+  s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
+end
+
+Jeweler::GemcutterTasks.new
+
+######################################################
+
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = 'spec/*_spec.rb'
+end
+
+desc "Print specdocs"
+RSpec::Core::RakeTask.new(:doc) do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.rspec_opts = ["--format", "specdoc", "--dry-run"]
+end
+
+desc "Run all examples with RCov"
+RSpec::Core::RakeTask.new('rcov') do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'examples']
+end
+
+task :default => :spec
+
+######################################################
+
+require 'rdoc/task'
+
+Rake::RDocTask.new do |t|
+  t.rdoc_dir = 'rdoc'
+  t.title    = "rush, a Ruby replacement for bash+ssh"
+  t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  t.options << '--charset' << 'utf-8'
+  t.rdoc_files.include('README.rdoc')
+  t.rdoc_files.include('lib/rush.rb')
+  t.rdoc_files.include('lib/rush/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.7.0

data/bin/rush

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/rush'
+require_relative '../lib/rush/shell'
+
+shell = Rush::Shell.new
+
+if ARGV.size > 0
+	shell.execute ARGV.join(' ')
+else
+	shell.run
+end
+

data/bin/rushd

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require_relative __dir__ + '/../lib/rush'
+require_relative __dir__ + '/../lib/rush/server'
+
+RushServer.new.run
+

data/lib/rush.rb

@@ -0,0 +1,91 @@
+require 'etc' # get info from /etc
+
+# The top-level Rush module has some convenience methods for accessing the
+# local box.
+module Rush
+  # Access the root filesystem of the local box.
+  #
+  # @param key [String] relative path.
+  # @example
+  #   Rush['/etc/hosts'].contents
+  #
+  def self.[](key)
+    box[key]
+  end
+
+  # Create a dir object from the path of a provided file.
+  #
+  # @param filename [String] path that should be created.
+  # @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
+
+  # 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
+  #   Rush.processes.filter(:cmdline => /ruby/)
+  #
+  def self.processes
+    box.processes
+  end
+
+  # 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
+
+  # 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
+end
+
+module Rush::Connection; end
+
+require_relative 'rush/exceptions'
+require_relative 'rush/config'
+require_relative 'rush/commands'
+require_relative 'rush/access'
+require_relative 'rush/entry'
+require_relative 'rush/file'
+require_relative 'rush/dir'
+require_relative 'rush/search_results'
+require_relative 'rush/head_tail'
+require_relative 'rush/find_by'
+require_relative 'rush/string_ext'
+require_relative 'rush/fixnum_ext'
+require_relative 'rush/array_ext'
+require_relative 'rush/process'
+require_relative 'rush/process_set'
+require_relative 'rush/local'
+require_relative 'rush/remote'
+require_relative 'rush/box'
+require_relative 'rush/embeddable_shell'

data/lib/rush/access.rb

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