rush3 3.0.0

data/lib/rush/process_set.rb

@@ -0,0 +1,62 @@
+# A container for processes that behaves like an array, and adds process-specific operations
+# on the entire set, like kill.
+#
+# Example:
+#
+#   processes.filter(:cmdline => /mongrel_rails/).kill
+#
+class Rush::ProcessSet
+  attr_reader :processes
+
+  def initialize(processes)
+    @processes = processes
+  end
+
+  # Filter by any field that the process responds to.  Specify an exact value,
+  # or a regular expression.  All conditions are put together as a boolean
+  # AND, so these two statements are equivalent:
+  #
+  #   processes.filter(:uid => 501).filter(:cmdline => /ruby/)
+  #   processes.filter(:uid => 501, :cmdline => /ruby/)
+  #
+  def filter(conditions)
+    Rush::ProcessSet.new(
+      processes.select do |p|
+        conditions.all? do |key, value|
+          value.class == Regexp ?
+            value.match(p.send(key)) :
+            p.send(key) == value
+        end
+      end
+    )
+  end
+
+  # Kill all processes in the set.
+  def kill(options={})
+    processes.each { |p| p.kill(options) }
+  end
+
+  # Check status of all processes in the set, returns an array of booleans.
+  def alive?
+    processes.map { |p| p.alive? }
+  end
+
+  include Enumerable
+
+  def each
+    processes.each { |p| yield p }
+  end
+
+  def ==(other)
+    if other.class == self.class
+      other.processes == processes
+    else
+      to_a == other
+    end
+  end
+
+  # All other messages (like size or first) are passed through to the array.
+  def method_missing(meth, *args)
+    processes.send(meth, *args)
+  end
+end

data/lib/rush/search_results.rb

@@ -0,0 +1,71 @@
+# An instance of this class is returned by Rush::Commands#search.  It contains
+# both the list of entries which matched the search, as well as the raw line
+# matches.  These methods get equivalent functionality to "grep -l" and "grep -h".
+#
+# SearchResults mixes in Rush::Commands so that you can chain multiple searches
+# or do file operations on the resulting entries.
+#
+# Examples:
+#
+#   myproj['**/*.rb'].search(/class/).entries.size
+#   myproj['**/*.rb'].search(/class/).lines.size
+#   myproj['**/*.rb'].search(/class/).copy_to other_dir
+class Rush::SearchResults
+  include Rush::Commands
+  include Enumerable
+
+  attr_reader :entries, :lines, :entries_with_lines, :pattern
+
+  # Make a blank container.  Track the pattern so that we can colorize the
+  # output to show what was matched.
+  def initialize(pattern)
+    # Duplication of data, but this lets us return everything in the exact
+    # order it was received.
+    @pattern = pattern
+    @entries = []
+    @entries_with_lines = {}
+    @lines = []
+  end
+
+  # Add a Rush::Entry and the array of string matches.
+  def add(entry, lines)
+    # this assumes that entry is unique
+    @entries << entry
+    @entries_with_lines[entry] = lines
+    @lines += lines
+    self
+  end
+  alias_method :<<, :add
+
+  def to_s
+    widest = entries.map { |k| k.full_path.length }.max
+    entries_with_lines.inject('') do |result, (entry, lines)|
+      result << entry.full_path
+      result << ' ' * (widest - entry.full_path.length + 2)
+      result << "=> "
+      result << colorize(lines.first.strip.head(30))
+      lines.each { |line| result << "\t" << line << "\n" }
+      result << "\n"
+    end
+  end
+
+  def each(&block)
+    @entries.each(&block)
+  end
+
+  def colorize(line)
+    lowlight + line.gsub(/(#{pattern.source})/, "#{hilight}\\1#{lowlight}") + normal
+  end
+
+  def hilight
+    "\e[34;1m"
+  end
+
+  def lowlight
+    "\e[37;2m"
+  end
+
+  def normal
+    "\e[0m"
+  end
+end

data/lib/rush/shell.rb

@@ -0,0 +1,118 @@
+require_relative 'shell/completion'
+require 'coolline'
+require 'coderay'
+require 'pp'
+
+module Rush
+  # Rush::Shell is used to create an interactive shell.
+  # It is invoked by the rush binary.
+  #
+  class Shell
+    include Rush::Completion
+
+    attr_accessor :suppress_output, :config, :history, :pure_binding
+    # 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
+      @box = Rush::Box.new
+      @pure_binding = @box.instance_eval 'binding'
+      $last_res = nil
+      load_custom_commands
+      set_readline
+      @multiline_cmd  = '' # Multiline commands should be stored somewhere
+      $last_backtrace = '' # Backtrace should too.
+    end
+
+    def set_readline
+      @history = Coolline::History.new config.history_file.full_path
+      Coolline::Settings[:word_boundaries] = [' ', "\t"]
+      Coolline::Settings[:completion_word_boundaries] = [' ', "\t"]
+      @readline = Coolline.new do |c|
+        c.transform_proc  = proc { syntax_highlight c.line }
+        c.completion_proc = proc { complete c.completed_word }
+      end
+    end
+
+    def load_custom_commands
+      eval config.load_env, @pure_binding
+      commands = config.load_commands
+      [Rush::Dir, Rush::File, Array].each { |x| x.class_eval commands }
+    end
+
+    # Run the interactive shell using coolline.
+    def run
+      loop do
+        prompt = self.class.prompt || "#{`whoami`.chomp} $ "
+        cmd = @readline.readline prompt
+        finish if cmd.nil? || cmd == 'exit'
+        next   if cmd.empty?
+        @history << cmd
+        execute cmd
+      end
+    end
+
+    # Run a single command.
+    def execute(cmd)
+      res = eval(@multiline_cmd << "\n" << cmd, @pure_binding)
+      $last_res = res
+      eval('_ = $last_res', @pure_binding)
+      @multiline_cmd = ''
+      print_result res
+    rescue SyntaxError => e
+      unless e.message.include? 'unexpected end-of-input'
+        @multiline_cmd = ''
+        puts "Exception #{e.class} -> #{e.message}"
+      end
+      # Else it should be multiline command.
+    rescue Rush::Exception => e
+      puts "Exception #{e.class} -> #{e.message}"
+      @multiline_cmd = ''
+    rescue ::Exception => e
+      puts "Exception #{e.class} -> #{e.message}"
+      $last_backtrace = e.backtrace
+        .map { |t| "\t#{::File.expand_path(t)}" }
+        .join("\n")
+      @multiline_cmd = ''
+    end
+
+    # Tune the prompt with
+    #   Rush::Shell.prompt = 'hey there! > '
+    class << self
+      attr_accessor :prompt
+    end
+
+    # Save history to ~/.rush/history when the shell exists.
+    def finish
+      puts
+      exit
+    end
+
+    # Nice printing of different return types, particularly Rush::SearchResults.
+    #
+    def print_result(res)
+      return if suppress_output
+      if res.is_a? String
+        output = res
+      elsif res.is_a? Rush::SearchResults
+        output = res.to_s <<
+          "#{res.entries.size} matching files with #{res.lines.size} lines"
+      elsif res.respond_to? :each
+        output = res.pretty_inspect
+      else
+        output = "   = #{res.inspect}"
+      end
+      output.lines.count > 5 ? output.less : puts(output)
+    end
+
+    # Syntax highlighting with coderay.
+    #
+    def syntax_highlight(input)
+      CodeRay.encode input, :ruby, :term
+    end
+  end
+end

data/lib/rush/shell/completion.rb

@@ -0,0 +1,108 @@
+module Rush
+  # Paths, executables and methods copmletion module.
+  #
+  module Completion
+    # The complete method itself.
+    # @param input [String] part of line from last space/beginning of line.
+    # @returns [String] completed string.
+    #
+    # Types of completed lines:
+    #   kernel constants, global variables, executables:
+    #     CON<tab> -- constant;
+    #     met<tab> -- method/variable name;
+    #     execu<tab> -- executable file from PATH environment variable;
+    #   given module/class constants:
+    #     Object::CON<tab> -- constant of given module/class;
+    #   methods:
+    #     Object.met<tab> -- method of object;
+    #     Object.method1.meth<tab>;
+    #     variable.met<tab>;
+    #     variable.method1.method2.met<tab> -- method number N in chain;
+    #   paths:
+    #     box['pa<tab. -- relative to box path;
+    #     box['path/to/fi<tab> -- relative path with multiple lvls;
+    #     box/'pa<tab> -- another syntax to relative path;
+    #     box/'path/to/fi<tab> -- the same;
+    #
+    def complete(input)
+      TEMPLATES.values
+        .select { |x| x[:regexp].match input }
+        .map    { |x| send x[:method], input }
+        .flatten
+        .compact
+    end
+
+    TEMPLATES = {
+      constant: {
+        regexp: /[A-Z](\w|_)+/,
+        method: :complete_constant
+      },
+      object_constant: {
+        regexp: /^([A-Z](\w|_)+::)+[A-Z](\w|_)+$/,
+        method: :complete_object_constant
+      },
+      global_method: {
+        regexp: /^[a-z](\w|_)+$/,
+        method: :complete_global_method
+      },
+      method: {
+        regexp: /^(((\w|_)+(\.|::))+)((\w|_)+)$/,
+        method: :complete_method
+      },
+      path: {
+        regexp: /^(\w|_|.|:| )+[\[\/][\'\"].*$/,
+        method: :complete_path
+      }
+    }
+
+    def complete_constant(input)
+      Object.constants.map(&:to_s).select { |x| x.start_with? input }.sort
+    end
+
+    def complete_object_constant(input)
+      receiver, delimiter, const_part = *input.rpartition('::')
+      eval(receiver, pure_binding).constants
+        .map(&:to_s)
+        .select { |x| x.start_with? const_part }
+        .map    { |x| receiver + delimiter + x }
+    end
+
+    def complete_global_method(input)
+      complete_for(pure_binding, input)
+    end
+
+    def complete_method(input)
+      receiver, delimiter, method_part = *input.rpartition('.')
+      the_binding = eval(receiver, pure_binding).instance_eval('binding')
+      complete_for(the_binding, method_part)
+        .map { |x| receiver + delimiter + x }
+    end
+
+    def complete_for(the_binding, method_part)
+      lvars = eval('local_variables', the_binding)
+      gvars = eval('global_variables', the_binding)
+      ivars = eval('instance_variables', the_binding)
+      mets = eval('methods', the_binding)
+      (executables + lvars + gvars + ivars + mets)
+        .map(&:to_s)
+        .select { |e| e.start_with? method_part }
+    end
+
+    def executables
+      Rush::Path.executables
+    end
+
+    def complete_path(input)
+      delimiters = %w([' [" /' /")
+      delimiter = delimiters.find { |x| input.include? x }
+      object, _, path = *input.rpartition(delimiter)
+      path_done, _, path_part = path.rpartition('/')
+      return [] unless eval(object, pure_binding).class == Rush::Dir
+      box = eval(object + "/'" + path_done + "'", pure_binding)
+      box.entries
+        .map(&:name)
+        .select { |x| x.start_with? path_part }
+        .map { |x| object + delimiter + path_done + '/' + x }
+    end
+  end
+end

data/lib/rush/string_ext.rb

@@ -0,0 +1,33 @@
+class String
+	include Rush::HeadTail
+
+  def less
+    IO.popen('less -R', 'w') { |f| f.puts self }
+  end
+  alias_method :pager, :less
+
+  def dir?
+    ::Dir.exists? self
+  end
+
+  def locate
+    Rush::Dir.new(ENV['HOME']).locate self
+  end
+
+  def open_with(meth, *args, &block)
+    if executables.include? meth.to_s
+      system [meth.to_s, *args, self].join(' ')
+    else
+      raise 'No such executable. Maybe something wrong with PATH?'
+    end
+  end
+  alias_method :e, :open_with
+
+  def |(meth, *args, &block)
+    Open3.capture2(meth, stdin_data: self).first
+  end
+
+  def executables
+    Rush::Path.executables
+  end
+end

data/spec/access_spec.rb

@@ -0,0 +1,134 @@
+require_relative '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
+		expect(@access.parts_from(:user)).to eq(%w(user))
+	end
+
+	it "gets parts from a two-part symbol like :read_write" do
+		expect(@access.parts_from(:read_write)).to eq(%w(read write))
+	end
+
+	it "allows use of 'and' in multipart symbols, like :user_and_group" do
+		expect(@access.parts_from(:user_and_group)).to eq( %w(user group))
+	end
+
+	it "extract_list verifies that all the parts among the valid choices" do
+		expect(@access).to receive(:parts_from).with(:red_green).and_return(%w(red green))
+		expect(@access.extract_list('type', :red_green, %w(red blue green))).to eq(%w(red green))
+	end
+
+	it "extract_list raises a BadAccessSpecifier when there is part not in the list of choices" do
+		expect do
+			@access.extract_list('role', :user_bork, %w(user group))
+		end.to 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))
+		expect(@access.user_can_read).to eq(true)
+	end
+
+	it "sets two values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user group))
+		expect(@access.user_can_read).to eq(true)
+		expect(@access.group_can_read).to eq(true)
+	end
+
+	it "sets four values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read write), %w(user group))
+		expect(@access.user_can_read).to eq(true)
+		expect(@access.group_can_read).to eq(true)
+		expect(@access.user_can_write).to eq(true)
+		expect(@access.group_can_write).to eq(true)
+	end
+
+	it "parse options hash" do
+		@access.parse(:user_can => :read)
+		expect(@access.user_can_read).to eq(true)
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		expect(@access.octal_permissions).to eq(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
+		expect(@access.octal_permissions).to eq(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)
+			expect(`ls -l #{file}`).to match(/^-r--------/)
+		ensure
+			system "rm -rf #{file}; touch #{file}"
+		end
+	end
+
+	it "serializes itself to a hash" do
+		@access.user_can_read = true
+		expect(@access.to_hash).to eq({
+			: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')
+		expect(@access.user_can_read).to eq(true)
+	end
+
+	it "initializes from a serialized hash" do
+		expect(@access.class).to receive(:new).and_return(@access)
+		expect(@access.class.from_hash(:user_can_read => '1')).to eq(@access)
+		expect(@access.user_can_read).to eq(true)
+	end
+
+	it "initializes from a parsed options hash" do
+		expect(@access.class).to receive(:new).and_return(@access)
+		expect(@access.class.parse(:user_and_group_can => :read)).to eq(@access)
+		expect(@access.user_can_read).to eq(true)
+	end
+
+	it "converts and octal integer into an array of integers" do
+		expect(@access.octal_integer_array(0740)).to eq([ 7, 4, 0 ])
+	end
+
+	it "filters out anything above the top three digits (File.stat returns some extra data there)" do
+		expect(@access.octal_integer_array(0100644)).to eq([ 6, 4, 4 ])
+	end
+
+	it "taskes permissions from an octal representation" do
+		@access.from_octal(0644)
+		expect(@access.user_can_read).to eq(true)
+		expect(@access.user_can_write).to eq(true)
+		expect(@access.user_can_execute).to eq(false)
+	end
+
+	it "computes a display hash by dropping false keys and converting the 1s to trues" do
+		expect(@access).to receive(:to_hash).and_return(:red => 1, :green => 0, :blue => 1)
+		expect(@access.display_hash).to eq({ :red => true, :blue => true })
+	end
+end