rush2 0.7.0

data/lib/rush/remote.rb

@@ -0,0 +1,33 @@
+require 'net/ssh'
+
+module Rush
+  # wrapper of command
+  #   sshfs '-o idmap=user <user_name>@<server_address>:<path> <local_path>'
+  #
+  class Connection::Remote
+    attr_reader :local_path, :full_remote_path, :remote_path, :remote_server, :remote_user
+
+    def initialize(full_remote_path, local_path)
+      local_path = local_path.full_path if local_path.respond_to?(:full_path)
+      @full_remote_path = full_remote_path
+      @local_path = Rush::Dir.new(local_path)
+      @local_path.create unless @local_path.exists?
+      @remote_user, server_and_path = *full_remote_path.split('@', 2)
+      @remote_server, @remote_address = *server_and_path.split(':', 2)
+    end
+
+    def connect
+      system "sshfs -o idmap=user #{full_remote_path} #{local_path}"
+    end
+    alias_method :mount, :connect
+
+    def disconnect
+      system "fusermount -u #{local_path.full_path}"
+    end
+    alias_method :umount, :disconnect
+
+    def method_missing(meth, *args, &block)
+      @local_path.send(meth, *args, &block)
+    end
+  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,111 @@
+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
+      @history = Coolline::History.new config.history_file.full_path
+      @readline = Coolline.new do |c|
+        c.transform_proc  = proc { syntax_highlight c.line }
+        c.completion_proc = proc { complete c.completed_word }
+      end
+
+      @box = Rush::Box.new
+      @pure_binding = @box.instance_eval 'binding'
+      $last_res = nil
+
+      eval config.load_env, @pure_binding
+      commands = config.load_commands
+      Rush::Dir.class_eval commands
+      Rush::File.class_eval commands
+      Array.class_eval     commands
+
+      # Multiline commands should be stored somewhere
+      @multiline_cmd = ''
+    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}"
+      e.backtrace.each { |t| puts "\t#{::File.expand_path(t)}" }
+      @multiline_cmd = ''
+    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
+
+    # 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,110 @@
+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 }
+    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
+      ENV['PATH'].split(':')
+        .map { |x| Rush::Dir.new(x).entries.map(&:name) }
+        .flatten
+    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,16 @@
+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
+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
+		@access.parts_from(:user).should == %w(user)
+	end
+
+	it "gets parts from a two-part symbol like :read_write" do
+		@access.parts_from(:read_write).should == %w(read write)
+	end
+
+	it "allows use of 'and' in multipart symbols, like :user_and_group" do
+		@access.parts_from(:user_and_group).should == %w(user group)
+	end
+
+	it "extract_list verifies that all the parts among the valid choices" do
+		@access.should_receive(:parts_from).with(:red_green).and_return(%w(red green))
+		@access.extract_list('type', :red_green, %w(red blue green)).should == %w(red green)
+	end
+
+	it "extract_list raises a BadAccessSpecifier when there is part not in the list of choices" do
+		lambda do
+			@access.extract_list('role', :user_bork, %w(user group))
+		end.should 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))
+		@access.user_can_read.should == true
+	end
+
+	it "sets two values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+	end
+
+	it "sets four values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read write), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+		@access.user_can_write.should == true
+		@access.group_can_write.should == true
+	end
+
+	it "parse options hash" do
+		@access.parse(:user_can => :read)
+		@access.user_can_read.should == true
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.octal_permissions.should == 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
+		@access.octal_permissions.should == 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)
+			`ls -l #{file}`.should match(/^-r--------/)
+		ensure
+			system "rm -rf #{file}; touch #{file}"
+		end
+	end
+
+	it "serializes itself to a hash" do
+		@access.user_can_read = true
+		@access.to_hash.should == {
+			: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')
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a serialized hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.from_hash(:user_can_read => '1').should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a parsed options hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.parse(:user_and_group_can => :read).should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "converts and octal integer into an array of integers" do
+		@access.octal_integer_array(0740).should == [ 7, 4, 0 ]
+	end
+
+	it "filters out anything above the top three digits (File.stat returns some extra data there)" do
+		@access.octal_integer_array(0100644).should == [ 6, 4, 4 ]
+	end
+
+	it "taskes permissions from an octal representation" do
+		@access.from_octal(0644)
+		@access.user_can_read.should == true
+		@access.user_can_write.should == true
+		@access.user_can_execute.should == false
+	end
+
+	it "computes a display hash by dropping false keys and converting the 1s to trues" do
+		@access.should_receive(:to_hash).and_return(:red => 1, :green => 0, :blue => 1)
+		@access.display_hash.should == { :red => true, :blue => true }
+	end
+end