yap-shell 0.4.0 → 0.4.1

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

@@ -9,24 +9,30 @@ module Yap::Shell
       end
 
       def expand_aliases_in(input)
+        Treefell['shell'].puts "shell-expansions expand aliases in: #{input.inspect}"
         head, *tail = input.split(/\s/, 2).first
-        if new_head=aliases.fetch_alias(head)
+        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)
-        [input].flatten.inject([]) do |results,str|
+        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
 
@@ -35,11 +41,16 @@ module Yap::Shell
       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'
+          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
-            world.env.fetch(var_name){ match }
+            match
           end
         end
       end
@@ -53,10 +64,13 @@ module Yap::Shell
           # 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) }
+            expanded = expansions.map { |expansion| str.sub(/\{([^\}]+)\}/, expansion) }.tap do |expanded|
+              Treefell['shell'].puts "shell-expansions expanding words in #{str} to #{expanded}"
+            end
+            return expanded
           end
         end
-        return [str]
+        [str]
       end
 
       def process_expansions(expansions, escape_directory_expansions: true)

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

@@ -3,13 +3,17 @@ module Yap::Shell::Execution
 
   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)
+        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

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

@@ -60,12 +60,15 @@ module Yap::Shell::Execution
           )
 
           @saved_tty_attrs = Termios.tcgetattr(STDIN)
+          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
@@ -83,6 +86,7 @@ module Yap::Shell::Execution
             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)
@@ -100,15 +104,19 @@ module Yap::Shell::Execution
     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

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

@@ -49,11 +49,13 @@ module Yap::Shell::Execution
             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
@@ -67,9 +69,11 @@ module Yap::Shell::Execution
       # 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
@@ -79,17 +83,24 @@ module Yap::Shell::Execution
       # give it back to the us so we can become the foreground process
       # in the terminal
       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
 
       # if the reason we stopped is from being suspended
-      if status && status.stopsig == Signal.list["TSTP"]
-        puts "Process (#{pid}) suspended: #{status.stopsig}" if ENV["DEBUG"]
+      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
-        puts "Process (#{pid}) not suspended? #{status.stopsig}" if ENV["DEBUG"]
+        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)
@@ -99,18 +110,20 @@ module Yap::Shell::Execution
     def resume
       args = @suspended
       @suspended = nil
+      pid = args[:pid]
+      sigcont = Signal.list["CONT"]
 
-      puts "Resuming: #{args[:pid]}" if ENV["DEBUG"]
+      Treefell['shell'].puts "resuming suspended process pid=#{pid} by sending it signal=#{sigcont}"
       resume_blk = lambda do
-        Process.kill "SIGCONT", args[:pid]
-        args[:pid]
+        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:)
-      puts "Suspending: #{pid}" if ENV["DEBUG"]
+      Treefell['shell'].puts "process pid=#{pid} suspended"
       @suspended = {
         command: command,
         n: n,

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

@@ -3,83 +3,78 @@ module Yap::Shell::Execution
     on_execute do |command:, n:, of:, wait:|
       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
+      exit_code = 0
+      first_command = n == 1
 
-          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
+      f = nil
+      ruby_result = nil
+      begin
+        ruby_command = command.to_executable_str
 
-          puts "READ: #{contents.length} bytes from #{stdin}" if ENV["DEBUG"] && contents
-          world.contents = contents
+        Treefell['shell'].puts "ruby execution: reading stdin from #{stdin.inspect}"
+        contents = if stdin.is_a?(String)
+          f = File.open stdin
+          f.read
+        elsif stdin != $stdin
+          stdin.read
+        end
+
+        Treefell['shell'].puts "ruby execution: contents=#{contents.inspect}, setting to world.content"
+        world.contents = contents
 
-          method = ruby_command.scan(/^(\w+(?:[!?]|\s*=)?)/).flatten.first.gsub(/\s/, '')
-          puts "method: #{method}" if ENV["DEBUG"]
+        method = ruby_command.scan(/^(\w+(?:[!?]|\s*=)?)/).flatten.first.gsub(/\s/, '')
+        Treefell['shell'].puts "ruby execution: method=#{method.inspect}"
 
-          obj = if first_command
-            world
-          elsif contents.respond_to?(method)
-            contents
-          else
-            world
-          end
+        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?
+        if ruby_command =~ /^[A-Z0-9]|::/
+          Treefell['shell'].puts "ruby executing: eval(#{ruby_command.inspect})"
+          ruby_result = eval ruby_command
+        else
+          ruby_command = "self.#{ruby_command}"
+          Treefell['shell'].puts "ruby executing: #{obj.class.name} instance instance_eval(#{ruby_command.inspect})"
+          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")
+      # 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.write ruby_result
+      stdout.flush
+      stderr.flush
 
-        stdout.close if stdout != $stdout && !stdout.closed?
-        stderr.close if stderr != $stderr && !stderr.closed?
+      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
+      # 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
+      # Make up an exit code
+      Result.new(status_code:exit_code, directory:Dir.pwd, n:n, of:of).tap do |result|
+        Treefell['shell'].puts "ruby execution done with result=#{result.inspect}"
+      end
     end
   end
 end

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

@@ -1,6 +1,8 @@
 module Yap::Shell::Execution
   class ShellCommandExecution < CommandExecution
     on_execute do |command:, n:, of:, wait:|
+      Treefell['shell'].puts "shell command execution: #{command}"
+
       possible_parameters = {
         command: command.str,
         args: command.args,
@@ -17,6 +19,7 @@ module Yap::Shell::Execution
         h
       end
 
+      Treefell['shell'].puts "shell command executing with params: #{params.inspect}"
       command_result = func.call(**params)
       @stdout.close if @stdout != $stdout && !@stdout.closed?
       @stderr.close if @stderr != $stderr && !@stderr.closed?

data/lib/yap/shell/repl.rb

@@ -12,7 +12,11 @@ module Yap::Shell
     def initialize(world:nil)
       @world = world
       @editor= world.editor
+
+      Treefell['shell'].puts "installing default keybindings"
       install_default_keybindings
+
+      Treefell['shell'].puts "installing default tab completion"
       install_default_tab_completion_proc
     end
 
@@ -20,17 +24,23 @@ module Yap::Shell
       @blk = blk
 
       @world.editor.on_read_line do |event|
+        line_read = event[:payload][:line]
+        Treefell['shell'].puts "editor line read: #{line_read.inspect}"
         # editor.history = true?
-        line = event[:payload][:line] << "\n"
+        line = line_read << "\n"
         begin
           @blk.call(line)
           @world.editor.redraw_prompt
-        rescue Yap::Shell::Parser::Lexer::NonterminatedString, Yap::Shell::Parser::Lexer::LineContinuationFound
+        rescue Yap::Shell::Parser::Lexer::NonterminatedString,
+          Yap::Shell::Parser::Lexer::LineContinuationFound => ex
+          Treefell['shell'].puts "rescued #{ex}, asking user for more input"
           line << read_another_line_of_input
           retry
         rescue ::Yap::Shell::CommandUnknownError => ex
+          Treefell['shell'].puts "rescued #{ex}, telling user"
           puts "  CommandError: #{ex.message}"
         rescue ::Yap::Shell::Parser::ParseError => ex
+          Treefell['shell'].puts "rescued #{ex}, telling user"
           puts "  Parse error: #{ex.message}"
         ensure
           @world.editor.reset_line
@@ -213,13 +223,12 @@ module Yap::Shell
         return _input
       end
 
-      puts "Beginning heredoc" if ENV["DEBUG"]
-
+      Treefell['shell'].puts "asking for heredoc input with @world.secondary_prompt"
       loop do
         str = editor.read(@world.secondary_prompt.update.text, false)
         input << "#{str}\n"
         if str =~ /^#{Regexp.escape(marker)}$/
-          puts "Ending heredoc" if ENV["DEBUG"]
+          Treefell['shell'].puts "done asking for heredoc input"
           break
         end
       end

data/lib/yap/shell/version.rb

@@ -1,5 +1,5 @@
 module Yap
   module Shell
-    VERSION = "0.4.0"
+    VERSION = "0.4.1"
   end
 end

data/lib/yap/world.rb

@@ -1,4 +1,5 @@
 require 'term/ansicolor'
+require 'fileutils'
 require 'forwardable'
 require 'rawline'
 require 'termios'
@@ -30,6 +31,9 @@ module Yap
       @env = ENV.to_h.dup
       dom = build_editor_dom
 
+      # ensure yap directory exists
+      FileUtils.mkdir_p configuration.yap_path
+
       @editor = RawLine::Editor.create(dom: dom)
 
       self.prompt = Yap::Shell::Prompt.new(text: DEFAULTS[:primary_prompt_text])