rush3 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b99827c73309a2c9e4e34f76f9895a6c8c746319aa1b691e4587f1c500fa4fe7
+  data.tar.gz: a0d7944a11b824d44afd3cf11b82c84d8f51c7380c167b8644b977d177a603e3
+SHA512:
+  metadata.gz: 2d26505e95f767c97e172d0696137a920c34de97ef77301040c14d8f3470b1b2ea90a10cfd17cf98ecdaa9f732691de09aeddb129755ffa42501d6299e181ed8
+  data.tar.gz: 7c7f9bfa17995218345d5b00c8cda4c1bcb12913acaf6178f5f56b0f582bb4538df9752b17411aa7ca9b610f631b5e26ee00f7b71810a88859dd3aafa313ef79

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+ruby '~> 2.6.1'
+
+gem 'session', '~> 3.2'
+gem 'coolline', '~> 0.5.0'
+gem 'coderay', '~> 1.1', '>= 1.1.2'
+gem 'net-ssh', '~> 5.2'
+
+group :development do
+  gem 'pry', '~> 0.12.2'
+  gem 'rake', '~> 12.3', '>= 12.3.3'
+  gem 'jeweler', '~> 2.3', '>= 2.3.9'
+  gem 'rspec', '~> 3.8'
+end

data/Gemfile.lock

@@ -0,0 +1,93 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.4.0)
+    builder (3.2.3)
+    coderay (1.1.2)
+    coolline (0.5.0)
+      unicode_utils (~> 1.4)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.3)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    git (1.5.0)
+    github_api (0.16.0)
+      addressable (~> 2.4.0)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.4)
+      mime-types (>= 1.16, < 3.0)
+      oauth2 (~> 1.0)
+    hashie (3.6.0)
+    highline (2.0.2)
+    jeweler (2.3.9)
+      builder
+      bundler
+      git (>= 1.2.5)
+      github_api (~> 0.16.0)
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      psych
+      rake
+      rdoc
+      semver2
+    jwt (2.2.1)
+    method_source (0.9.2)
+    mime-types (2.99.3)
+    mini_portile2 (2.4.0)
+    multi_json (1.13.1)
+    multi_xml (0.6.0)
+    multipart-post (2.1.1)
+    net-ssh (5.2.0)
+    nokogiri (1.10.4)
+      mini_portile2 (~> 2.4.0)
+    oauth2 (1.4.1)
+      faraday (>= 0.8, < 0.16.0)
+      jwt (>= 1.0, < 3.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    psych (3.1.0)
+    rack (2.0.7)
+    rake (12.3.3)
+    rdoc (6.2.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    semver2 (3.4.2)
+    session (3.2.0)
+    thread_safe (0.3.6)
+    unicode_utils (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coderay (~> 1.1, >= 1.1.2)
+  coolline (~> 0.5.0)
+  jeweler (~> 2.3, >= 2.3.9)
+  net-ssh (~> 5.2)
+  pry (~> 0.12.2)
+  rake (~> 12.3, >= 12.3.3)
+  rspec (~> 3.8)
+  session (~> 3.2)
+
+RUBY VERSION
+   ruby 2.6.1p33
+
+BUNDLED WITH
+   1.17.3

data/README.rdoc

@@ -0,0 +1,124 @@
+= 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/protolif/rush.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/protolif/rush]
+
+
+== Install
+
+  gem install rush3
+
+
+Or for the bleeding edge:
+
+  git clone git://github.com/protolif/rush.git
+  cd rush
+  gem build *.gemspec
+  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/protolif/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)
+
+  rake install  # install your default gem location
+
+
+To uninstall
+
+  gem uninstall rush3
+
+
+== 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 was hosted by Google groups, which is no more. Link included for posterity:
+http://groups.google.com/group/ruby-shell
+
+The previous maintainer archived their repository.
+The new website for this fork is:
+https://github.com/protolif/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
+
+Previously maintained by Sergei Smagin. Now maintained by James Dunn. Ask me if something is unclear: jamesldunnjr@gmail.com
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+  s.name = "rush3"
+  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.authors = ["Adam Wiggins", "Sergei Smagin", "James Dunn"]
+  s.email = "jamesldunnjr@gmail.com"
+  s.homepage = "https://github.com/protolif/rush"
+  s.licenses = ['MIT']
+  s.executables = [ "rush", "rushd" ]
+  s.version = "3.0.0"
+  # s.has_rdoc = true
+  # Deprecated with no replacement on 2018-12-01.
+
+  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.10.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/path'
+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/integer_ext'
+require_relative 'rush/array_ext'
+require_relative 'rush/process'
+require_relative 'rush/process_set'
+require_relative 'rush/local'
+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