rubsh 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca63773e13fa92b984e44144945aa43955b9f4468881e819581a65b8015f7b4d
+  data.tar.gz: 4090f30591db271c5f50230c93270e542d59a2f19c4b3e60e3f09fbc8160b56f
+SHA512:
+  metadata.gz: 9717cb3327ac4176352ed8dc3ac818cac44f5d0a77a5b9775d0f992902b8723af461c93a66b02acd730471c77c94d11c9d3d390824ac1c1fde41e65f58492899
+  data.tar.gz: 54fbae882195e3851d33c9eadef7d2dfbd4181f2fcef701574d38b0ccaf2a4811350a78e8f94e7fa1da7cfb29a6c7258b9aef802e4edabe38829616046ba44ba

data/README.rdoc

@@ -22,17 +22,16 @@ Run rubsh on the commandline. Type help for a quick overview of usage.
 
 == aliases
 
-ralias aliases a command.
+Aliases use shell syntax and remain available for the current session:
 
-Example:
- ralias 'ls ls -Gh'
+  alias ls "ls -Gh"
 
-Currently an alias will not be parsed to include other aliases. i.e.
-doing <tt>ralias 'ls ls -Gh'</tt> followed by <tt>ralias 'll ls -l'</tt> will not get you 'ls -lGh'
+Put the same line in <tt>~/.config/rubsh/config.rb</tt> to load it at startup.
+Alias values are parsed again as shell commands, so quoting and pipeline arguments are preserved.
 
-== .rubsh/rc.rb
+== ~/.config/rubsh/config.rb
 
-Define your own functions, aliases etc in the rc file. It's included to the environment.
+Define Ruby functions and persistent aliases in this file. Rubsh loads it when the shell starts.
 
 == Shortcuts
 
@@ -71,14 +70,34 @@ use ENV['PR1'] to set your prompt.  see 'help prompt' for options from within th
 
   Example: ENV['PR1'] = "[%u@%h]--(%t)\n\r[%w]%$ "
 
-== Commandline functions
+== Ruby command functions
 
-Commandline functions must currently be defined as one-liners. They also take an argument, which
-is what was typed to invoke the command.
+Rubsh keeps one Ruby context for the shell session. Define a function over multiple lines,
+then use it as a command or inside backtick command substitution:
 
- def test(*a); p a;end
- $ test foo #=> ["test foo"]
+  def foo
+    return "ok"
+  end
 
+  echo `foo` | tee out.txt
 
+The example prints <tt>ok</tt> and writes <tt>ok\n</tt> to <tt>out.txt</tt>. Function arguments
+are the command arguments. A returned string becomes command output; <tt>puts</tt> writes
+directly to the command's output stream.
 
+Ruby functions can also call shell commands:
 
+  def merp
+    ls
+  end
+
+== Pipelines
+
+Commands are parsed into argv arrays, so quotes and escaped spaces remain one argument.
+The pipe operator connects command stages, including Ruby functions and external programs.
+Backticks run a nested Rubsh command and substitute its captured output, with a trailing
+newline removed.
+
+Rubsh intentionally does not implement job control, background jobs, heredocs, redirects,
+or <tt>&amp;&amp;</tt>/<tt>||</tt> conditionals. Stateful commands such as <tt>cd</tt> run in the
+shell process so directory changes persist.

data/bin/rubsh

@@ -7,12 +7,14 @@ require 'optparse'
 $DEBUG = false
 
 def parse_options
-    parser = OptionParser.new()
-    parser.on("--debug", "If included run in DEBUG mode") do
-      $DEBUG = true
-    end
-    parser.banner "rubsh"
-    parser.parse(ARGV)
+  options = {}
+  parser = OptionParser.new
+  parser.on('-c COMMAND', '--command COMMAND', 'Run one command and exit') { |command| options[:command] = command }
+  parser.on('--debug', 'If included run in DEBUG mode') { $DEBUG = true }
+  parser.banner = 'rubsh'
+  parser.parse!(ARGV)
+  options
 end
 
-Rubsh.new.run
+options = parse_options
+exit(Rubsh.new.run(options[:command]) || 0)

data/lib/alias.rb

@@ -1,19 +1,29 @@
 class Alias
-  @@aliases = Hash.new
-  def self.parse(str)
-    str.scan(/^\s*([^\s]+)(.*)$/) do |name,val|
-      @@aliases[name] = val
-    end
+  def initialize
+    @values = {}
   end
-  def self.[]=(name,value)
-    @@aliases[name] = value
+
+  def []=(name, value)
+    @values[name.to_s] = value.to_s
   end
-  def self.[](name)
-    @@aliases[name]
+
+  def [](name)
+    @values[name.to_s]
   end
-  def self.show
-    @@aliases.each do |k,v|
-      puts "alias #{k} = #{v}"
-    end
+
+  def delete(name)
+    @values.delete(name.to_s)
+  end
+
+  def empty?
+    @values.empty?
+  end
+
+  def to_h
+    @values.dup
+  end
+
+  def show(output = $stdout)
+    @values.each { |name, value| output.puts "alias #{name}=#{value}" }
   end
 end

data/lib/commands.rb

@@ -1,86 +1,84 @@
 class Commands
   @@oldpwd = nil
+
+  attr_writer :shell_executor, :shell_source_executor, :completion_executor
+
   def get_binding
     binding
   end
 
-  def help(arg)
-    case arg
-    when /help.*prompt/
-      puts %|
-      %h  - hostname
-      %u  - the username of the current user
-      %w  - the current working directory, with $HOME abbreviated with a tilde
-      %W  - the basename of the current working directory, with $HOME abbreviated
-         with a tilde
-      %Cb - blue color
-      %Cc - cyan color
-      %Cg - green color
-      %CC - color reset
-      %t  - the current time in 24-hour HH:MM:SS format
-      %%  - literal %
-      %$  - if the effective UID is 0, a #, otherwise a $
-
-      Example: ENV['PR1'] = "[%u@%h]--(%t)\\n\\r[%w]%$ "
-      |
-    else
-      puts %|
-    ralias - alias command
-      example: ralias 'ls ls -Gh'
-      aliases ls to 'ls -Gh'
+  def method_missing(name, *args)
+    return super unless @shell_executor
+    @shell_executor.call(name.to_s, args)
+  end
 
-    shortcuts:
-      '...'.ls - shortcut for Dir.glob(...)
-      '...'.ls.du is available to do `du` on the files
+  def respond_to_missing?(_name, _include_private = false)
+    true
+  end
 
-    prompt:
-      use ENV['PR1'] to set your prompt.
-      see 'help prompt' for options
+  def complete(name, &block)
+    @completion_executor.call(name.to_s, &block)
+  end
 
-    ~/.rubsh/rc.rb
-      you can define your aliases, prompt and define
-      your own functions in here.
+  def __rubsh_shell__(source)
+    @shell_source_executor.call(source)
+  end
 
-    commandline functions:
-      * it gets sent it's own invocation
-      * must be a one liner
-      example: def test(*a); p a;end  #  test foo #=> ["test foo"]
+  def command?(name)
+    symbol = name.to_sym
+    singleton_methods.include?(symbol) ||
+      self.class.public_instance_methods(true).include?(symbol) ||
+      self.class.protected_instance_methods(true).include?(symbol) ||
+      self.class.private_instance_methods(true).include?(symbol)
+  end
 
-    |
+  def call(name, args, stdin: $stdin, stdout: $stdout, stderr: $stderr)
+    method = method(name.to_sym)
+    if method.parameters.any? { |_kind, key| key == :stdin }
+      method.call(args, stdin: stdin, stdout: stdout, stderr: stderr)
+    elsif method.arity == 0
+      method.call
+    else
+      method.call(*args)
     end
   end
-  def cd(dir)
-    dir.gsub! /\s*cd\s*/, ''
-    dir.gsub! /\s*$/, ''
-    dir.gsub! /("|')/, ''
-    if dir.empty?
-      @@oldpwd = Dir.pwd
-      Dir.chdir ENV['HOME']
-      return
-    end
 
+  def help(*_args)
+    puts <<~HELP
+      Rubsh runs Ruby expressions and external commands.
+      Define commands with a multiline Ruby function:
+
+        def foo
+          return "ok"
+        end
+
+      Backticks capture a command, and | connects pipeline stages.
+    HELP
+  end
+
+  def cd(args, stdin: $stdin, stdout: $stdout, stderr: $stderr)
+    dir = args.first
+    dir = ENV['HOME'] if dir.nil? || dir.empty?
     if dir == '-'
-      if @@oldpwd
-        curdir = Dir.pwd
-        Dir.chdir @@oldpwd
-        @@oldpwd = curdir
-      else
-        puts "OLDPWD not set"
+      unless @@oldpwd
+        stderr.puts 'OLDPWD not set'
+        return 1
       end
-      return
-    end
-
-    if dir =~ /^~\/?/
-      dir.gsub!('~',ENV['HOME'])
+      dir, @@oldpwd = @@oldpwd, Dir.pwd
+    else
+      dir = File.expand_path(dir, ENV['HOME']) if dir.start_with?('~/') || dir == '~'
+      @@oldpwd = Dir.pwd
     end
-    @@oldpwd = Dir.pwd
-    Dir.chdir dir
+    Dir.chdir(dir)
+    0
+  rescue SystemCallError => error
+    stderr.puts error.message
+    1
   end
-  def method_missing(m,*args)
-    if ::Rubsh::iscmd? m.to_s
-      system(m.to_s)
-      return
-    end
-    raise "rubsh: #{m}: command not found"
+
+  def history(*_args)
+    file = File.join(ENV['HOME'], '.rubsh', 'history')
+    return unless File.exist?(file)
+    File.foreach(file) { |line| puts line }
   end
 end

data/lib/completion.rb

@@ -0,0 +1,111 @@
+class CompletionNode
+  attr_reader :options, :subcommands, :arguments
+  attr_accessor :description, :wrapped_command
+
+  def initialize
+    @options = {}
+    @subcommands = {}
+    @arguments = []
+  end
+
+  def option(name, description: nil, argument: nil)
+    @options[name.to_s] = { description: description, argument: argument }
+  end
+
+  def argument(name = nil, complete: nil)
+    @arguments << { name: name, complete: complete }
+  end
+
+  def subcommand(name, description: nil, &block)
+    child = (@subcommands[name.to_s] ||= CompletionNode.new)
+    child.description = description if description
+    child.instance_eval(&block) if block
+    child
+  end
+
+  def wraps(command)
+    @wrapped_command = command.to_s
+  end
+end
+
+class CompletionRegistry
+  def initialize
+    @commands = {}
+  end
+
+  def complete(name, &block)
+    node = (@commands[name.to_s] ||= CompletionNode.new)
+    node.instance_eval(&block) if block
+    node
+  end
+
+  def erase(name)
+    @commands.delete(name.to_s)
+  end
+  def import_fish(text)
+    text.each_line do |line|
+      next unless line =~ /\Acomplete(?:\s+--no-files)?\s+(\S+)(.*)\z/
+      command, rest = Regexp.last_match(1), Regexp.last_match(2)
+      complete(command) do
+        if rest =~ /\s+-s\s+(\S+)/
+          option("-#{Regexp.last_match(1)}", description: rest[/\s+-d\s+'([^']+)'/, 1])
+        elsif rest =~ /\s+-a\s+'([^']+)'/
+          Regexp.last_match(1).split.each { |value| subcommand(value) }
+        end
+      end
+    end
+  end
+
+
+  def [](name)
+    @commands[name.to_s]
+  end
+
+  def suggestions(argv, prefix)
+    node = @commands[argv.first]
+    node = @commands[node.wrapped_command] if node && node.wrapped_command
+    return [] unless node
+    argv.drop(1).each { |word| node = node.subcommands[word] if node.subcommands.key?(word) }
+    (node.subcommands.keys + node.options.keys).grep(/^#{Regexp.escape(prefix)}/)
+  end
+
+  def show(name = nil)
+    return @commands.keys.sort unless name
+    node = @commands[name.to_s]
+    node ? ruby_definition(name.to_s, node) : []
+  end
+
+  private
+
+  def ruby_definition(name, node, indent = 0)
+    pad = '  ' * indent
+    lines = ["#{pad}complete #{name.inspect} do"]
+    node.options.each do |option, details|
+      args = [option.inspect]
+      args << "description: #{details[:description].inspect}" if details[:description]
+      args << "argument: #{details[:argument].inspect}" if details[:argument]
+      lines << "#{pad}  option #{args.join(', ')}"
+    end
+    node.arguments.each { |arg| lines << "#{pad}  argument #{arg[:name].inspect}" }
+    node.subcommands.each do |subcommand, child|
+      description = child.description ? ", description: #{child.description.inspect}" : ''
+      lines.concat(ruby_subcommand(subcommand, child, indent + 1, description))
+    end
+    lines << "#{pad}end"
+    lines.join("\n")
+  end
+
+  def ruby_subcommand(name, node, indent, description)
+    pad = '  ' * indent
+    lines = ["#{pad}subcommand #{name.inspect}#{description} do"]
+    node.options.each do |option, details|
+      args = [option.inspect]
+      args << "description: #{details[:description].inspect}" if details[:description]
+      args << "argument: #{details[:argument].inspect}" if details[:argument]
+      lines << "#{pad}  option #{args.join(', ')}"
+    end
+    node.subcommands.each { |child_name, child| lines.concat(ruby_subcommand(child_name, child, indent + 1, child.description ? ", description: #{child.description.inspect}" : '')) }
+    lines << "#{pad}end"
+    lines
+  end
+end

data/lib/rub_readline.rb

@@ -1,4 +1,4 @@
-require 'readline'
+require 'reline'
 def get_local_dirs(str)
   Dir[str+'*'].
     grep( /^#{Regexp.escape(str)}/ ). #only return dirs which start with str
@@ -20,16 +20,37 @@ def get_executables(str)
   end
   return commands
 end
-Readline.completion_proc = Proc.new do |str|
-  completions = get_local_dirs(str)
-  
-  # if it's the first thing we're typing in, assume this to be a command and not just a dir.
-  # iow, we don't do this for second arg allowing executables not to be completed when
-  # prefixed by example 'cd'.
-  if Readline.line_buffer =~ /^\s*#{Regexp.escape(str)}/
-    completions += get_executables(str)
+Reline.autocompletion = false if Reline.respond_to?(:autocompletion=)
+Reline.completion_proc = Proc.new do |str|
+
+  line = Reline.line_buffer
+  str = str.to_s
+
+  custom = []
+  registered = false
+  if defined?($rubsh_completion_registry) && defined?(ShellParser)
+    begin
+      if line =~ /\A\s*([^\s|]+)\s*\z/ && !line.end_with?(' ')
+        command = Regexp.last_match(1)
+        command = $rubsh_aliases[command].split.first if defined?($rubsh_aliases) && $rubsh_aliases[command]
+        custom = $rubsh_completion_registry.suggestions([command], '')
+        registered = !$rubsh_completion_registry[command].nil?
+
+      else
+        before = str.empty? ? line : line[0...-str.length]
+        words = ShellParser.parse(before.empty? ? 'x' : before).stages.first.words.map(&:value)
+        command = words.first
+        command = $rubsh_aliases[command].split.first if defined?($rubsh_aliases) && $rubsh_aliases[command]
+        words[0] = command
+        custom = $rubsh_completion_registry.suggestions(words, str)
+        registered = !$rubsh_completion_registry[command].nil?
+
+      end
+    rescue SyntaxError
+      custom = []
+    end
   end
-  completions
+  registered ? custom.uniq : (custom + get_local_dirs(str) + get_executables(str)).uniq
 end
 
 def commands_in_path
@@ -45,3 +66,7 @@ def commands_in_path
   end
   return commands
 end
+COMMANDS_IN_PATH = commands_in_path.freeze
+
+
+# Reline's output modifier also receives subprocess output. Do not rewrite it as input.