yap-shell 0.1.1 → 0.3.0

data/lib/yap.rb

@@ -2,62 +2,11 @@ require 'yap/shell'
 require 'yap/world'
 
 module Yap
-  module WorldAddons
-    def self.syntax_ok?(file)
-      `ruby -c #{file}`
-      $?.exitstatus == 0
-    end
-
-    def self.load_from_files(files:[])
-      files.map do |file|
-        (puts "Cannot load world addon: #{file} does not exist" and next) unless File.exist?(file)
-        (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)
-
-        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
-
-    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
-    addon_files = Dir[
-      "#{ENV['HOME']}/.yaprc",
-      "#{ENV['HOME']}/.yap-addons/*.rb"
-    ]
+    addons = []
+    addons.push World::Addons.load_directories Dir["#{ENV['HOME']}/.yap-addons/*"]
+    addons.push World::Addons.load_rcfiles Dir["#{ENV['HOME']}/.yaprc"]
 
-    addons = WorldAddons.load_from_files(files:addon_files)
-    Shell::Impl.new(addons: addons).repl
+    Shell::Impl.new(addons: addons.flatten).repl
   end
 end

data/lib/yap/shell.rb

@@ -2,6 +2,7 @@ require 'readline'
 require 'yaml'
 require 'yap/shell/version'
 require 'yap/shell/builtins'
+require 'fcntl'
 
 module Yap
   module Shell
@@ -22,6 +23,12 @@ module Yap
 
     class Impl
       def initialize(addons:)
+        @original_file_descriptor_flags = {
+          stdin: $stdin.fcntl(Fcntl::F_GETFL, 0),
+          stdout: $stdout.fcntl(Fcntl::F_GETFL, 0),
+          stderr: $stderr.fcntl(Fcntl::F_GETFL, 0)
+        }
+
         @stdin = $stdin
         @stdout = $stdout
         @stderr = $stderr
@@ -29,29 +36,63 @@ module Yap
         @stdout.sync = true
         @stderr.sync = true
 
-        @addons = addons
+        @world = Yap::World.instance(addons:addons)
+      end
+
+      # Yields to the passed in block after restoring the file descriptor
+      # flags that Yap started in. This ensures that any changes Yap has
+      # made to run the shell don't interfere with child processes.
+      def with_original_file_descriptor_flags(&block)
+        current_file_descriptor_flags = {
+          stdin: $stdin.fcntl(Fcntl::F_GETFL, 0),
+          stdout: $stdout.fcntl(Fcntl::F_GETFL, 0),
+          stderr: $stderr.fcntl(Fcntl::F_GETFL, 0)
+        }
+
+        $stdin.fcntl(Fcntl::F_SETFL, @original_file_descriptor_flags[:stdin])
+        $stdout.fcntl(Fcntl::F_SETFL, @original_file_descriptor_flags[:stdout])
+        $stderr.fcntl(Fcntl::F_SETFL, @original_file_descriptor_flags[:stderr])
+
+        yield
+      ensure
+        $stdin.fcntl(Fcntl::F_SETFL, current_file_descriptor_flags[:stdin])
+        $stdout.fcntl(Fcntl::F_SETFL, current_file_descriptor_flags[:stdout])
+        $stderr.fcntl(Fcntl::F_SETFL, current_file_descriptor_flags[:stderr])
       end
 
       def repl
-        @world = Yap::World.new(addons:@addons)
         context = Yap::Shell::Execution::Context.new(
           stdin:  @stdin,
           stdout: @stdout,
           stderr: @stderr
         )
 
-        @repl = Yap::Shell::Repl.new(world:@world)
-        @repl.loop_on_input do |input|
-          evaluation = Yap::Shell::Evaluation.new(stdin:@stdin, stdout:@stdout, stderr:@stderr)
-          evaluation.evaluate(input) do |command, stdin, stdout, stderr|
+        @world.repl.on_input do |input|
+          evaluation = Yap::Shell::Evaluation.new(stdin:@stdin, stdout:@stdout, stderr:@stderr, world:@world)
+          evaluation.evaluate(input) do |command, stdin, stdout, stderr, wait|
             context.clear_commands
-            context.add_command_to_run command, stdin:stdin, stdout:stdout, stderr:stderr
-            context.execute(world:@world)
+            context.add_command_to_run command, stdin:stdin, stdout:stdout, stderr:stderr, wait:wait
+
+            with_original_file_descriptor_flags do
+              context.execute(world:@world)
+            end
           end
         end
-      end
 
+        begin
+          @world.interactive!
+        # rescue Errno::EIO => ex
+        #   # This happens when yap is no longer the foreground process
+        #   # but it tries to receive input/output from the tty. I believe it
+        #   # is a race condition when launching a child process.
+        rescue Interrupt
+          @world.editor.puts "^C"
+          retry
+        rescue Exception => ex
+          require 'pry'
+          binding.pry unless ex.is_a?(SystemExit)
+        end
+      end
     end
-
   end
 end

data/lib/yap/shell/builtins.rb

@@ -6,8 +6,8 @@ module Yap::Shell
       Yap::Shell::BuiltinCommand.add(name, &blk)
     end
 
-    def self.execute_builtin(name, args:, stdin:, stdout:, stderr:)
-      command = Yap::Shell::BuiltinCommand.new(str:name, args: args)
+    def self.execute_builtin(name, world:, args:, stdin:, stdout:, stderr:)
+      command = Yap::Shell::BuiltinCommand.new(world:world, str:name, args: args)
       command.execute(stdin:stdin, stdout:stdout, stderr:stderr)
     end
 

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

@@ -3,7 +3,7 @@ require 'shellwords'
 
 module Yap::Shell
   module Builtins
-    builtin :alias do |*args|
+    builtin :alias do |args:, stdout:, **kwargs|
       output = []
       if args.empty?
         Yap::Shell::Aliases.instance.to_h.each_pair do |name, value|
@@ -19,7 +19,7 @@ module Yap::Shell
         name, command = name_eq_value.scan(/^(.*?)\s*=\s*(.*)$/).flatten
         Yap::Shell::Aliases.instance.set_alias name, command
       end
-      output.join("\n")
+      stdout.puts output.join("\n")
     end
   end
 end

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

@@ -3,13 +3,12 @@ module Yap::Shell
     DIRECTORY_HISTORY = []
     DIRECTORY_FUTURE  = []
 
-    builtin :cd do |args:, stderr:, **|
-      path = args.first || ENV['HOME']
-      cwd = Dir.pwd
+    builtin :cd do |world:, args:, stderr:, **|
+      path = args.first || world.env['HOME']
       if Dir.exist?(path)
-        DIRECTORY_HISTORY << cwd
+        DIRECTORY_HISTORY << Dir.pwd
+        world.env["PWD"] = File.expand_path(path)
         Dir.chdir(path)
-        ENV["PWD"] = cwd
         exit_status = 0
       else
         stderr.puts "cd: #{path}: No such file or directory"
@@ -17,15 +16,14 @@ module Yap::Shell
       end
     end
 
-    builtin :popd do |args:, stderr:, **keyword_args|
+    builtin :popd do |world:, args:, stderr:, **keyword_args|
       output = []
-      cwd = Dir.pwd
       if DIRECTORY_HISTORY.any?
         path = DIRECTORY_HISTORY.pop
         if Dir.exist?(path)
-          DIRECTORY_FUTURE << cwd
+          DIRECTORY_FUTURE << Dir.pwd
           Dir.chdir(path)
-          ENV["PWD"] =cwd
+          world.env["PWD"] = Dir.pwd
           exit_status = 0
         else
           stderr.puts "popd: #{path}: No such file or directory"
@@ -37,14 +35,14 @@ module Yap::Shell
       end
     end
 
-    builtin :pushd do |args:, stderr:, **keyword_args|
+    builtin :pushd do |world:, args:, stderr:, **keyword_args|
       output = []
       if DIRECTORY_FUTURE.any?
         path = DIRECTORY_FUTURE.pop
         if Dir.exist?(path)
           DIRECTORY_HISTORY << Dir.pwd
           Dir.chdir(path)
-          ENV["PWD"] = path
+          world.env["PWD"] = Dir.pwd
           exit_status = 0
         else
           stderr.puts "pushd: #{path}: No such file or directory"

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

@@ -0,0 +1,11 @@
+module Yap::Shell
+  module Builtins
+
+    builtin :env do |world:, args:, stdout:, **|
+      world.env.keys.sort.each do |key|
+        stdout.puts "#{key}=#{world.env[key]}"
+      end
+    end
+
+  end
+end

data/lib/yap/shell/commands.rb

@@ -7,13 +7,13 @@ module Yap::Shell
   class CommandUnknownError < CommandError ; end
 
   class CommandFactory
-    def self.build_command_for(command:, args:, heredoc:, internally_evaluate:)
-      return RubyCommand.new(str:command) if internally_evaluate
+    def self.build_command_for(world:, command:, args:, heredoc:, internally_evaluate:, line:)
+      return RubyCommand.new(world:world, str:command) if internally_evaluate
 
       case command
-      when ShellCommand then ShellCommand.new(str:command, args:args, heredoc:heredoc)
-      when BuiltinCommand then BuiltinCommand.new(str:command, args:args, heredoc:heredoc)
-      when FileSystemCommand  then FileSystemCommand.new(str:command, args:args, heredoc:heredoc)
+      when ShellCommand then ShellCommand.new(world:world, str:command, args:args, heredoc:heredoc, line:line)
+      when BuiltinCommand then BuiltinCommand.new(world:world, str:command, args:args, heredoc:heredoc)
+      when FileSystemCommand  then FileSystemCommand.new(world:world, str:command, args:args, heredoc:heredoc)
       else
         raise CommandUnknownError, "Don't know how to execute command: #{command}"
       end
@@ -21,13 +21,15 @@ module Yap::Shell
   end
 
   class Command
-    attr_accessor :str, :args
+    attr_accessor :world, :str, :args, :line
     attr_accessor :heredoc
 
-    def initialize(str:, args:[], heredoc:nil)
+    def initialize(world:, str:, args:[], line:nil, heredoc:nil)
+      @world = world
       @str = str
       @args = args
       @heredoc = heredoc
+      @line = line
     end
 
     def to_executable_str
@@ -54,7 +56,7 @@ module Yap::Shell
 
     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:args, stdin:stdin, stdout:stdout, stderr:stderr
+      action.call world:world, args:args, stdin:stdin, stdout:stdout, stderr:stderr
     end
 
     def type
@@ -67,6 +69,10 @@ module Yap::Shell
   end
 
   class FileSystemCommand < Command
+    def self.world
+      ::Yap::World.instance
+    end
+
     def self.===(other)
       command = other.split(/\s+/).detect{ |f| !f.include?("=") }
 
@@ -74,7 +80,7 @@ module Yap::Shell
       return true if File.executable?(command)
 
       # See if the command exists anywhere on the path
-      ENV["PATH"].split(":").detect do |path|
+      world.env["PATH"].split(":").detect do |path|
         File.executable?(File.join(path, command))
       end
     end
@@ -86,7 +92,7 @@ module Yap::Shell
     def to_executable_str
       [
         str,
-        args.map(&:shellescape).join(' ')
+        args.join(' ')
       ].join(' ')
     end
   end
@@ -96,13 +102,17 @@ module Yap::Shell
       (@registered_functions ||= {}).freeze
     end
 
-    def self.define_shell_function(name, &blk)
-      raise ArgumentError, "Must provided block when defining a shell function" unless blk
-      (@registered_functions ||= {})[name.to_sym] = blk
+    def self.define_shell_function(name_or_pattern, &blk)
+      raise ArgumentError, "Must provide block when defining a shell function" unless blk
+      name_or_pattern = name_or_pattern.to_s if name_or_pattern.is_a?(Symbol)
+      name_or_pattern = /^#{Regexp.escape(name_or_pattern)}$/ if name_or_pattern.is_a?(String)
+      (@registered_functions ||= {})[name_or_pattern] = blk
     end
 
-    def self.===(other)
-      registered_functions.include?(other.to_sym)
+    def self.===(command)
+      registered_functions.detect do |name_or_pattern, *_|
+        name_or_pattern.match(command)
+      end
     end
 
     def type
@@ -110,9 +120,10 @@ module Yap::Shell
     end
 
     def to_proc
-      self.class.registered_functions.fetch(str.to_sym){
-        raise "Shell function #{str} was not found!"
-      }
+      self.class.registered_functions.detect do |name_or_pattern, function_body|
+        return function_body if name_or_pattern.match(str)
+      end
+      raise "Shell function #{str} was not found!"
     end
   end
 

data/lib/yap/shell/evaluation.rb

@@ -1,32 +1,38 @@
 require 'yap/shell/parser'
 require 'yap/shell/commands'
 require 'yap/shell/aliases'
+require 'yap/shell/evaluation/shell_expansions'
 
 module Yap::Shell
   class Evaluation
-    def initialize(stdin:, stdout:, stderr:)
+    attr_reader :world
+
+    def initialize(stdin:, stdout:, stderr:, world:)
       @stdin, @stdout, @stderr = stdin, stdout, stderr
-      @last_result = nil
+      @world = world
     end
 
     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)
+      @input = recursively_find_and_replace_command_substitutions(input)
+      ast = Parser.parse(@input)
       ast.accept(self)
     end
 
+    def set_last_result(result)
+      @world.last_result = result
+    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)
+    def recursively_find_and_replace_command_substitutions(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)
+      Parser.each_command_substitution_for(input) do |substitution_result, start_position, end_position|
+        result = recursively_find_and_replace_command_substitutions(substitution_result.str)
         position = substitution_result.position
-        ast = parser.parse(result)
+        ast = Parser.parse(result)
         with_standard_streams do |stdin, stdout, stderr|
           r,w = IO.pipe
           @stdout = w
@@ -46,65 +52,183 @@ module Yap::Shell
 
     def visit_CommandNode(node)
       @aliases_expanded ||= []
+      @command_node_args_stack ||= []
       with_standard_streams do |stdin, stdout, stderr|
-        args = node.args.map(&:lvalue)
+        args = node.args.map(&:lvalue).map do |arg|
+          shell_expand(arg, escape_directory_expansions: false)
+        end
         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(args).join(" "))
+          @command_node_args_stack << args
+          ast = Parser.parse(_alias)
           @aliases_expanded.push(node.command)
           ast.accept(self)
           @aliases_expanded.pop
           @suppress_events = false
         else
+          cmd2execute = variable_expand(node.command)
+          final_args = (args + @command_node_args_stack).flatten.shelljoin
+          expanded_args = shell_expand(final_args)
           command = CommandFactory.build_command_for(
-            command: node.command,
-            args:    shell_expand(args),
-            heredoc: node.heredoc,
-            internally_evaluate: node.internally_evaluate?)
+            world: world,
+            command: cmd2execute,
+            args:    expanded_args,
+            heredoc: (node.heredoc && node.heredoc.value),
+            internally_evaluate: node.internally_evaluate?,
+            line: @input)
           @stdin, @stdout, @stderr = stream_redirections_for(node)
-          @last_result = @blk.call command, @stdin, @stdout, @stderr
+          set_last_result @blk.call command, @stdin, @stdout, @stderr, pipeline_stack.empty?
+          @command_node_args_stack.clear
+        end
+      end
+    end
+
+    def visit_CommentNode(node)
+      # no-op, do nothing
+    end
+
+    def visit_RangeNode(node)
+      range = node.head.value
+      if node.tail
+        @current_range_values = range.to_a
+        node.tail.accept(self)
+        @current_range_values = nil
+      else
+        @stdout.puts range.to_a.join(' ')
+      end
+    end
+
+    def visit_RedirectionNode(node)
+      filename = node.target
+
+      if File.directory?(filename)
+        puts <<-ERROR.gsub(/^\s*/m, '').lines.join(' ')
+          Whoops, #{filename.inspect} is a directory! Those can't be redirected to.
+        ERROR
+        set_last_result Yap::Shell::Execution::Result.new(status_code:1, directory:Dir.pwd, n:1, of:1)
+      elsif node.kind == ">"
+        File.write(filename, "")
+        set_last_result Yap::Shell::Execution::Result.new(status_code:0, directory:Dir.pwd, n:1, of:1)
+      else
+        puts "Sorry, #{node.kind} redirection isn't a thing, but >#{filename} is!"
+        set_last_result Yap::Shell::Execution::Result.new(status_code:2, directory:Dir.pwd, n:1, of:1)
+      end
+    end
+
+    def visit_BlockNode(node)
+      with_standard_streams do |stdin, stdout, stderr|
+        # Modify @stdout and @stderr for the first command
+        stdin, @stdout = IO.pipe
+
+        # Don't modify @stdin for the first command in the pipeline.
+        values = []
+        if node.head
+          node.head.accept(self)
+          values = stdin.read.split(/\s+/)
+        else
+          # assume range for now
+          values = @current_range_values
+        end
+
+        evaluate_block = lambda {
+          with_standard_streams do |stdin2, stdout2, stderr2|
+            @stdout = stdout
+            node.tail.accept(self)
+          end
+        }
+
+        if node.params.any?
+          values.each_slice(node.params.length).each do |_slice|
+            with_env do
+              Hash[ node.params.zip(_slice) ].each_pair do |k,v|
+                world.env[k] = v.to_s
+              end
+              evaluate_block.call
+            end
+          end
+        else
+          values.each do
+            evaluate_block.call
+          end
+        end
+      end
+
+    end
+
+    def visit_NumericalRangeNode(node)
+      node.range.each do |n|
+        if node.tail
+          if node.reference
+            with_env do
+              world.env[node.reference.value] = n.to_s
+              node.tail.accept(self)
+            end
+          else
+            node.tail.accept(self)
+          end
         end
       end
     end
 
     def visit_StatementsNode(node)
-      env = ENV.to_h
-      Yap::Shell::Execution::Context.fire :before_statements_execute, self unless @suppress_events
+      Yap::Shell::Execution::Context.fire :before_statements_execute, @world unless @suppress_events
       node.head.accept(self)
       if node.tail
         node.tail.accept(self)
-        ENV.clear
-        ENV.replace(env)
       end
-      Yap::Shell::Execution::Context.fire :after_statements_execute, self unless @suppress_events
+      Yap::Shell::Execution::Context.fire :after_statements_execute, @world unless @suppress_events
     end
 
+    # Represents a statement that has scoped environment variables being set,
+    # e.g.:
+    #
+    #    yap> A=5 ls
+    #    yap> A=5 B=6 echo
+    #
+    # These environment variables are reset after the their statement, e.g.:
+    #
+    #    yap> A=5
+    #    yap> echo $A
+    #    5
+    #    yap> A=b echo $A
+    #    b
+    #    yap> echo $
+    #    5
+    #
     def visit_EnvWrapperNode(node)
-      env = ENV.to_h
-      node.env.each_pair do |k,v|
-        ENV[k] = v
+      with_env do
+        node.env.each_pair { |env_var_name,value| world.env[env_var_name] = variable_expand(value) }
+        node.node.accept(self)
       end
-      node.node.accept(self)
-      ENV.clear
-      ENV.replace(env)
     end
 
+    # Represents a statement that contains nothing but environment
+    # variables being set, e.g.:
+    #
+    #    yap> A=5
+    #    yap> A=5 B=6
+    #    yap> A=3 && B=6
+    #
+    # The environment variables persist from statement to statement until
+    # they cleared or overridden.
+    #
     def visit_EnvNode(node)
       node.env.each_pair do |key,val|
-        ENV[key] = val
+        world.env[key] = variable_expand(val)
       end
+      Yap::Shell::Execution::Result.new(status_code:0, directory:Dir.pwd, n:1, of:1)
     end
 
     def visit_ConditionalNode(node)
       case node.operator
       when '&&'
         node.expr1.accept self
-        if @last_result.status_code == 0
+        if @world.last_result.status_code == 0
           node.expr2.accept self
         end
       when '||'
         node.expr1.accept self
-        if @last_result.status_code != 0
+        if @world.last_result.status_code != 0
           node.expr2.accept self
         end
       else
@@ -116,7 +240,7 @@ module Yap::Shell
       with_standard_streams do |stdin, stdout, stderr|
         # Modify @stdout and @stderr for the first command
         stdin, @stdout = IO.pipe
-
+        pipeline_stack.push true
         # Don't modify @stdin for the first command in the pipeline.
         node.head.accept(self)
 
@@ -127,6 +251,7 @@ module Yap::Shell
         # Modify @stdout,@stderr to go back to the original
         @stdout, @stderr = stdout, stderr
 
+        pipeline_stack.pop
         node.tail.accept(self)
 
         # Set our @stdin back to the original
@@ -136,11 +261,13 @@ module Yap::Shell
 
     def visit_InternalEvalNode(node)
       command = CommandFactory.build_command_for(
+        world: world,
         command: node.command,
         args:    node.args,
         heredoc: node.heredoc,
-        internally_evaluate: node.internally_evaluate?)
-      @last_result = @blk.call command, @stdin, @stdout, @stderr
+        internally_evaluate: node.internally_evaluate?,
+        line: @input)
+      set_last_result @blk.call command, @stdin, @stdout, @stderr, pipeline_stack.empty?
     end
 
     ######################################################################
@@ -149,45 +276,26 @@ module Yap::Shell
     #                                                                    #
     ######################################################################
 
-    def alias_expand(input, aliases:Aliases.instance)
-      head, *tail = input.split(/\s/, 2).first
-      if new_head=aliases.fetch_alias(head)
-        [new_head].concat(tail).join(" ")
-      else
-        input
-      end
-    end
 
-    def shell_expand(input)
-      [input].flatten.inject([]) do |results,str|
-        # Basic bash-style brace expansion
-        expansions = str.scan(/\{([^\}]+)\}/).flatten.first
-        if expansions
-          expansions.split(",").each do |expansion|
-            results << str.sub(/\{([^\}]+)\}/, expansion)
-          end
-        else
-          results << str
-        end
+    # +pipeline_stack+ is used to determine if we are about go inside of a
+    # pipeline. It will be empty when we are coming out of a pipeline node.
+    def pipeline_stack
+      @pipeline_stack ||= []
+    end
 
-        results = results.map! do |s|
-          # Basic bash-style tilde expansion
-          s.gsub!(/\A~(.*)/, ENV["HOME"] + '\1')
+    def alias_expand(input)
+      ShellExpansions.new(world: world).expand_aliases_in(input)
+    end
 
-          # Basic bash-style variable expansion
-          if s =~ /^\$(.*)/
-            s = ENV.fetch($1, "")
-          end
+    def variable_expand(input)
+      ShellExpansions.new(world: world).expand_variables_in(input)
+    end
 
-          # Basic bash-style path-name expansion
-          expansions = Dir[s]
-          if expansions.any?
-            expansions
-          else
-            s
-          end
-        end.flatten
-      end.flatten
+    def shell_expand(input, escape_directory_expansions: true)
+      ShellExpansions.new(world: world).expand_words_in(
+        input,
+        escape_directory_expansions: escape_directory_expansions
+      )
     end
 
     def with_standard_streams(&blk)
@@ -215,5 +323,14 @@ module Yap::Shell
       [stdin, stdout, stderr]
     end
 
+    def with_env(&blk)
+      env = world.env.dup
+      begin
+        yield if block_given?
+      ensure
+        world.env.clear
+        world.env.replace(env)
+      end
+    end
   end
 end