yap-shell 0.0.2

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

@@ -0,0 +1,30 @@
+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:)
+      if self.class.on_execute
+        self.instance_exec(command:command, n:n, of:of, &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

@@ -0,0 +1,88 @@
+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:)
+      @command_queue << [command, stdin, stdout, stderr]
+    end
+
+    def clear_commands
+      @command_queue.clear
+    end
+
+    def execute(world:)
+      results = []
+      @command_queue.each_with_index do |(command, stdin, stdout, stderr), reversed_i|
+        of = @command_queue.length
+        i = of - reversed_i
+        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
+          )
+
+          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
+
+          case result
+          when SuspendExecution
+            # Ensure echo is turned back on. Some suspended programs
+            # may have turned it off.
+            `stty echo`
+            @suspended_execution_contexts.push execution_context
+          when ResumeExecution
+            execution_context = @suspended_execution_contexts.pop
+            if execution_context
+              execution_context.resume
+            else
+              stderr.puts "fg: No such job"
+            end
+          end
+
+          results << result
+        end
+      end
+
+      clear_commands
+
+      results.last
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Yap::Shell::Execution
+  class FileSystemCommandExecution < CommandExecution
+    on_execute do |command:, n:, of:, resume_blk:nil|
+      stdin, stdout, stderr, world = @stdin, @stdout, @stderr, @world
+      result = nil
+      begin
+        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
+            # Start a new process gruop as the session leader. Now we are
+            # responsible for sending signals that would have otherwise
+            # been propagated to the process, e.g. SIGINT, SIGSTOP, SIGCONT, etc.
+            stdin  = File.open(stdin, "rb") if stdin.is_a?(String)
+            stdout = File.open(stdout, "wb") if stdout.is_a?(String)
+            stderr = File.open(stderr, "wb") if stderr.is_a?(String)
+
+            stdout = stderr if stdout == :stderr
+            stderr = stdout if stderr == :stdout
+
+            $stdin.reopen stdin
+            $stdout.reopen stdout
+            $stderr.reopen stderr
+            Process.setsid
+
+            Kernel.exec command.to_executable_str
+          end
+          if command.heredoc
+            w.write command.heredoc
+            w.close
+          end
+        end
+
+        # This prevents the shell from processing sigint and lets the child
+        # process handle it. Necessary for interactive shells that do not
+        # abort on Ctrl-C such as irb.
+        Signal.trap("SIGINT") do
+          Process.kill("SIGINT", pid)
+        end
+
+        Process.waitpid(pid) unless of > 1
+        Signal.trap("SIGINT", "DEFAULT")
+
+        # If we're not printing to the terminal than 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
+          stdout.close
+        end
+        if stderr != $stderr && stderr.is_a?(IO) && !stderr.closed? then
+          stderr.close
+        end
+        # if stdin != $stdin && !stdin.closed? then stdin.close end
+
+      rescue Interrupt
+        Process.kill "SIGINT", pid
+
+      rescue SuspendSignalError => ex
+        Process.kill "SIGSTOP", pid
+
+        # The Process started above with the PID +pid+ is a child process
+        # so it has also received the suspend/SIGTSTP signal.
+        suspended(command:command, n:n, of:of, pid: pid)
+
+        result = SuspendExecution.new(status_code:nil, directory:Dir.pwd, n:n, of:of)
+      end
+
+      # if a signal killed or stopped the process (such as SIGINT or SIGTSTP) $? is nil.
+      exitstatus = $? ? $?.exitstatus : nil
+      result || Result.new(status_code:exitstatus, directory:Dir.pwd, n:n, of:of)
+    end
+
+    def resume
+      args = @suspended
+      @suspended = nil
+
+      puts "Resuming: #{args[:pid]}" if ENV["DEBUG"]
+      resume_blk = lambda do
+        Process.kill "SIGCONT", args[:pid]
+        args[:pid]
+      end
+
+      self.instance_exec command:args[:command], n:args[:n], of:args[:of], resume_blk:resume_blk, &self.class.on_execute
+    end
+
+    def suspended(command:, n:, of:, pid:)
+      puts "Suspending: #{pid}" if ENV["DEBUG"]
+      @suspended = {
+        command: command,
+        n: n,
+        of: of,
+        pid: pid
+      }
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Yap::Shell::Execution
+  class Result
+    attr_reader :status_code, :directory, :n, :of
+
+    def initialize(status_code:, directory:, n:, of:)
+      @status_code = status_code
+      @directory = directory
+      @n = n
+      @of = of
+    end
+  end
+
+  class SuspendExecution < Result
+  end
+
+  class ResumeExecution < Result
+  end
+end

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

@@ -0,0 +1,85 @@
+module Yap::Shell::Execution
+  class RubyCommandExecution < CommandExecution
+    on_execute do |command:, n:, of:|
+      result = nil
+      stdin, stdout, stderr, world = @stdin, @stdout, @stderr, @world
+      t = Thread.new {
+        exit_code = 0
+        first_command = n == 1
+
+        f = nil
+        ruby_result = nil
+        begin
+          ruby_command = command.to_executable_str
+
+          contents = if stdin.is_a?(String)
+            puts "READ: stdin as a String: #{stdin.inspect}" if ENV["DEBUG"]
+            f = File.open stdin
+            f.read
+          elsif stdin != $stdin
+            puts "READ: stdin is not $stdin: #{stdin.inspect}" if ENV["DEBUG"]
+            stdin.read
+          else
+            puts "READ: contents is: #{contents.inspect}" if ENV["DEBUG"]
+          end
+
+          puts "READ: #{contents.length} bytes from #{stdin}" if ENV["DEBUG"] && contents
+          world.contents = contents
+
+          method = ruby_command.scan(/^(\w+(?:[!?]|\s*=)?)/).flatten.first.gsub(/\s/, '')
+          puts "method: #{method}" if ENV["DEBUG"]
+
+          obj = if first_command
+            world
+          elsif contents.respond_to?(method)
+            contents
+          else
+            world
+          end
+
+          if ruby_command =~ /^[A-Z0-9]|::/
+            puts "Evaluating #{ruby_command.inspect} globally" if ENV["DEBUG"]
+            ruby_result = eval ruby_command
+          else
+            ruby_command = "self.#{ruby_command}"
+            puts "Evaluating #{ruby_command.inspect} on #{obj.inspect}" if ENV["DEBUG"]
+            ruby_result = obj.instance_eval ruby_command
+          end
+        rescue Exception => ex
+          ruby_result = <<-EOT.gsub(/^\s*\S/, '')
+            |Failed processing ruby: #{ruby_command}
+            |#{ex}
+            |#{ex.backtrace.join("\n")}
+          EOT
+          exit_code = 1
+        ensure
+          f.close if f && !f.closed?
+        end
+
+        # The next line  causes issues sometimes?
+        # puts "WRITING #{ruby_result.length} bytes" if ENV["DEBUG"]
+        ruby_result = ruby_result.to_s
+        ruby_result << "\n" unless ruby_result.end_with?("\n")
+
+        stdout.write ruby_result
+        stdout.flush
+        stderr.flush
+
+        stdout.close if stdout != $stdout && !stdout.closed?
+        stderr.close if stderr != $stderr && !stderr.closed?
+
+        # Pass current execution to give any other threads a chance
+        # 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
+
+        # 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
+      result
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Yap::Shell::Execution
+  class ShellCommandExecution < CommandExecution
+    on_execute do |command:, n:, of:|
+      func = command.to_proc
+      command_result = func.call(args:command.args, stdin:@stdin, stdout:@stdout, stderr:@stderr)
+      @stdout.close if @stdout != $stdout && !@stdout.closed?
+      @stderr.close if @stderr != $stderr && !@stderr.closed?
+    end
+  end
+end

data/lib/yap/shell/repl.rb

@@ -0,0 +1,63 @@
+require 'readline'
+
+module Yap::Shell
+  class Repl
+    def initialize(world:nil)
+      @world = world
+    end
+
+    def loop_on_input(&blk)
+      @blk = blk
+
+      loop do
+        heredoc = nil
+        prompt = ""
+
+        begin
+          prompt = @world ? @world.prompt : "> "
+          input = Readline.readline("#{prompt}", true)
+
+          next if input == ""
+
+          input = process_heredoc(input)
+
+          yield input
+        rescue ::Yap::Shell::CommandUnknownError => ex
+          puts "  CommandError: #{ex.message}"
+        rescue Interrupt
+          puts "^C"
+          next
+        rescue SuspendSignalError
+          # no-op since if we got here we're on the already at the top-level
+          # repl and there's nothing to suspend but ourself and we're not
+          # about to do that.
+          puts "^Z"
+          next
+        end
+      end
+    end
+
+    private
+
+    def process_heredoc(_input)
+      if _input =~ /<<-?([A-z0-9\-]+)\s*$/
+        input = _input.dup
+        marker = $1
+        input << "\n"
+      else
+        return _input
+      end
+
+      puts "Beginning heredoc" if ENV["DEBUG"]
+      loop do
+        str = Readline.readline("> ", true)
+        input << "#{str}\n"
+        if str =~ /^#{Regexp.escape(marker)}$/
+          puts "Ending heredoc" if ENV["DEBUG"]
+          break
+        end
+      end
+      input
+    end
+  end
+end

data/lib/yap/shell/version.rb

@@ -0,0 +1,5 @@
+module Yap
+  module Shell
+    VERSION = "0.0.2"
+  end
+end

data/lib/yap/world.rb

@@ -0,0 +1,43 @@
+require 'term/ansicolor'
+require 'forwardable'
+
+module Yap
+  class World
+    include Term::ANSIColor
+    extend Forwardable
+
+    attr_accessor :prompt, :contents, :addons
+
+    def initialize(options)
+      (options || {}).each do |k,v|
+        self.send "#{k}=", v
+      end
+
+      addons.each do |addon|
+        self.instance_eval addon
+      end
+    end
+
+    def func(name, &blk)
+      Yap::Shell::ShellCommand.define_shell_function(name, &blk)
+    end
+
+    def readline
+      ::Readline
+    end
+
+    def prompt
+      if @prompt.respond_to? :call
+        @prompt.call
+      else
+        @prompt
+      end
+    end
+
+    (String.instance_methods - Object.instance_methods).each do |m|
+      next if [:object_id, :__send__, :initialize].include?(m)
+      def_delegator :@contents, m
+    end
+
+  end
+end