yap-shell 0.7.1 → 0.7.2

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

@@ -1,99 +0,0 @@
-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)
-        Treefell['shell'].puts "shell-expansions expand aliases in: #{input.inspect}"
-        head, *tail = input.split(/\s/, 2).first
-        expanded = if aliases.has_key?(head)
-          new_head=aliases.fetch_alias(head)
-          [new_head].concat(tail).join(" ")
-        else
-          input
-        end
-        expanded
-      end
-
-      def expand_words_in(input, escape_directory_expansions: true)
-        Treefell['shell'].puts "shell-expansions expand words in: #{input.inspect}"
-        expanded = [input].flatten.inject([]) do |results,str|
-          results << process_expansions(
-            word_expand(str),
-            escape_directory_expansions: escape_directory_expansions
-          )
-        end.flatten
-        expanded
-      end
-
-      def expand_variables_in(input)
-        Treefell['shell'].puts "shell-expansions expand variables in: #{input.inspect}"
-        env_expand(input)
-      end
-
-      private
-
-      def env_expand(str)
-        # match "$a", "$a $b", "$a$b", "$cat$dog $foo"
-        str.gsub(/\$([^\$\s]+)/) do |match,*args|
-          var_name = match[1..-1]
-          if var_name == '?'
-            (world.last_result ? world.last_result.status_code.to_s : '0').tap do |expanded|
-              Treefell['shell'].puts "shell-expansions expanding env var #{match} to #{expanded}"
-            end
-          elsif world.env.has_key?(var_name)
-            world.env.fetch(var_name).tap do |expanded|
-              Treefell['shell'].puts "shell-expansions expanding env var #{match} to #{expanded}"
-            end
-          else
-            match
-          end
-        end
-      end
-
-      def word_expand(str)
-        content = str.scan(/\{([^\}]+)\}/).flatten.first
-        if content
-          expansions = content.split(",", -1)
-
-          # Break compatibility with Bash/Zsh. They do not expand words
-          # when there is only one word supplied (e.g. "a_{word}"), but this
-          # is counter-intuitive to me. It should behave the same regardless
-          # of the number of words provided to expand.
-          expanded = expansions.map { |expansion| str.sub(/\{([^\}]+)\}/, expansion) }.tap do |expanded|
-            Treefell['shell'].puts "shell-expansions expanding words in #{str} to #{expanded}"
-          end
-        else
-          [str]
-        end
-      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

@@ -1,18 +0,0 @@
-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.rb

@@ -1,16 +0,0 @@
-module Yap::Shell
-  module Execution
-    require "yap/shell/execution/context"
-    require "yap/shell/execution/command_execution"
-    require "yap/shell/execution/builtin_command_execution"
-    require "yap/shell/execution/file_system_command_execution"
-    require "yap/shell/execution/ruby_command_execution"
-    require "yap/shell/execution/shell_command_execution"
-    require "yap/shell/execution/result"
-
-    Context.register BuiltinCommandExecution,    command_type: :BuiltinCommand
-    Context.register FileSystemCommandExecution, command_type: :FileSystemCommand
-    Context.register ShellCommandExecution,      command_type: :ShellCommand
-    Context.register RubyCommandExecution,       command_type: :RubyCommand
-  end
-end

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

@@ -1,20 +0,0 @@
-module Yap::Shell::Execution
-  require 'yap/shell/execution/result'
-
-  class BuiltinCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:, wait:|
-      Treefell['shell'].puts "builtin command executing: #{command}"
-      status_code = command.execute(stdin:@stdin, stdout:@stdout, stderr:@stderr)
-      if status_code == :resume
-        Treefell['shell'].puts "builtin command execution resumed: #{command}"
-        ResumeExecution.new(status_code:0, directory:Dir.pwd, n:n, of:of)
-      else
-        @stdout.close if @stdout != $stdout && !@stdout.closed?
-        @stderr.close if @stderr != $stderr && !@stderr.closed?
-        Result.new(status_code:status_code, directory:Dir.pwd, n:n, of:of).tap do |result|
-          Treefell['shell'].puts "builtin command execution done with result=#{result.inspect}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module Yap::Shell::Execution
-  class CommandExecution
-    attr_reader :stdin, :stdout, :stderr, :world
-
-    def self.on_execute(&blk)
-      if block_given?
-        @on_execute_blk = blk
-      else
-        @on_execute_blk
-      end
-    end
-
-    def initialize(stdin:, stdout:, stderr:, world:)
-      @stdin, @stdout, @stderr = stdin, stdout, stderr
-      @world = world
-    end
-
-    def execute(command:, n:, of:, wait:true)
-      if 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
-    end
-
-    def suspended?
-      @suspended
-    end
-  end
-end

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

@@ -1,128 +0,0 @@
-require 'uri'
-
-module Yap::Shell::Execution
-  class Context
-    def self.on(event=nil, &blk)
-      @on_callbacks ||= Hash.new{ |h,k| h[k] = [] }
-      if event
-        @on_callbacks[event.to_sym].push blk
-      end
-      @on_callbacks
-    end
-
-    def self.fire(event, context, *args)
-      on[event.to_sym].each do |block|
-        block.call(context, *args)
-      end
-    end
-
-    def self.register(context, command_type:)
-      raise "context cannot be nil" if context.nil?
-      @registrations ||= {}
-      @registrations[command_type] = context
-      true
-    end
-
-    def self.execution_context_for(command)
-      @registrations[command.type] || raise("No execution context found for given #{command.type} command: #{command.inspect}")
-    end
-
-    def initialize(stdin:, stdout:, stderr:)
-      @stdin, @stdout, @stderr = stdin, stdout, stderr
-      @command_queue = []
-      @suspended_execution_contexts = []
-    end
-
-    def add_command_to_run(command, stdin:, stdout:, stderr:, wait:)
-      @command_queue << [command, stdin, stdout, stderr, wait]
-    end
-
-    def clear_commands
-      @command_queue.clear
-    end
-
-    def execute(world:)
-      results = []
-      @command_queue.each_with_index do |(command, stdin, stdout, stderr, wait), reversed_i|
-        of = @command_queue.length
-        i = reversed_i + 1
-        stdin  = @stdin  if stdin  == :stdin
-        stdout = @stdout if stdout == :stdout
-        stderr = @stderr if stderr == :stderr
-
-        execution_context_factory = self.class.execution_context_for(command)
-        if execution_context_factory
-          execution_context = execution_context_factory.new(
-            stdin:  stdin,
-            stdout: stdout,
-            stderr: stderr,
-            world:  world
-          )
-
-          @saved_tty_attrs = Termios.tcgetattr(STDIN) if STDIN.isatty
-
-          Treefell['shell'].puts "firing :before_execute for #{command}"
-          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)
-
-            Treefell['shell'].puts "rescued unexpected error=#{ex} with message=#{ex.message.inspect}"
-            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
-
-          Treefell['shell'].puts "firing :after_execute for #{command}"
-          self.class.fire :after_execute, world, command: command, result: result
-
-          results << process_execution_result(execution_context:execution_context, result:result)
-          Termios.tcsetattr(STDIN, Termios::TCSANOW, @saved_tty_attrs) if STDIN.isatty
-        end
-      end
-
-      clear_commands
-
-      results.last
-    end
-
-    private
-
-    def process_execution_result(execution_context:, result:)
-      case result
-      when SuspendExecution
-        Treefell['shell'].puts "suspending execution context"
-        @suspended_execution_contexts.push execution_context
-        return result
-
-      when ResumeExecution
-        Treefell['shell'].puts "resuming suspended execution context"
-        execution_context = @suspended_execution_contexts.pop
-        if execution_context
-          nresult = execution_context.resume
-          Treefell['shell'].puts "resuming suspended execution context success"
-          return process_execution_result execution_context: execution_context, result: nresult
-        else
-          Treefell['shell'].puts "error: cannot resume execution when there is nothing suspended"
-          @stderr.puts "fg: No such job"
-        end
-      else
-        return result
-      end
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-require 'termios'
-
-module Yap::Shell::Execution
-  require 'yap/shell/execution/result'
-
-  class FileSystemCommandExecution < CommandExecution
-    on_execute do |command:, n:, of:, wait:, resume_blk:nil|
-      stdin, stdout, stderr, world = @stdin, @stdout, @stderr, @world
-      result = nil
-      if resume_blk
-        pid = resume_blk.call
-      else
-        r,w = nil, nil
-        if command.heredoc
-          r,w = IO.pipe
-          stdin = r
-        end
-
-        pid = fork do
-          # reset signals in case any were ignored
-          Signal.trap("SIGINT",  "DEFAULT")
-          Signal.trap("SIGQUIT", "DEFAULT")
-          Signal.trap("SIGTSTP", "DEFAULT")
-          Signal.trap("SIGTTIN", "DEFAULT")
-          Signal.trap("SIGTTOU", "DEFAULT")
-
-          # Set the process group of the forked to child to that of the
-          Process.setpgrp
-
-          $stdin.reopen stdin
-          $stdout.reopen stdout
-          $stderr.reopen stderr
-
-          begin
-            before = ENV.to_h.dup
-            ENV.replace(@world.env)
-            Treefell['shell'].puts <<-MSG.gsub(/^\s*\|/, '')
-              |forked child process
-              |  pid=#{Process.pid} #{command.to_executable_str}
-              |  stdin=#{stdin.inspect}
-              |  stdout=#{stdout.inspect}
-              |  stderr=#{stderr.inspect}
-              |  $stdin=#{$stdin.inspect}
-              |  $stdout=#{$stdout.inspect}
-              |  $stderr=#{$stderr.inspect}
-            MSG
-            Kernel.exec command.to_executable_str
-          ensure
-            ENV.replace(before)
-          end
-        end
-        Treefell['shell'].puts "forked child process pid=#{pid} to execute #{command}"
-
-        # Put the child process into a process group of its own
-        Process.setpgid pid, pid
-
-        if command.heredoc
-          Treefell['shell'].puts "command has heredoc, wriing to stdin"
-          w.write command.heredoc
-          w.close
-        end
-      end
-
-      # Set terminal's process group to that of the child process
-      Termios.tcsetpgrp STDIN, pid if STDIN.isatty
-      pid, status = Process.wait2(pid, Process::WUNTRACED) if wait
-
-      # 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
-        Treefell['shell'].puts "closing stdout for child process with pid=#{pid}"
-        stdout.close
-      end
-      if stderr != $stderr && stderr.is_a?(IO) && !stderr.closed? then
-        Treefell['shell'].puts "closing stderr for child process with pid=#{pid}"
-        stderr.close
-      end
-      # if stdin != $stdin && !stdin.closed? then stdin.close end
-
-
-      # if the pid that just stopped was the process group owner then
-      # give it back to the us so we can become the foreground process
-      # in the terminal
-      if STDIN.isatty
-        if pid == Termios.tcgetpgrp(STDIN)
-          Treefell['shell'].puts <<-DEBUG.gsub(/^\s*\|/, '')
-            |restoring process group for STDIN to yap process with pid=#{Process.pid}
-          DEBUG
-          Process.setpgid Process.pid, Process.pid
-          Termios.tcsetpgrp STDIN, Process.pid
-        end
-      end
-
-      # if the reason we stopped is from being suspended
-      sigtstp = Signal.list["TSTP"]
-      if status && status.stopsig == sigtstp
-        Treefell['shell'].puts "process pid=#{pid} suspended by signal=#{status.stopsig.inspect}"
-        Treefell['shell'].puts "$?: #{$?.inspect}"
-        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)
-      else
-        caused_by_signal = status ? (status.termsig || status.stopsig) : nil
-        Treefell['shell'].puts "process pid=#{pid} stopped by signal=#{caused_by_signal.inspect}"
-        Treefell['shell'].puts "$?: #{$?.inspect}"
-        # if a signal killed or stopped the process (such as SIGINT or SIGTSTP) $? is nil.
-        exitstatus = $? ? $?.exitstatus : nil
-        result = Yap::Shell::Execution::Result.new(status_code:exitstatus, directory:Dir.pwd, n:n, of:of)
-      end
-    end
-
-    def resume
-      args = @suspended
-      @suspended = nil
-      pid = args[:pid]
-      sigcont = Signal.list["CONT"]
-
-      Treefell['shell'].puts "resuming suspended process pid=#{pid} by sending it signal=#{sigcont}"
-      resume_blk = lambda do
-        Process.kill sigcont, pid
-        pid
-      end
-
-      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:)
-      Treefell['shell'].puts "process pid=#{pid} suspended"
-      @suspended = {
-        command: command,
-        n: n,
-        of: of,
-        pid: pid
-      }
-    end
-  end
-end