rubsh 0.0.2 → 0.0.3

data/lib/rubsh.rb

@@ -4,143 +4,480 @@ require 'rub_readline'
 require 'prompt'
 require 'etc'
 require 'alias'
+require 'shell_parser'
+require 'shell_pipeline'
+require 'completion'
+
 
 def ralias(str)
-  Alias.parse(str)
+  name, value = str.to_s.strip.split(/\s+/, 2)
+  [name, value]
 end
 
 class Rubsh
-   def initialize()
-      Signal.trap('INT') {
-         puts "Enter exit/quit to exit shell"
-      }
-      Signal.trap('SIGKILL') {
-         puts "Enter exit/quit to exit shell"
-      }
-   end
-
-   def self.iscmd?(cmd = nil)
-      return nil unless cmd
-      return true if File.exists? cmd
-      ENV["PATH"].split(':').each do |dir|
-         return true if File.exists? "#{dir}/#{cmd.split[0]}"
+  attr_reader :commands
+
+  def initialize
+    @commands = Commands.new
+    @binding = @commands.get_binding
+    @aliases = Alias.new
+    @block = []
+    @block_depth = 0
+    @function_sources = {}
+    @completions = CompletionRegistry.new
+
+    @binding.eval('$PATH = ENV.fetch("PATH", "").split(File::PATH_SEPARATOR)')
+
+
+    @commands.shell_executor = proc { |name, args| execute_ruby_command(name, args) }
+    @commands.shell_source_executor = proc { |source| execute_pipeline(ShellParser.parse(source)) }
+    @commands.completion_executor = proc { |name, &block| @completions.complete(name, &block) }
+    $rubsh_completion_registry = @completions
+    $rubsh_aliases = @aliases
+
+
+
+
+    Signal.trap('INT') { warn 'Enter exit or quit to exit shell' }
+  end
+
+  def self.iscmd?(cmd = nil)
+    return false unless cmd
+    executable?(cmd.to_s.split.first)
+  end
+
+  def self.executable?(name)
+    return false if name.nil? || name.empty?
+    return File.executable?(name) if name.include?(File::SEPARATOR)
+    ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
+      path = File.join(dir, name)
+      File.executable?(path) && !File.directory?(path)
+    end
+  end
+
+  def alias(*args)
+    return @aliases.to_h if args.empty?
+    define_alias(args.shift, args.join(' '))
+  end
+
+  def source(filename)
+    ruby_lines = []
+    File.foreach(filename) do |line|
+      directive = line.strip
+      if directive =~ /\Aalias\s+(\S+)\s+(.+)\z/
+        define_alias($1, $2)
+      else
+        ruby_lines << line
+      end
+    end
+    source = ruby_lines.join
+    source.scan(/^\s*def\s+([A-Za-z_]\w*)/).each { |match| @function_sources[match.first] = source }
+    eval(source, @binding, filename) unless source.empty?
+  end
+
+  def parse_cmd(line)
+    return exit if line.nil?
+    return if line.to_s.strip.empty?
+    line = line.to_s
+    if line.match?(/\A\s*def\b.*\bend\s*\|/)
+      warn 'rubsh: cannot pipe a function definition; define it before running the pipeline'
+      return 2
+    end
+    if line =~ /\A(.+?)\s*\|\s*complete\s+--from-fish\s*\z/
+      imported = execute_pipeline(ShellParser.parse(Regexp.last_match(1)), capture: true)
+      @completions.import_fish(imported)
+      return 0
+    end
+    if line =~ /\A(.+?)\s*\|\s*source\s*\z/
+      generated = execute_pipeline(ShellParser.parse(Regexp.last_match(1)), capture: true)
+      eval(generated, @binding, '(pipeline source)')
+      return 0
+    end
+    if line =~ /\A(def\s+[A-Za-z_]\w*\s*;.*?;\s*end;?)\s*(.+)\z/
+      accept_ruby_line(Regexp.last_match(1))
+      rest = Regexp.last_match(2).sub(/\A\s*;\s*/, '')
+      return parse_cmd(rest) unless rest.empty?
+      return 0
+    end
+
+    return accept_ruby_line(line) if collecting_ruby?
+
+
+
+    if line =~ /\Acomplete\s+-e\s+(\S+)\s*\z/
+      @completions.erase($1)
+      return 0
+    elsif line =~ /\Acomplete\s+(\S+)\s*\z/
+      puts @completions.show($1)
+      return 0
+    end
+
+    if ruby_expression?(line)
+      expression = line.match?(/\$(?:PATH|argv|rubsh_status)/) ? line : expand_environment(line)
+      eval(expression, @binding)
+      return 0
+    end
+
+    if line =~ /\Asource\s+(.+)\z/
+      path = expand_tilde(Regexp.last_match(1).strip)
+      unless File.file?(path)
+        warn "rubsh: source file not found: #{path}"
+        return 1
       end
-      return false
-   end
-
-   def history
-     history_file = ENV['HOME'] + '/.rubsh/history'
-     return unless File.exists?  history_file
-     IO.readlines("#{ENV['HOME']}/.rubsh/history").each do |line|
-       puts line
-     end
-   end
-
-   def alias(*args)
-     if args.size == 0
-       Alias.show
-       return
-     end
-     first = args.shift
-     Alias[first] = args.join(' ')
-   end
-   def source(fname)
-     load fname
-   end
-
-   def parse_cmd(cmd,follow=true)
-     exit if cmd =~ /exit|quit/
-       exit if cmd == nil
-     call,*args = cmd.split
-     return unless call
-     if Alias[call] and follow #prevent recursion
-       parse_cmd Alias[call] + ' ' + args.join(' '), false
-     elsif Commands.new.respond_to? call
-       begin
-         Commands.new.send call, cmd
-       rescue
-         puts $!
-       end
-     elsif Rubsh::iscmd? call
-       system(cmd)
-     else
-       begin
-         res = eval(cmd,Commands.new.get_binding)
-         p res
-       rescue Exception
-         puts $!
-       end
-     end
-   end
-
-   def parse_cmd2(cmd,follow=true)
-     exit if cmd =~ /exit|quit/
-     exit if cmd == nil
-     call,*args = cmd.split
-     return unless call
-     if Alias[call] and follow #prevent recursion
-       parse_cmd Alias[call] + ' ' + args.join(' '), false
-     elsif ::Rubsh::iscmd? call
-       system(cmd)
-     else
-       begin
-         p eval(cmd, Commands.new.get_binding)
-       rescue Exception
-         puts $!
-       end
-     end
-   end
-
-   def log_cmd(cmd)
-     @fh = File.open(ENV['HOME'] + '/.rubsh/history','a+') unless @fh
-     @fh.puts cmd unless cmd.nil? or cmd =~ /^\s*$/
-     @fh.flush
-   end
-
-   at_exit { @fh.close if @fh }
-
-   def init_readline
-     history_file = ENV['HOME'] + '/.rubsh/history'
-     return unless File.exists?  history_file
-     IO.readlines(history_file).each do |line|
-       line.chomp!
-       Readline::HISTORY.push line
-     end
-   end
-
-   def run
-     ENV['PR1'] ||= '[%h:%w] %u%% '
-     if not File.exists? "#{ENV['HOME']}/.rubsh"
-       FileUtils.mkdir "#{ENV['HOME']}/.rubsh"
-     end
-     if File.exists? "#{ENV['HOME']}/.rubsh/rc.rb"
-       source ENV['HOME'] + '/.rubsh/rc.rb'
-     end
-     init_readline
-     loop do
-       prompt = Prompt::parse ENV['PR1']
-       cmd = Readline::readline(prompt, true)
-       Readline::HISTORY.pop if cmd =~ /^\s*$/
-       log_cmd cmd
-       parse_cmd cmd
-     end
-   end
+      source(path)
+      return 0
+    end
+
+    if line =~ /\A(?:alias|ralias)\s+(\S+)\s+(.+)\z/
+      define_alias($1, $2)
+      return 0
+    end
+    if line =~ /\Adef\s+-([esr])\s+([A-Za-z_]\w*)\s*\z/
+      return edit_function($2) if $1 == 'e'
+      return remove_function($2) if $1 == 'r'
+      return save_function($2)
+    end
+    if line =~ /\Atype\s+([A-Za-z_]\w*)\s*\z/
+      return report_type($1)
+    end
+
+    return accept_ruby_line(line) if ruby_block_start?(line)
+
+    if line.strip =~ /\A\$([A-Za-z_]\w*)\z/
+      puts ENV.fetch($1, '')
+      return 0
+    end
+    if line.strip =~ /\A(puts|print|p)\s+\$([A-Za-z_]\w*)\z/
+      value = ENV.fetch($2, '')
+      Kernel.public_send($1, value)
+      return 0
+    end
+
+    return exit if line.strip =~ /\A(?:exit|quit)\z/
+
+    execute_pipeline(expand_alias(ShellParser.parse(line)))
+  rescue SyntaxError, StandardError => error
+    warn "rubsh: #{error.message}"
+    1
+  end
+
+  def execute_pipeline(pipeline, capture: false)
+    stages = pipeline.stages.map { |stage| expand_stage(stage) }
+    sync_path_environment
+
+    if stages.length == 1 && stages.first.first == 'cd'
+      return @commands.call('cd', stages.first.drop(1), stderr: $stderr)
+    end
+
+    runtime = stages.map do |argv|
+      callable = callable_for(argv.first)
+      ShellPipelineStage.new(argv, callable: callable)
+    end
+    target = capture ? StringIO.new : $stdout
+    result = ShellPipeline.new(runtime, stdout: target, stderr: $stderr).run
+    capture ? result.stdout.sub(/\n\z/, '') : result.returncode
+  end
+
+  def run(command = nil)
+    ENV['PR1'] ||= '[%h:%w] %u%% '
+    directory = File.join(ENV['HOME'], '.config', 'rubsh')
+    defs = File.join(directory, 'defs')
+    completions = File.join(directory, 'completions')
+
+    FileUtils.mkdir_p(completions)
+    Dir[File.join(completions, '*.rb')].sort.each { |file| source(file) }
+    local_completions = File.expand_path('../completions', __dir__)
+    Dir[File.join(local_completions, '*.rb')].sort.each { |file| source(file) }
+
+
+    FileUtils.mkdir_p(defs)
+    Dir[File.join(defs, '*.rb')].sort.each { |file| source(file) }
+    config = File.join(directory, 'config.rb')
+    source(config) if File.exist?(config)
+    return parse_cmd(command) unless command.nil?
+    init_readline
+    loop do
+      prompt = @block.empty? ? prompt_for_readline : '> '
+      line = Reline.readline(prompt, true)
+      break if line.nil?
+      Reline::HISTORY.pop if line.strip.empty?
+      log_cmd(line)
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      status = parse_cmd(line)
+      ENV['CMD_DURATION'] = (((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round).to_s
+      $rubsh_status = status
+      $stdout.write("\n") if $stdout.respond_to?(:tty?) && $stdout.tty?
+
+    end
+  end
+
+  def prompt_text
+    return Prompt.parse(ENV['PR1']) unless @commands.command?('sh_prompt')
+    @binding.eval('sh_prompt').to_s
+  rescue StandardError => error
+    warn "rubsh: sh_prompt: #{error.message}"
+    Prompt.parse(ENV['PR1'])
+  end
+
+  def prompt_for_readline
+    lines = prompt_text.split("\n", -1)
+    unless lines.length == 1
+      $stdout.write(lines[0...-1].join("\n"))
+      $stdout.write("\n")
+    end
+    lines[-1]
+  end
+
+  def history
+    file = File.join(ENV['HOME'], '.rubsh', 'history')
+    return unless File.exist?(file)
+    File.foreach(file) { |line| puts line }
+  end
+
+  def log_cmd(command)
+    return if command.nil? || command.strip.empty?
+    @fh ||= File.open(File.join(ENV['HOME'], '.rubsh', 'history'), 'a+')
+    @fh.puts(command)
+    @fh.flush
+  rescue SystemCallError
+    @fh = nil
+  end
+
+  def init_readline
+    file = File.join(ENV['HOME'], '.rubsh', 'history')
+    return unless File.exist?(file)
+    File.foreach(file) { |line| Reline::HISTORY.push(line.chomp) }
+  end
+
+  private
+
+  def collecting_ruby?
+    !@block.empty?
+  end
+
+  def ruby_block_start?(line)
+    line.lstrip.start_with?('def ')
+  end
+
+  def accept_ruby_line(line)
+    @block << line
+    @block_depth += line.scan(/\bdef\b/).length
+    @block_depth -= line.scan(/\bend\b/).length
+    return if @block_depth > 0
+    original_source = @block.join("\n")
+    source = transform_ruby_source(original_source)
+    function_name = original_source[/\A\s*def\s+([A-Za-z_]\w*)/, 1]
+    @function_sources[function_name] = original_source if function_name
+    @block = []
+    eval(source, @binding)
+  end
+
+  def execute_ruby_command(name, args)
+    words = [ShellParser::Word.new([name.to_s])] + args.map { |arg| ShellParser::Word.new([arg.to_s]) }
+    execute_pipeline(ShellParser::Pipeline.new([ShellParser::Stage.new(words)]))
+    nil
+  end
+
+  def transform_ruby_source(source)
+    source.lines.map do |line|
+      inline = line.match(/^(\s*)def\s+([A-Za-z_]\w*)\s*;\s*([A-Za-z_]\w*(?:\s+.+?))\s*;\s*end\s*;?\s*$/)
+      if inline && self.class.executable?(inline[3].split.first)
+        "#{inline[1]}def #{inline[2]}; __rubsh_shell__(#{inline[3].inspect}); end\n"
+      else
+        match = line.match(/^(\s*)([A-Za-z_]\w*)(?:\s+(.+?))?\s*$/)
+        if match && self.class.executable?(match[2])
+          "#{match[1]}__rubsh_shell__(#{line.strip.inspect})\n"
+        else
+          line
+        end
+      end
+    end.join
+  end
+
+  def save_function(name)
+    source = @function_sources[name]
+    alias_definition = @aliases[name]
+    unless source || alias_definition
+      warn "rubsh: function not found: #{name}"
+      return 1
+    end
+    directory = File.join(ENV['HOME'], '.config', 'rubsh', 'defs')
+    FileUtils.mkdir_p(directory)
+    path = File.join(directory, "#{name}.rb")
+    if alias_definition
+      File.write(path, "alias #{name} #{alias_definition.inspect}\n")
+    else
+      File.write(path, format_ruby_definition(source, color: false) + "\n")
+    end
+    0
+  rescue SystemCallError => error
+    warn "rubsh: #{error.message}"
+    1
+  end
+
+  def remove_function(name)
+    @function_sources.delete(name)
+    @aliases.delete(name)
+    method = name.to_sym
+    if @commands.singleton_class.instance_methods(false).include?(method)
+      @commands.singleton_class.send(:remove_method, method)
+    elsif @commands.class.instance_methods(false).include?(method)
+      @commands.class.send(:remove_method, method)
+    end
+    path = File.join(ENV['HOME'], '.config', 'rubsh', 'defs', "#{name}.rb")
+    File.delete(path) if File.file?(path)
+    0
+  rescue SystemCallError => error
+    warn "rubsh: #{error.message}"
+    1
+  end
+
+  def edit_function(name)
+    directory = File.join(ENV['HOME'], '.config', 'rubsh', 'defs')
+    FileUtils.mkdir_p(directory)
+    path = File.join(directory, "#{name}.rb")
+    source = @function_sources[name] || "def #{name}\nend\n"
+    File.write(path, format_ruby_definition(source, color: false) + "\n") unless File.exist?(path)
+    editor = ENV['EDITOR'] || ENV['VISUAL']
+    unless editor && !editor.empty?
+      warn 'rubsh: $EDITOR is not set'
+      return 1
+    end
+    return 1 unless system(editor, path)
+    source(path)
+    0
+  rescue SystemCallError => error
+    warn "rubsh: #{error.message}"
+    1
+  end
+
+  def report_type(name)
+    if (definition = @aliases[name])
+      puts "#{name} is a function with definition"
+      puts '# Defined via alias'
+      puts format_shell_definition(name, definition)
+    elsif @commands.command?(name)
+      puts "#{name} is a function with definition"
+      puts '# Defined via Ruby'
+      puts format_ruby_definition(@function_sources[name] || "def #{name}\nend")
+    elsif self.class.executable?(name)
+      path = ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).map { |dir| File.join(dir, name) }.find { |candidate| File.executable?(candidate) }
+      puts "#{name} is #{path}"
+    else
+      puts "#{name} not found"
+      return 1
+    end
+    0
+  end
+
+  def format_ruby_definition(source, color: true)
+    lines = source.lines.map(&:rstrip)
+    lines.each_with_index.map do |line, index|
+      formatted = index > 0 && index < lines.length - 1 && !line.empty? ? "  #{line.lstrip}" : line
+      highlight_ruby(formatted, color: color)
+    end.join("\n")
+  end
+
+  def format_shell_definition(name, definition)
+    ["function #{name}", "  #{definition} $argv", 'end'].map { |line| highlight_shell(line) }.join("\n")
+  end
+
+  def highlight_ruby(line, color: true)
+    return line unless color && $stdout.respond_to?(:tty?) && $stdout.tty?
+    line.gsub(/\b(def|end|return)\b/, "\e[35m\\1\e[0m").gsub(/([\"'].*?[\"'])/, "\e[32m\\1\e[0m")
+  end
+
+  def highlight_shell(line)
+    return line unless $stdout.respond_to?(:tty?) && $stdout.tty?
+    line.gsub(/\b(function|end)\b/, "\e[36m\\1\e[0m")
+  end
+
+  def define_alias(name, value)
+    value = value.strip
+    value = value[1...-1] if value.length >= 2 && value[0] == value[-1] && ['"', "'"].include?(value[0])
+    @aliases[name.to_s] = value
+  end
+
+  def expand_alias(pipeline)
+    first = pipeline.stages.first
+    return pipeline unless first && first.words.first&.literal?
+    name = first.words.first.value
+    replacement = @aliases[name]
+    return pipeline unless replacement
+    raise RuntimeError, "alias recursion: #{name}" if replacement.include?(name)
+    replacement_stage = ShellParser.parse(replacement).stages.first
+    ShellParser::Pipeline.new([ShellParser::Stage.new(replacement_stage.words + first.words.drop(1))] + pipeline.stages.drop(1))
+  end
+
+  def expand_stage(stage)
+    stage.words.flat_map do |word|
+      value = word.parts.map do |part|
+        if part.is_a?(ShellParser::Substitution)
+          execute_substitution(part.source)
+        else
+          expand_tilde(expand_environment(part))
+        end
+      end.join
+      expand_glob(value)
+    end
+  end
+
+  def expand_glob(value)
+    return [value] unless value.match?(/[\*\?\[]/)
+    matches = Dir.glob(value)
+    matches.empty? ? [value] : matches
+  end
+
+
+
+  def expand_environment(value)
+    value.gsub(/\$([A-Za-z_]\w*)/) { ENV.fetch(Regexp.last_match(1), '') }
+  end
+
+  def sync_path_environment
+    path = @binding.eval('$PATH')
+    ENV['PATH'] = path.map(&:to_s).join(File::PATH_SEPARATOR) if path.is_a?(Array)
+  end
+
+  def expand_tilde(value)
+    return value unless value == '~' || value.start_with?('~/')
+    File.expand_path(value, ENV['HOME'])
+  end
+
+  def ruby_expression?(line)
+    return true if line.match?(/\A\s*[A-Za-z_]\w*\s*=\s*[^=]/)
+    return true if line.match?(/\A\s*\$PATH\b/)
+    return true if line.match?(/\A\s*(?:puts|print|p)\s+\$(?:PATH|argv|rubsh_status)\s*\z/)
+
+    if line =~ /\A\s*(?:puts|print|p)\s+([a-z_]\w*)\s*\z/
+      return @binding.local_variable_defined?($1.to_sym)
+    end
+    line =~ /\A\s*([a-z_]\w*)\s*\z/ && @binding.local_variable_defined?($1.to_sym)
+  end
+
+  def execute_substitution(source)
+    execute_pipeline(expand_alias(ShellParser.parse(source)), capture: true).to_s
+  end
+
+  def callable_for(name)
+    return nil if self.class.executable?(name)
+    return nil unless @commands.command?(name)
+    proc { |argv| @commands.call(name, argv.drop(1)) }
+  end
 end
 
 class String
   def ls
-    Dir.glob self
+    Dir.glob(self)
   end
 end
 
 class Array
-  def du(opt='')
-    switch = ''
-    if (opt.class == Symbol)
-      switch = '-' + opt.to_s
-    else
-      switch = opt
+  def du(opt = '')
+    switch = opt.is_a?(Symbol) ? "-#{opt}" : opt.to_s
+    each do |file|
+      pid = Process.spawn('du', switch, file.to_s)
+      Process.wait(pid)
     end
-    self.each { |f| system("du #{switch} '#{f}'"); }
   end
 end