yap-shell 0.1.1 → 0.3.0

data/lib/yap/shell/evaluation/shell_expansions.rb

@@ -0,0 +1,85 @@
+module Yap::Shell
+  class Evaluation
+    class ShellExpansions
+      attr_reader :aliases, :world
+
+      def initialize(world:, aliases: Aliases.instance)
+        @world = world
+        @aliases = aliases
+      end
+
+      def expand_aliases_in(input)
+        head, *tail = input.split(/\s/, 2).first
+        if new_head=aliases.fetch_alias(head)
+          [new_head].concat(tail).join(" ")
+        else
+          input
+        end
+      end
+
+      def expand_words_in(input, escape_directory_expansions: true)
+        [input].flatten.inject([]) do |results,str|
+          results << process_expansions(
+            word_expand(str),
+            escape_directory_expansions: escape_directory_expansions
+          )
+        end.flatten
+      end
+
+      def expand_variables_in(input)
+        env_expand(input)
+      end
+
+      private
+
+      def env_expand(str)
+        str.gsub(/\$(\S+)/) do |match,*args|
+          var_name = match[1..-1]
+          case var_name
+          when "?"
+            world.last_result ? world.last_result.status_code.to_s : '0'
+          else
+            world.env.fetch(var_name){ match }
+          end
+        end
+      end
+
+      def word_expand(str)
+        content = str.scan(/\{([^\}]+)\}/).flatten.first
+        if content
+          expansions = content.split(",", -1)
+
+          # Be compatible with Bash/Zsh which only do word-expansion if there
+          # at least one comma listed. E.g. "a_{1,2}" => "a_1 a_2" whereas
+          # "a_{1}" => "a_{1}"
+          if expansions.length > 1
+            return expansions.map { |expansion| str.sub(/\{([^\}]+)\}/, expansion) }
+          end
+        end
+        return [str]
+      end
+
+      def process_expansions(expansions, escape_directory_expansions: true)
+        expansions.map do |s|
+          # Basic bash-style tilde expansion
+          s.gsub!(/\A~(.*)/, world.env["HOME"] + '\1')
+
+          # Basic bash-style variable expansion
+          s = env_expand(s)
+
+          # Basic bash-style path-name expansion
+          expansions = Dir[s]
+          if expansions.any?
+            if escape_directory_expansions
+              expansions.map(&:shellescape)
+            else
+              expansions
+            end
+          else
+            s
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/yap/shell/event_emitter.rb

@@ -0,0 +1,18 @@
+module Yap::Shell
+  module EventEmitter
+    def _callbacks
+      @_callbacks ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def on(type, *args, &blk)
+      _callbacks[type] << blk
+      self
+    end
+
+    def emit(type, *args)
+      _callbacks[type].each do |blk|
+        blk.call(*args)
+      end
+    end
+  end
+end

data/lib/yap/shell/execution/builtin_command_execution.rb

@@ -2,7 +2,7 @@ require 'yap/shell/execution/result'
 
 module Yap::Shell::Execution
   class BuiltinCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:|
+    on_execute do |command:, n:, of:, wait:|
       status_code = command.execute(stdin:@stdin, stdout:@stdout, stderr:@stderr)
       if status_code == :resume
         ResumeExecution.new(status_code:0, directory:Dir.pwd, n:n, of:of)

data/lib/yap/shell/execution/command_execution.rb

@@ -10,14 +10,14 @@ module Yap::Shell::Execution
       end
     end
 
-    def initialize(stdin:, stdout:, stderr:,world:)
+    def initialize(stdin:, stdout:, stderr:, world:)
       @stdin, @stdout, @stderr = stdin, stdout, stderr
       @world = world
     end
 
-    def execute(command:, n:, of:)
+    def execute(command:, n:, of:, wait:true)
       if self.class.on_execute
-        self.instance_exec(command:command, n:n, of:of, &self.class.on_execute)
+        self.instance_exec(command:command, n:n, of:of, wait:wait, &self.class.on_execute)
       else
         raise NotImplementedError, "on_execute block hasn't been implemented!"
       end

data/lib/yap/shell/execution/context.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Yap::Shell::Execution
   class Context
     def self.on(event=nil, &blk)
@@ -31,8 +33,8 @@ module Yap::Shell::Execution
       @suspended_execution_contexts = []
     end
 
-    def add_command_to_run(command, stdin:, stdout:, stderr:)
-      @command_queue << [command, stdin, stdout, stderr]
+    def add_command_to_run(command, stdin:, stdout:, stderr:, wait:)
+      @command_queue << [command, stdin, stdout, stderr, wait]
     end
 
     def clear_commands
@@ -41,9 +43,9 @@ module Yap::Shell::Execution
 
     def execute(world:)
       results = []
-      @command_queue.each_with_index do |(command, stdin, stdout, stderr), reversed_i|
+      @command_queue.each_with_index do |(command, stdin, stdout, stderr, wait), reversed_i|
         of = @command_queue.length
-        i = of - reversed_i
+        i = reversed_i + 1
         stdin  = @stdin  if stdin  == :stdin
         stdout = @stdout if stdout == :stdout
         stderr = @stderr if stderr == :stderr
@@ -58,11 +60,32 @@ module Yap::Shell::Execution
           )
 
           @saved_tty_attrs = Termios.tcgetattr(STDIN)
-          self.class.fire :before_execute, execution_context, command: command
-          result = execution_context.execute(command:command, n:i, of:of)
-          self.class.fire :after_execute, execution_context, command: command, result: result
+          self.class.fire :before_execute, world, command: command
+
+          begin
+            result = execution_context.execute(command:command, n:i, of:of, wait:wait)
+          rescue Exception => ex
+            raise(ex) if ex.is_a?(SystemExit)
+            puts <<-ERROR.gsub(/^\s*\|/, '')
+              |******************************
+              |\e[31mWhoops! An unexpected error has occurred\e[0m
+              |******************************
+              |
+              |The error was:
+              |  #{ex.message}
+              |
+              |Backtrace:
+              |#{ex.backtrace.join("\n")}
+              |
+              |Report this to yap-shell on github:
+              |   https://github.com/zdennis/yap-shell/issues/new?title=#{URI.escape(ex.message)}
+              |
+            ERROR
+          end
+
+          self.class.fire :after_execute, world, command: command, result: result
 
-          results << process_execution_result(execution_context:execution_context, result: result)
+          results << process_execution_result(execution_context:execution_context, result:result)
           Termios.tcsetattr(STDIN, Termios::TCSANOW, @saved_tty_attrs)
         end
       end
@@ -86,7 +109,7 @@ module Yap::Shell::Execution
           nresult = execution_context.resume
           return process_execution_result execution_context: execution_context, result: nresult
         else
-          stderr.puts "fg: No such job"
+          @stderr.puts "fg: No such job"
         end
       else
         return result

data/lib/yap/shell/execution/file_system_command_execution.rb

@@ -3,7 +3,7 @@ require 'termios'
 
 module Yap::Shell::Execution
   class FileSystemCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:, resume_blk:nil|
+    on_execute do |command:, n:, of:, wait:, resume_blk:nil|
       stdin, stdout, stderr, world = @stdin, @stdout, @stderr, @world
       result = nil
       if resume_blk
@@ -40,7 +40,13 @@ module Yap::Shell::Execution
           $stdout.reopen stdout
           $stderr.reopen stderr
 
-          Kernel.exec command.to_executable_str
+          begin
+            before = ENV.to_h.dup
+            ENV.replace(@world.env)
+            Kernel.exec command.to_executable_str
+          ensure
+            ENV.replace(before)
+          end
         end
 
         # Put the child process into a process group of its own
@@ -54,10 +60,9 @@ module Yap::Shell::Execution
 
       # Set terminal's process group to that of the child process
       Termios.tcsetpgrp STDIN, pid
-      pid, status = Process.wait2(-1, Process::WUNTRACED) unless of > 1
-      puts "Process (#{pid}) stopped: #{status.inspect}" if ENV["DEBUG"]
+      pid, status = Process.wait2(pid, Process::WUNTRACED) if wait
 
-      # If we're not printing to the terminal than close in/out/err. This
+      # If we're not printing to the terminal then close in/out/err. This
       # is so the next command in the pipeline can complete and don't hang waiting for
       # stdin after the command that's writing to its stdin has completed.
       if stdout != $stdout && stdout.is_a?(IO) && !stdout.closed? then
@@ -78,7 +83,7 @@ module Yap::Shell::Execution
       end
 
       # if the reason we stopped is from being suspended
-      if status.stopsig == Signal.list["TSTP"]
+      if status && status.stopsig == Signal.list["TSTP"]
         puts "Process (#{pid}) suspended: #{status.stopsig}" if ENV["DEBUG"]
         suspended(command:command, n:n, of:of, pid: pid)
         result = Yap::Shell::Execution::SuspendExecution.new(status_code:nil, directory:Dir.pwd, n:n, of:of)
@@ -100,7 +105,7 @@ module Yap::Shell::Execution
         args[:pid]
       end
 
-      self.instance_exec command:args[:command], n:args[:n], of:args[:of], resume_blk:resume_blk, &self.class.on_execute
+      self.instance_exec command:args[:command], n:args[:n], of:args[:of], resume_blk:resume_blk, wait:true, &self.class.on_execute
     end
 
     def suspended(command:, n:, of:, pid:)

data/lib/yap/shell/execution/ruby_command_execution.rb

@@ -1,9 +1,9 @@
 module Yap::Shell::Execution
   class RubyCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:|
+    on_execute do |command:, n:, of:, wait:|
       result = nil
       stdin, stdout, stderr, world = @stdin, @stdout, @stderr, @world
-      t = Thread.new {
+      # t = Thread.new {
         exit_code = 0
         first_command = n == 1
 
@@ -72,13 +72,13 @@ module Yap::Shell::Execution
         # to be scheduled before we send back our status code. This could
         # probably use a more elaborate signal or message passing scheme,
         # but that's for another day.
-        Thread.pass
+        # Thread.pass
 
         # Make up an exit code
         result = Result.new(status_code:exit_code, directory:Dir.pwd, n:n, of:of)
-      }
-      t.abort_on_exception = true
-      t.join
+      # }
+      # t.abort_on_exception = true
+      # t.join
       result
     end
   end

data/lib/yap/shell/execution/shell_command_execution.rb

@@ -1,8 +1,23 @@
 module Yap::Shell::Execution
   class ShellCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:|
+    on_execute do |command:, n:, of:, wait:|
+      possible_parameters = {
+        command: command.str,
+        args: command.args,
+        stdin: @stdin,
+        stdout: @stdout,
+        stderr: @stderr,
+        world: @world,
+        line: command.line
+      }
+
       func = command.to_proc
-      command_result = func.call(args:command.args, stdin:@stdin, stdout:@stdout, stderr:@stderr)
+      params = func.parameters.reduce({}) do |h, (type, name)|
+        h[name] = possible_parameters[name]
+        h
+      end
+
+      command_result = func.call(**params)
       @stdout.close if @stdout != $stdout && !@stdout.closed?
       @stderr.close if @stderr != $stderr && !@stderr.closed?
     end

data/lib/yap/shell/prompt.rb

@@ -0,0 +1,21 @@
+module Yap::Shell
+  class Prompt
+    attr_reader :text
+
+    def initialize(text:, &blk)
+      @text = text
+      @blk = blk
+    end
+
+    def text=(text)
+      @text = text
+    end
+
+    def update
+      if @blk
+        @text = @blk.call
+      end
+      self
+    end
+  end
+end

data/lib/yap/shell/repl.rb

@@ -1,38 +1,198 @@
-require 'readline'
+require 'shellwords'
+require 'term/ansicolor'
 
 module Yap::Shell
+  module Color
+    extend Term::ANSIColor
+  end
+
   class Repl
+    attr_reader :editor
+
     def initialize(world:nil)
       @world = world
+      @editor= world.editor
+      install_default_keybindings
+      install_default_tab_completion_proc
     end
 
-    def loop_on_input(&blk)
+    def on_input(&blk)
       @blk = blk
 
-      loop do
-        heredoc = nil
-        prompt = ""
-
+      @world.editor.on_read_line do |event|
+        # editor.history = true?
+        line = event[:payload][:line]
         begin
-          prompt = @world ? @world.prompt : "> "
-          input = Readline.readline("#{prompt}", true)
-
-          next if input == ""
-
-          input = process_heredoc(input)
-
-          yield input
+          @blk.call(line)
+          @world.editor.redraw_prompt
         rescue ::Yap::Shell::CommandUnknownError => ex
           puts "  CommandError: #{ex.message}"
-        rescue Interrupt
-          puts "^C"
-          next
+        ensure
+          @world.editor.reset_line
         end
+
+        ensure_process_group_controls_the_tty
+        @world.refresh_prompt
       end
     end
 
     private
 
+    def kill_ring
+      @kill_ring ||= []
+    end
+
+    def install_default_keybindings
+      editor.terminal.keys.merge!(enter: [13])
+      editor.bind(:return){ editor.newline }
+
+      # Move to beginning of line
+      editor.bind(:ctrl_a) { editor.move_to_beginning_of_input }
+
+      # Move to end of line
+      editor.bind(:ctrl_e) { editor.move_to_end_of_input }
+
+      # Move backward one word at a time
+      editor.bind(:ctrl_b) {
+        text = editor.line.text[0...editor.line.position].reverse
+        position = text.index(/\s+/, 1)
+        position = position ? (text.length - position) : 0
+        editor.move_to_position position
+      }
+
+      # Move forward one word at a time
+      editor.bind(:ctrl_f) {
+        text = editor.line.text
+        position = text.index(/\s+/, editor.line.position)
+        position = position ? (position + 1) : text.length
+        editor.move_to_position position
+      }
+
+      # Yank text from the kill ring and insert it at the cursor position
+      editor.bind(:ctrl_y){
+        text = kill_ring[-1]
+        if text
+          editor.yank_forward text.without_ansi
+        end
+      }
+
+      # Backwards delete one word
+      editor.bind(:ctrl_w){
+        before_text =  editor.line.text[0...editor.line.position]
+        after_text = editor.line.text[editor.line.position..-1]
+
+        have_only_seen_whitespace = true
+        position = 0
+
+        before_text.reverse.each_char.with_index do |ch, i|
+          if ch =~ /\s/ && !have_only_seen_whitespace
+            position = before_text.length - i
+            break
+          else
+            have_only_seen_whitespace = false
+          end
+        end
+
+        killed_text = before_text[position...editor.line.position]
+        kill_ring.push killed_text
+
+        text = [before_text.slice(0, position), after_text].join
+        editor.overwrite_line text
+        editor.move_to_position position
+      }
+
+      # History forward, but if at the end of the history then give user a
+      # blank line rather than remain on the last command
+      editor.bind(:down_arrow) {
+        if editor.history.searching? && !editor.history.end?
+          editor.history_forward
+        else
+          editor.overwrite_line ""
+        end
+      }
+
+      editor.bind(:enter) { editor.newline }
+      editor.bind(:tab) { editor.complete }
+      editor.bind(:backspace) { editor.delete_left_character }
+
+      # Delete to end of line from cursor position
+      editor.bind(:ctrl_k) {
+        kill_ring.push editor.kill_forward
+      }
+
+      # Delete to beginning of line from cursor position
+      editor.bind(:ctrl_u) {
+        kill_ring.push editor.line.text[0...editor.line.position]
+        editor.overwrite_line editor.line.text[editor.line.position..-1]
+        editor.move_to_position 0
+      }
+
+      # Forward delete a character, leaving the cursor in place
+      editor.bind("\e[3~") {
+        before_text =  editor.line.text[0...editor.line.position]
+        after_text = editor.line.text[(editor.line.position+1)..-1]
+        text = [before_text, after_text].join
+        position = editor.line.position
+        editor.overwrite_line text
+        editor.move_to_position position
+      }
+
+      editor.bind(:ctrl_l){
+        editor.clear_screen
+      }
+
+      editor.bind(:ctrl_r) {
+        $r = $r ? false : true
+        #  editor.redo
+      }
+      editor.bind(:left_arrow) { editor.move_left }
+      editor.bind(:right_arrow) { editor.move_right }
+      editor.bind(:up_arrow) { editor.history_back }
+      editor.bind(:down_arrow) { editor.history_forward }
+      editor.bind(:delete) { editor.delete_character }
+      editor.bind(:insert) { editor.toggle_mode }
+
+      editor.bind(:ctrl_g) { editor.clear_history }
+      # editor.bind(:ctrl_l) { editor.debug_line }
+      editor.bind(:ctrl_h) { editor.show_history }
+      editor.bind(:ctrl_d) { puts; puts "Exiting..."; exit }
+
+      # character-search; wraps around as necessary
+      editor.bind(:ctrl_n) {
+        line = editor.line
+        text, start_position = line.text, line.position
+        i, new_position = start_position, nil
+
+        break_on_bytes = [editor.terminal.keys[:ctrl_c]].flatten
+        byte = [editor.read_character].flatten.first
+
+        unless break_on_bytes.include?(byte)
+          loop do
+            i += 1
+            i = 0 if i >= text.length                                    # wrap-around to the beginning
+            break if i == start_position                                 # back to where we started
+            (editor.move_to_position(i) ; break) if text[i] == byte.chr  # found a match; move and break
+          end
+        end
+      }
+    end
+
+    def install_default_tab_completion_proc
+      editor.completion_proc = lambda do |word|
+        Dir["#{word}*"].map{ |str| str.gsub(/ /, '\ ')}
+      end
+    end
+
+    # This is to prevent the Errno::EIO error from occurring by ensuring that
+    # if we haven't been made the process group controlling the TTY that we
+    # become so. This method intentionally blocks.
+    def ensure_process_group_controls_the_tty
+      while Process.pid != Termios.tcgetpgrp(STDIN)
+        Termios.tcsetpgrp(STDIN, Process.pid)
+        sleep 0.1
+      end
+    end
+
     def process_heredoc(_input)
       if _input =~ /<<-?([A-z0-9\-]+)\s*$/
         input = _input.dup
@@ -43,8 +203,9 @@ module Yap::Shell
       end
 
       puts "Beginning heredoc" if ENV["DEBUG"]
+
       loop do
-        str = Readline.readline("> ", true)
+        str = editor.read(@world.secondary_prompt.update.text, false)
         input << "#{str}\n"
         if str =~ /^#{Regexp.escape(marker)}$/
           puts "Ending heredoc" if ENV["DEBUG"]