yap-shell 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c9ea62ec24c22dea32da508a7616ddcb03eedbe
-  data.tar.gz: 19cb2c35c5806d94653782b5d5e06655bc734676
+  metadata.gz: e4b50596222f441b63d4b4db6a74b34cdcdee1e7
+  data.tar.gz: 2d0095e8845196cb5b6fa0a6c44b5783f8b2849e
 SHA512:
-  metadata.gz: 496c9bd377d0e6fa56cd785d7efc751882af5c606690bfaaa1b08590c6bcd8f41ac7bdabaf1a51b21cb945d1c3ad709374a59c2c882b369e6baf23b1f6556f7d
-  data.tar.gz: 31c37db8f24ef5be951a7bd4ed6c36675ded870f9af6328d62e5a6b7af34f6d7265a99be063b44d50327f4a506fba31108d68794aa72372941ff2f1bf196f538
+  metadata.gz: 64733efa5a216775d9c26ab3fe99b48270bf1edb7a80ebe5a2f898906085cd8f127a6c1ca141004890be5fcd8a895119f0bad8ed0856f4d9a4dceb43708a663b
+  data.tar.gz: f280c566e9e15cc692d77094a2659983b6dd9cf6433cdd26fe0cf0fe7b4d2d7107845885b080c4548411b82ffe195e4e462f691be165fa8e5271ac2e5a68ff39

data/addons/history.rb

@@ -0,0 +1,171 @@
+require 'forwardable'
+module Yap
+  module WorldAddons
+    class History
+      def self.load
+        instance
+      end
+
+      def self.instance
+        @history ||= History.new
+      end
+
+      def initialize
+        @history = []
+      end
+
+      def initialize_world(world)
+        load_history
+
+        world.func(:howmuch) do |args:, stdin:, stdout:, stderr:|
+          case args.first
+          when "time"
+            if history_item=self.last_executed_item
+              stdout.puts history_item.total_time_s
+            else
+              stdout.puts "Can't report on something you haven't done."
+            end
+          else
+            stdout.puts "How much what?"
+          end
+        end
+      end
+
+      def executing(command:, started_at:)
+        raise "Cannot acknowledge execution beginning of a command when no group has been started!" unless @history.last
+        @history.last.executing command:command, started_at:started_at
+      end
+
+      def executed(command:, stopped_at:)
+        raise "Cannot complete execution of a command when no group has been started!" unless @history.last
+        @history.last.executed command:command, stopped_at:stopped_at
+      end
+
+      def last_executed_item
+        @history.reverse.each do |group|
+          last_run = group.last_executed_item
+          break last_run if last_run
+        end
+      end
+
+      def start_group(started_at)
+        @history.push Group.new(started_at:started_at)
+      end
+
+      def stop_group(stopped_at)
+        @history.last.stopped_at(stopped_at)
+      end
+
+      private
+
+      def history_file
+        @history_file ||= File.expand_path('~') + '/.yap-history'
+      end
+
+      def load_history
+        return unless File.exists?(history_file) && File.readable?(history_file)
+        (YAML.load_file(history_file) || []).each do |item|
+          ::Readline::HISTORY.push item
+        end
+
+        at_exit do
+          File.write history_file, ::Readline::HISTORY.to_a.to_yaml
+        end
+      end
+
+      class Group
+        extend Forwardable
+
+        def initialize(started_at:Time.now)
+          @started_at = started_at
+          @stopped_at = nil
+          @items = []
+        end
+
+        def_delegators :@items, :push, :<<, :pop, :first, :last
+
+        def duration
+          return nil unless @stopped_at
+          @stopped_at - @started_at
+        end
+
+        def executing(command:, started_at:)
+          @items.push Item.new(command:command, started_at:started_at)
+        end
+
+        def executed(command:, stopped_at:)
+          raise "2:Cannot complete execution of a command when no group has been started!" unless @items.last
+          item = @items.reverse.detect do |item|
+            command == item.command && !item.finished?
+          end
+          item.finished!(stopped_at)
+        end
+
+        def last_executed_item
+          @items.reverse.detect{ |item| item.finished? }
+        end
+
+        def stopped_at(time)
+          @stopped_at ||= time
+        end
+      end
+
+      class Item
+        attr_reader :command
+
+        def initialize(command:command, started_at:Time.now)
+          @command = command
+          @started_at = started_at
+          @ended_at = nil
+        end
+
+        def finished!(at)
+          @ended_at = at
+        end
+
+        def finished?
+          !!@ended_at
+        end
+
+        def total_time_s
+          humanize(@ended_at - @started_at) if @ended_at && @started_at
+        end
+
+        private
+
+        def humanize secs
+          [[60, :seconds], [60, :minutes], [24, :hours], [1000, :days]].inject([]){ |s, (count, name)|
+            if secs > 0
+              secs, n = secs.divmod(count)
+              s.unshift "#{n} #{name}"
+            end
+            s
+          }.join(' ')
+        end
+      end
+
+      Yap::Shell::Execution::Context.on(:before_statements_execute) do |context|
+        puts "Before group: #{context.to_s}" if ENV["DEBUG"]
+        History.instance.start_group(Time.now)
+      end
+
+      Yap::Shell::Execution::Context.on(:after_statements_execute) do |context|
+        History.instance.stop_group(Time.now)
+        puts "After group: #{context.to_s}" if ENV["DEBUG"]
+      end
+
+      Yap::Shell::Execution::Context.on(:after_process_finished) do |context, *args|
+        # puts "After process: #{context.to_s}, args: #{args.inspect}"
+      end
+
+      Yap::Shell::Execution::Context.on(:before_execute) do |context, command:|
+        History.instance.executing command:command.str, started_at:Time.now
+      end
+
+      Yap::Shell::Execution::Context.on(:after_execute) do |context, command:, result:|
+        History.instance.executed command:command.str, stopped_at:Time.now
+      end
+
+    end
+  end
+end

data/bin/yap

@@ -1,24 +1,20 @@
 #!/usr/bin/env ruby
+
 file = __FILE__
 if File.symlink?(file)
   file = File.readlink(file)
 end
 
-class SuspendSignalError < StandardError
-end
+trap "SIGTSTP", "IGNORE"
+trap "SIGINT", "IGNORE"
+trap "SIGTTIN", "IGNORE"
+trap "SIGTTOU", "IGNORE"
 
-trap("SIGTSTP") do
-  raise SuspendSignalError
-end
+ENV["PATH"] = "/Applications/Postgres.app/Contents/MacOS/bin:/usr/local/share/npm/bin/:/usr/local/heroku/bin:/Users/zdennis/.bin:/Users/zdennis/.rvm/gems/ruby-2.1.5/bin:/Users/zdennis/.rvm/gems/ruby-2.1.5@global/bin:/Users/zdennis/.rvm/rubies/ruby-2.1.5/bin:/usr/local/bin:/usr/local/sbin:/Users/zdennis/bin:/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/CrossPack-AVR/bin:/private/tmp/.tidbits/bin:/Users/zdennis/source/playground/AdobeAir/AdobeAIRSDK/bin:/Users/zdennis/.rvm/bin:/Users/zdennis/Downloads/adt-bundle-mac-x86_64-20130219/sdk/tools/:/Users/zdennis/.rvm/bin"
+ENV["GEM_HOME"] = "/Users/zdennis/.rvm/gems/ruby-2.1.5:/Users/zdennis/.rvm/gems/ruby-2.1.5@global"
+ENV["GEM_PATH"] = "/Users/zdennis/.rvm/gems/ruby-2.1.5"
 
 $LOAD_PATH << File.dirname(file) + '/../lib'
 
-# loop do
-  load "yap.rb"
-  begin
-    Yap.run_shell
-  rescue StandardError => ex
-    puts ex.message
-    puts ex.backtrace
-  end
-# end
+require "yap"
+Yap.run_shell

data/lib/tasks/gem.rake

@@ -15,11 +15,13 @@ namespace :bump do
           _major = major.call($1) if major
           _minor = minor.call($2) if minor
           _patch = patch.call($3) if patch
-          version = %|VERSION = "#{_major}.#{_minor}.#{_patch}"|
+          version = "#{_major}.#{_minor}.#{_patch}"
+          results = %|VERSION = "#{version}"|
         end
         File.write(@file, contents)
         system "bundle"
-        system "git add #{ProjectVersion::FILE}\ && git commit -m 'Bumping version to #{version}'"
+        system "git add #{ProjectVersion::FILE} && git commit -m 'Bumping version to #{version}'"
+        system "git tag v#{version}"
       end
 
       private

data/lib/yap.rb

@@ -14,17 +14,50 @@ module Yap
         (puts "Cannot load world addon: #{file} is not readable" and next) unless File.exist?(file)
         (puts "Cannot load world addon: #{file} is a directory file" and next) if File.directory?(file)
 
-        # Module.new.tap { |m| m.module_eval IO.read(file) }
-        IO.read(file)
+        addon = file.end_with?("rc") ? load_rcfile(file) : load_addon_file(file)
+        addon.load
+      end
+    end
+
+    class RcFile
+      def initialize(contents)
+        @contents = contents
+      end
+
+      def load
+        self
+      end
+
+      def initialize_world(world)
+        world.instance_eval @contents
       end
     end
-  end
 
+    def self.load_rcfile(file)
+      RcFile.new IO.read(file)
+    end
+
+    def self.load_addon_file(file)
+      name = File.basename(file).sub(/\.[^\.]+$/, "").split(/[_]/).map(&:capitalize).join
+      klass_name = "Yap::WorldAddons::#{name}"
+
+      load file
+
+      if Yap::WorldAddons.const_defined?(name)
+        Yap::WorldAddons.const_get(name)
+      else
+        raise("Did not find #{klass_name} in #{file}")
+      end
+    end
+  end
 
   def self.run_shell
-    addons = WorldAddons.load_from_files(files: [
-      "#{ENV['HOME']}/.yaprc"
-    ])
+    addon_files = Dir[
+      "#{ENV['HOME']}/.yaprc",
+      "#{ENV['HOME']}/.yap-addons/*.rb"
+    ]
+
+    addons = WorldAddons.load_from_files(files:addon_files)
     Shell::Impl.new(addons: addons).repl
   end
 end

data/lib/yap/shell.rb

@@ -51,22 +51,6 @@ module Yap
         end
       end
 
-      private
-
-      def history_file
-        File.expand_path('~') + '/.yap-history'
-      end
-
-      def load_history
-        return unless File.exists?(history_file) && File.readable?(history_file)
-        (YAML.load_file(history_file) || []).each do |item|
-          ::Readline::HISTORY.push item
-        end
-
-        at_exit do
-          File.write history_file, ::Readline::HISTORY.to_a.to_yaml
-        end
-      end
     end
 
   end

data/lib/yap/shell/builtins.rb

@@ -6,9 +6,9 @@ module Yap::Shell
       Yap::Shell::BuiltinCommand.add(name, &blk)
     end
 
-    def self.execute_builtin(name, *args)
-      builtin = Yap::Shell::BuiltinCommand.builtins.fetch(name){ raise("Builtin #{name} not found") }
-      builtin.call *args
+    def self.execute_builtin(name, args:, stdin:, stdout:, stderr:)
+      command = Yap::Shell::BuiltinCommand.new(str:name, args: args)
+      command.execute(stdin:stdin, stdout:stdout, stderr:stderr)
     end
 
     Dir[File.dirname(__FILE__) + "/builtins/**/*.rb"].each do |f|

data/lib/yap/shell/builtins/cd.rb

@@ -3,35 +3,57 @@ module Yap::Shell
     DIRECTORY_HISTORY = []
     DIRECTORY_FUTURE  = []
 
-    builtin :cd do |path=ENV['HOME'], *_|
-      DIRECTORY_HISTORY << Dir.pwd
-      Dir.chdir(path)
-      ENV["PWD"] = Dir.pwd
-      output=""
+    builtin :cd do |args:, stderr:, **|
+      path = args.first || ENV['HOME']
+      cwd = Dir.pwd
+      if Dir.exist?(path)
+        DIRECTORY_HISTORY << cwd
+        Dir.chdir(path)
+        ENV["PWD"] = cwd
+        exit_status = 0
+      else
+        stderr.puts "cd: #{path}: No such file or directory"
+        exit_status = 1
+      end
     end
 
-    builtin :popd do
+    builtin :popd do |args:, stderr:, **keyword_args|
       output = []
+      cwd = Dir.pwd
       if DIRECTORY_HISTORY.any?
-        DIRECTORY_FUTURE << Dir.pwd
         path = DIRECTORY_HISTORY.pop
-        execute_builtin :cd, path
+        if Dir.exist?(path)
+          DIRECTORY_FUTURE << cwd
+          Dir.chdir(path)
+          ENV["PWD"] =cwd
+          exit_status = 0
+        else
+          stderr.puts "popd: #{path}: No such file or directory"
+          exit_status = 1
+        end
       else
-        output << "popd: directory stack empty\n"
+        stderr.puts "popd: directory stack empty"
+        exit_status = 1
       end
-      output.join("\n")
     end
 
-    builtin :pushd do
+    builtin :pushd do |args:, stderr:, **keyword_args|
       output = []
       if DIRECTORY_FUTURE.any?
-        DIRECTORY_HISTORY << Dir.pwd
         path = DIRECTORY_FUTURE.pop
-        execute_builtin :cd, path
+        if Dir.exist?(path)
+          DIRECTORY_HISTORY << Dir.pwd
+          Dir.chdir(path)
+          ENV["PWD"] = path
+          exit_status = 0
+        else
+          stderr.puts "pushd: #{path}: No such file or directory"
+          exit_status = 1
+        end
       else
-        output << "pushd: there are no directories in your future\n"
+        stderr.puts "pushd: there are no directories in your future"
+        exit_status = 1
       end
-      output.join("\n")
     end
   end
 end

data/lib/yap/shell/commands.rb

@@ -1,5 +1,6 @@
 require 'shellwords'
 require 'yap/shell/aliases'
+require 'yap/shell/execution/result'
 
 module Yap::Shell
   class CommandError < StandardError ; end
@@ -41,9 +42,9 @@ module Yap::Shell
 
     def self.builtins
       @builtins ||= {
-        builtins: lambda { puts @builtins.keys.sort },
-        exit: lambda { |code = 0| exit(code.to_i) },
-        fg: lambda{ :resume },
+        builtins: lambda { |stdout:, **| stdout.puts @builtins.keys.sort },
+        exit: lambda { |code = 0, **| exit(code.to_i) },
+        fg: lambda{ |**| :resume },
       }
     end
 
@@ -51,9 +52,9 @@ module Yap::Shell
       builtins.merge!(command.to_sym => action)
     end
 
-    def execute
+    def execute(stdin:, stdout:, stderr:)
       action = self.class.builtins.fetch(str.to_sym){ raise("Missing proc for builtin: '#{builtin}' in #{str.inspect}") }
-      action.call *args
+      action.call args:args, stdin:stdin, stdout:stdout, stderr:stderr
     end
 
     def type

data/lib/yap/shell/evaluation.rb

@@ -11,12 +11,33 @@ module Yap::Shell
 
     def evaluate(input, &blk)
       @blk = blk
+      parser = Yap::Shell::Parser.new
+      input = recursively_find_and_replace_command_substitutions(parser, input)
       ast = Yap::Shell::Parser.new.parse(input)
       ast.accept(self)
     end
 
     private
 
+    # +recursively_find_and_replace_command_substitutions+ is responsible for recursively
+    # finding and expanding command substitutions, in a depth first manner.
+    def recursively_find_and_replace_command_substitutions(parser, input)
+      input = input.dup
+      parser.each_command_substitution_for(input) do |substitution_result, start_position, end_position|
+        result = recursively_find_and_replace_command_substitutions(parser, substitution_result.str)
+        position = substitution_result.position
+        ast = parser.parse(result)
+        with_standard_streams do |stdin, stdout, stderr|
+          r,w = IO.pipe
+          @stdout = w
+          ast.accept(self)
+          input[position.min...position.max] = r.read.chomp
+        end
+      end
+      input
+    end
+
+
     ######################################################################
     #                                                                    #
     #               VISITOR METHODS FOR AST TREE WALKING                 #
@@ -26,9 +47,10 @@ module Yap::Shell
     def visit_CommandNode(node)
       @aliases_expanded ||= []
       with_standard_streams do |stdin, stdout, stderr|
+        args = node.args.map(&:lvalue)
         if !node.literal? && !@aliases_expanded.include?(node.command) && _alias=Aliases.instance.fetch_alias(node.command)
           @suppress_events = true
-          ast = Yap::Shell::Parser.new.parse([_alias].concat(node.args).join(" "))
+          ast = Yap::Shell::Parser.new.parse([_alias].concat(args).join(" "))
           @aliases_expanded.push(node.command)
           ast.accept(self)
           @aliases_expanded.pop
@@ -36,7 +58,7 @@ module Yap::Shell
         else
           command = CommandFactory.build_command_for(
             command: node.command,
-            args:    shell_expand(node.args),
+            args:    shell_expand(args),
             heredoc: node.heredoc,
             internally_evaluate: node.internally_evaluate?)
           @stdin, @stdout, @stderr = stream_redirections_for(node)
@@ -94,7 +116,6 @@ module Yap::Shell
       with_standard_streams do |stdin, stdout, stderr|
         # Modify @stdout and @stderr for the first command
         stdin, @stdout = IO.pipe
-        @stderr = @stdout
 
         # Don't modify @stdin for the first command in the pipeline.
         node.head.accept(self)

data/lib/yap/shell/execution.rb

@@ -1,15 +1,13 @@
+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"
+
 module Yap::Shell
   module Execution
-    autoload :Context,                    "yap/shell/execution/context"
-
-    autoload :CommandExecution,           "yap/shell/execution/command_execution"
-    autoload :BuiltinCommandExecution,    "yap/shell/execution/builtin_command_execution"
-    autoload :FileSystemCommandExecution, "yap/shell/execution/file_system_command_execution"
-    autoload :RubyCommandExecution,       "yap/shell/execution/ruby_command_execution"
-    autoload :ShellCommandExecution,      "yap/shell/execution/shell_command_execution"
-
-    autoload :Result,                     "yap/shell/execution/result"
-
     Context.register BuiltinCommandExecution,    command_type: :BuiltinCommand
     Context.register FileSystemCommandExecution, command_type: :FileSystemCommand
     Context.register ShellCommandExecution,      command_type: :ShellCommand

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

@@ -1,14 +1,15 @@
+require 'yap/shell/execution/result'
+
 module Yap::Shell::Execution
   class BuiltinCommandExecution < CommandExecution
     on_execute do |command:, n:, of:|
-      command_output = command.execute
-      if command_output == :resume
+      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)
       else
-        @stdout.write command_output
         @stdout.close if @stdout != $stdout && !@stdout.closed?
         @stderr.close if @stderr != $stderr && !@stderr.closed?
-        Result.new(status_code:0, directory:Dir.pwd, n:n, of:of)
+        Result.new(status_code:status_code, directory:Dir.pwd, n:n, of:of)
       end
     end
   end

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

@@ -57,26 +57,13 @@ module Yap::Shell::Execution
             world:  world
           )
 
+          @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
 
-          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
+          results << process_execution_result(execution_context:execution_context, result: result)
+          Termios.tcsetattr(STDIN, Termios::TCSANOW, @saved_tty_attrs)
         end
       end
 
@@ -84,5 +71,26 @@ module Yap::Shell::Execution
 
       results.last
     end
+
+    private
+
+    def process_execution_result(execution_context:, result:)
+      case result
+      when SuspendExecution
+        @suspended_execution_contexts.push execution_context
+        return result
+
+      when ResumeExecution
+        execution_context = @suspended_execution_contexts.pop
+        if execution_context
+          nresult = execution_context.resume
+          return process_execution_result execution_context: execution_context, result: nresult
+        else
+          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,79 +1,93 @@
+require 'yap/shell/execution/result'
+require 'termios'
+
 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
+      if resume_blk
+        pid = resume_blk.call
+      else
+        r,w = nil, nil
+        if command.heredoc
+          r,w = IO.pipe
+          stdin = r
         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
+        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
+
+          # Start a new process group 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)
 
-        Process.waitpid(pid) unless of > 1
-        Signal.trap("SIGINT", "DEFAULT")
+          stdout = stderr if stdout == :stderr
+          stderr = stdout if stderr == :stdout
 
-        # 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
+          $stdin.reopen stdin
+          $stdout.reopen stdout
+          $stderr.reopen stderr
+
+          Kernel.exec command.to_executable_str
         end
-        if stderr != $stderr && stderr.is_a?(IO) && !stderr.closed? then
-          stderr.close
+
+        # Put the child process into a process group of its own
+        Process.setpgid pid, pid
+
+        if command.heredoc
+          w.write command.heredoc
+          w.close
         end
-        # if stdin != $stdin && !stdin.closed? then stdin.close end
+      end
 
-      rescue Interrupt
-        Process.kill "SIGINT", pid
+      # 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"]
 
-      rescue SuspendSignalError => ex
-        Process.kill "SIGSTOP", pid
+      # 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
 
-        # 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)
+      # 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 pid == Termios.tcgetpgrp(STDIN)
+        Process.setpgid Process.pid, Process.pid
+        Termios.tcsetpgrp STDIN, Process.pid
       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)
+      # if the reason we stopped is from being suspended
+      if 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)
+      else
+        puts "Process (#{pid}) not suspended? #{status.stopsig}" if ENV["DEBUG"]
+        # 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

data/lib/yap/shell/repl.rb

@@ -27,12 +27,6 @@ module Yap::Shell
         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

data/lib/yap/shell/version.rb

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

data/lib/yap/world.rb

@@ -1,5 +1,6 @@
 require 'term/ansicolor'
 require 'forwardable'
+require 'yap/shell/execution'
 
 module Yap
   class World
@@ -14,7 +15,7 @@ module Yap
       end
 
       addons.each do |addon|
-        self.instance_eval addon
+        addon.initialize_world(self)
       end
     end
 

data/rcfiles/.yaprc

@@ -1,7 +1,10 @@
 #!/usr/bin/ruby
 
-require 'chronic'
-require 'term/ansicolor'
+ENV["PATH"] = "/Applications/Postgres.app/Contents/MacOS/bin:/usr/local/share/npm/bin/:/usr/local/heroku/bin:/Users/zdennis/.bin:/Users/zdennis/.rvm/gems/ruby-2.1.5/bin:/Users/zdennis/.rvm/gems/ruby-2.1.5@global/bin:/Users/zdennis/.rvm/rubies/ruby-2.1.5/bin:/usr/local/bin:/usr/local/sbin:/Users/zdennis/bin:/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/usr/local/CrossPack-AVR/bin:/private/tmp/.tidbits/bin:/Users/zdennis/source/playground/AdobeAir/AdobeAIRSDK/bin:/Users/zdennis/.rvm/bin:/Users/zdennis/Downloads/adt-bundle-mac-x86_64-20130219/sdk/tools/:/Users/zdennis/.rvm/bin"
+ENV["GEM_HOME"] = "/Users/zdennis/.rvm/gems/ruby-2.1.5:/Users/zdennis/.rvm/gems/ruby-2.1.5@global"
+
+# require 'chronic'
+# require 'term/ansicolor'
 
 #
 # Configuring your prompt. This can be set to a static value or to a
@@ -33,151 +36,8 @@ self.prompt = -> do
   "#{dark(green('£'))} #{yellow(pwd)} #{git_branch}#{red(arrow)} "
 end
 
-func :howmuch do |args:, stdin:, stdout:, stderr:|
-  case args.first
-  when "time"
-    if history_item=CommandHistory.last_run_command
-      stdout.puts history_item.total_time_s
-    else
-      stdout.puts "Can't report on something you haven't done."
-    end
-  else
-    stdout.puts "How much what?"
-  end
-end
 
 func :upcase do |args:, stdin:, stdout:, stderr:|
   str = stdin.read
   stdout.puts str.upcase
 end
-
-class CommandHistoryImplementation
-  def initialize
-    @history = []
-  end
-
-  def start_group(time)
-    @group = Group.new(started_at:time)
-    @history.push @group
-  end
-
-  def stop_group(time)
-    @group.stopped_at(time)
-  end
-
-  def push(item)
-    @group.add_item item
-  end
-
-  def last_group
-    @history.last
-  end
-
-  def last_command
-    return @history.last.last_item if @history.last
-    nil
-  end
-
-  def last_run_command
-    @history.reverse.each do |group|
-      last_run = group.items.reverse.detect{ |item| item.finished? }
-      break last_run if last_run
-    end
-  end
-
-  class Group
-    def initialize(started_at:Time.now)
-      @started_at = started_at
-      @items = []
-    end
-
-    def add_item(item)
-      @items.push item
-    end
-
-    def items
-      @items
-    end
-
-    def last_item
-      @items.last
-    end
-
-    def stopped_at(time)
-      @stopped_at ||= time
-    end
-
-    def duration
-      return nil unless @stopped_at
-      @stopped_at - @started_at
-    end
-  end
-
-  class Item
-    def initialize(command_str:command_str, started_at:Time.now)
-      @command_str = command_str
-      @started_at = started_at
-      @ended_at = nil
-    end
-
-    def finished!
-      @ended_at = Time.now
-    end
-
-    def finished?
-      !!@ended_at
-    end
-
-    def total_time_s
-      humanize(@ended_at - @started_at) if @ended_at && @started_at
-    end
-
-    private
-
-    def humanize secs
-      [[60, :seconds], [60, :minutes], [24, :hours], [1000, :days]].inject([]){ |s, (count, name)|
-        if secs > 0
-          secs, n = secs.divmod(count)
-          s.unshift "#{n} #{name}"
-        end
-        s
-      }.join(' ')
-    end
-  end
-
-end
-
-CommandHistory = CommandHistoryImplementation.new
-
-Yap::Shell::Execution::Context.on(:before_statements_execute) do |context|
-  puts "Before group: #{context.to_s}" if ENV["DEBUG"]
-  CommandHistory.start_group(Time.now)
-end
-
-Yap::Shell::Execution::Context.on(:after_statements_execute) do |context|
-  CommandHistory.stop_group(Time.now)
-  puts "After group: #{context.to_s}" if ENV["DEBUG"]
-end
-
-Yap::Shell::Execution::Context.on(:after_process_finished) do |context, *args|
-  # puts "After process: #{context.to_s}, args: #{args.inspect}"
-end
-
-Yap::Shell::Execution::Context.on(:before_execute) do |context, command:|
-  CommandHistory.push CommandHistoryImplementation::Item.new(command_str: command.str, started_at: Time.now)
-end
-
-Yap::Shell::Execution::Context.on(:after_execute) do |context, command:, result:|
-  CommandHistory.last_command.finished!
-  # if result.status_code == 0
-  #   # t = TermInfo.new("xterm-color", STDOUT)
-  #   # h, w = t.screen_size
-  #   # t.control "cub", w
-  #   # # msg =
-  #   # t.control "cuf"
-  #   # # t.control "home"
-  #   #
-  #   # # t.write "hi"
-  #   # # t.control "rc"
-  # end
-end

data/scripts/4

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+1000.times do
+  ("A".."z").each do |letter|
+    puts letter
+    sleep 2
+  end
+end

data/scripts/bg-vim

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+sleep 5
+vim < /dev/tty

data/scripts/fail

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exit 1

data/scripts/letters

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+1000.times do
+  ("A".."z").each do |letter|
+    puts letter
+    sleep 2
+  end
+end

data/scripts/lots-of-output

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+1000.times do |i|
+  puts i
+  sleep 2
+end

data/scripts/pass

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exit 0

data/scripts/simulate-long-running

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+sleep 1000
+echo "Done"

data/scripts/write-to-stderr.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+STDERR.puts "this is an error"

data/scripts/write-to-stdout.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+STDOUT.puts "This is stdout"

data/yap-shell.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "yap-shell-parser", "~> 0.0.2"
+  spec.add_dependency "yap-shell-parser", "~> 0.1.0"
   spec.add_dependency "term-ansicolor", "~> 1.3"
   spec.add_dependency "chronic", "~> 0.10"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yap-shell
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Zach Dennis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-02 00:00:00.000000000 Z
+date: 2015-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yap-shell-parser
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: term-ansicolor
   requirement: !ruby/object:Gem::Requirement
@@ -95,6 +95,7 @@ files:
 - README.md
 - Rakefile
 - WISHLIST.md
+- addons/history.rb
 - bin/yap
 - lib/tasks/gem.rake
 - lib/yap.rb
@@ -117,6 +118,15 @@ files:
 - lib/yap/shell/version.rb
 - lib/yap/world.rb
 - rcfiles/.yaprc
+- scripts/4
+- scripts/bg-vim
+- scripts/fail
+- scripts/letters
+- scripts/lots-of-output
+- scripts/pass
+- scripts/simulate-long-running
+- scripts/write-to-stderr.rb
+- scripts/write-to-stdout.rb
 - yap-shell.gemspec
 homepage: https://github.com/zdennis/yap-shell
 licenses: