yap-shell 0.7.1 → 0.7.2

data/lib/yap/shell/builtins.rb

@@ -1,18 +0,0 @@
-module Yap::Shell
-  require 'yap/shell/commands'
-
-  module Builtins
-    def self.builtin(name, &blk)
-      Yap::Shell::BuiltinCommand.add(name, &blk)
-    end
-
-    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
-
-    Dir[File.dirname(__FILE__) + "/builtins/**/*.rb"].each do |f|
-      require f
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'shellwords'
-
-module Yap::Shell
-  require 'yap/shell/aliases'
-
-  module Builtins
-    Color = ::Term::ANSIColor
-
-    builtin :alias do |args:, stdout:, **kwargs|
-      output = []
-      if args.empty?
-        Yap::Shell::Aliases.instance.to_h.each_pair do |name, value|
-          # Escape and wrap single quotes since we're using
-          # single quotes to wrap the aliased command for matching
-          # bash output.
-          escaped_value = value.gsub(/'/){ |a| "'\\#{a}'" }
-          output << "alias #{name.shellescape}='#{escaped_value}'"
-        end
-        output << ""
-      else
-        name_eq_value = args.map(&:shellsplit).join(' ')
-        name, command = name_eq_value.scan(/^(.*?)\s*=\s*(.*)$/).flatten
-        output << "Setting alias #{name} #{Color.green('done')}"
-        Yap::Shell::Aliases.instance.set_alias name, command
-      end
-      stdout.puts output.join("\n")
-    end
-
-    builtin :unalias do |args:, stdout:, **kwargs|
-      output = []
-      if args.empty?
-        output << "Usage: unalias <aliasname>"
-      else
-        args.each do |alias_name|
-          Yap::Shell::Aliases.instance.unset_alias alias_name
-          output << "Removing alias #{alias_name} #{Color.green('done')}"
-        end
-      end
-      stdout.puts output.join("\n")
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-module Yap::Shell
-  module Builtins
-    DIRECTORY_HISTORY = []
-    DIRECTORY_FUTURE  = []
-
-    builtin :cd do |world:, args:, stderr:, **|
-      path = (args.first || world.env['HOME']).shellsplit.join
-      if Dir.exist?(path)
-        DIRECTORY_HISTORY << Dir.pwd
-        world.env["PWD"] = File.expand_path(path)
-        Dir.chdir(path)
-        exit_status = 0
-      else
-        stderr.puts "cd: #{path}: No such file or directory"
-        exit_status = 1
-      end
-    end
-
-    builtin :popd do |world:, args:, stderr:, **keyword_args|
-      output = []
-      if DIRECTORY_HISTORY.any?
-        path = DIRECTORY_HISTORY.pop
-        if Dir.exist?(path)
-          DIRECTORY_FUTURE << Dir.pwd
-          Dir.chdir(path)
-          world.env["PWD"] = Dir.pwd
-          exit_status = 0
-        else
-          stderr.puts "popd: #{path}: No such file or directory"
-          exit_status = 1
-        end
-      else
-        stderr.puts "popd: directory stack empty"
-        exit_status = 1
-      end
-    end
-
-    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)
-          world.env["PWD"] = Dir.pwd
-          exit_status = 0
-        else
-          stderr.puts "pushd: #{path}: No such file or directory"
-          exit_status = 1
-        end
-      else
-        stderr.puts "pushd: there are no directories in your future"
-        exit_status = 1
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-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

@@ -1,163 +0,0 @@
-require 'shellwords'
-
-module Yap::Shell
-  require 'yap/shell/aliases'
-  require 'yap/shell/execution/result'
-
-  class CommandError < StandardError ; end
-
-  class CommandFactory
-    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(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
-        UnknownCommand.new(world:world, str:command, args:args, heredoc:heredoc)
-      end
-    end
-  end
-
-  class Command
-    attr_accessor :world, :str, :args, :line
-    attr_accessor :heredoc
-
-    def initialize(world:, str:, args:[], line:nil, heredoc:nil)
-      @world = world
-      @str = str
-      @args = args
-      @heredoc = heredoc
-      @line = line
-    end
-
-    def to_s
-      "#{self.class.name}(#{str.inspect})"
-    end
-    alias :to_str :to_s
-    alias :inspect :to_s
-
-    def to_executable_str
-      raise NotImplementedError, ":to_executable_str must be implemented by including object."
-    end
-  end
-
-  class BuiltinCommand < Command
-    def self.===(other)
-      self.builtins.keys.include?(other.split(' ').first.to_sym) || super
-    end
-
-    def self.builtins
-      @builtins ||= {
-        builtins: lambda { |stdout:, **| stdout.puts @builtins.keys.sort },
-        exit: lambda { |code = 0, **| exit(code.to_i) },
-        fg: lambda{ |**| :resume },
-      }
-    end
-
-    def self.add(command, &action)
-      builtins.merge!(command.to_sym => action)
-    end
-
-    def execute(stdin:, stdout:, stderr:)
-      action = self.class.builtins.fetch(str.to_sym){ raise("Missing proc for builtin: '#{builtin}' in #{str.inspect}") }
-      action.call world:world, args:args, stdin:stdin, stdout:stdout, stderr:stderr
-    end
-
-    def type
-      :BuiltinCommand
-    end
-
-    def to_executable_str
-      raise NotImplementedError, "#to_executable_str is not implemented on BuiltInCommand"
-    end
-  end
-
-  class UnknownCommand < Command
-    EXIT_CODE = 127
-
-    def execute(stdin:, stdout:, stderr:)
-      stderr.puts "yap: command not found: #{str}"
-      EXIT_CODE
-    end
-
-    def type
-      :BuiltinCommand
-    end
-  end
-
-  class FileSystemCommand < Command
-    def self.world
-      ::Yap::World.instance
-    end
-
-    def self.===(other)
-      command = other.split(/\s+/).detect{ |f| !f.include?("=") }
-
-      # Check to see if the user gave us a valid path to execute
-      return true if File.executable?(command)
-
-      # See if the command exists anywhere on the path
-      world.env["PATH"].split(":").detect do |path|
-        File.executable?(File.join(path, command))
-      end
-    end
-
-    def type
-      :FileSystemCommand
-    end
-
-    def to_s
-      "#{self.class.name}(#{to_executable_str.inspect})"
-    end
-    alias :to_str :to_s
-    alias :inspect :to_s
-
-    def to_executable_str
-      [
-        str,
-        args.join(' ')
-      ].join(' ')
-    end
-  end
-
-  class ShellCommand < Command
-    def self.registered_functions
-      (@registered_functions ||= {}).freeze
-    end
-
-    def self.define_shell_function(name_or_pattern, name: nil, &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)
-      (@registered_functions ||= {})[name_or_pattern] = blk
-    end
-
-    def self.===(command)
-      registered_functions.detect do |name_or_pattern, *_|
-        name_or_pattern.match(command)
-      end
-    end
-
-    def type
-      :ShellCommand
-    end
-
-    def to_proc
-      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
-
-  class RubyCommand < Command
-    def type
-      :RubyCommand
-    end
-
-    def to_executable_str
-      str
-    end
-  end
-end

data/lib/yap/shell/evaluation.rb

@@ -1,439 +0,0 @@
-module Yap::Shell
-  require 'yap/shell/parser'
-  require 'yap/shell/commands'
-  require 'yap/shell/aliases'
-  require 'yap/shell/evaluation/shell_expansions'
-
-  class Evaluation
-    attr_reader :world
-
-    def initialize(stdin:, stdout:, stderr:, world:)
-      @stdin, @stdout, @stderr = stdin, stdout, stderr
-      @world = world
-    end
-
-    def evaluate(input, &blk)
-      @blk = blk
-      debug_log "evaluation begins input=#{input.inspect}"
-      @input = recursively_find_and_replace_command_substitutions(input)
-      debug_log "recursive find/replace command substitutions results in input=#{@input.inspect}"
-      ast = Parser.parse(@input)
-      debug_log "parsed input into AST: #{ast}"
-      debug_log "beginning to walk AST"
-      ast.accept(self).tap do
-        debug_log "done walking AST"
-      end
-    end
-
-    def set_last_result(result)
-      debug_log "evaluation setting last result=#{result.inspect}"
-      @world.last_result = result
-    end
-
-    private
-
-    def debug_log(message)
-      Treefell['shell'].puts message
-    end
-
-    def debug_visit(node, msg='')
-      calling_method = caller[0][/`.*'/][1..-2]
-      debug_log "evaluation #{calling_method} node=#{node} #{msg}"
-    end
-
-    # +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(input)
-      input = input.dup
-      Parser.each_command_substitution_for(input) do |substitution_result, start_position, end_position|
-        debug_log "found command substitution at position=#{(start_position..end_position)} #{substitution_result.inspect}"
-        result = recursively_find_and_replace_command_substitutions(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)
-
-          output = r.read.chomp
-
-          # Treat consecutive newlines in output as a single space
-          output = output.gsub(/\n+/, ' ')
-
-          # Double quote the output and escape any double quotes already
-          # existing
-          output = %|"#{output.gsub(/"/, '\\"')}"|
-
-          # Put thd output back into the original input
-          debug_log "replacing command substitution at position=#{(position.min...position.max)} with #{output.inspect}"
-          input[position.min...position.max] = output
-        end
-      end
-      input
-    end
-
-
-    ######################################################################
-    #                                                                    #
-    #               VISITOR METHODS FOR AST TREE WALKING                 #
-    #                                                                    #
-    ######################################################################
-
-    def visit_CommandNode(node)
-      debug_visit(node)
-      @aliases_expanded ||= []
-      @command_node_args_stack ||= []
-      with_standard_streams do |stdin, stdout, stderr|
-        args = process_ArgumentNodes(node.args)
-        if !node.literal? && !@aliases_expanded.include?(node.command) && Aliases.instance.has_key?(node.command)
-          _alias=Aliases.instance.fetch_alias(node.command)
-          @suppress_events = true
-          @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.map(&:shellescape)
-          expanded_args = final_args
-          command = CommandFactory.build_command_for(
-            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)
-          set_last_result @blk.call command, @stdin, @stdout, @stderr, pipeline_stack.empty?
-          @command_node_args_stack.clear
-        end
-      end
-    end
-
-    def visit_CommentNode(node)
-      debug_visit(node)
-      # no-op, do nothing
-    end
-
-    def visit_RangeNode(node)
-      debug_visit(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)
-      debug_visit(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)
-      debug_visit(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(/\n|\0/)
-        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)
-      debug_visit(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)
-      debug_visit(node)
-      Yap::Shell::Execution::Context.fire :before_statements_execute, @world unless @suppress_events
-      node.head.accept(self)
-      if node.tail
-        node.tail.accept(self)
-      end
-      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)
-      debug_visit(node)
-      with_env do
-        node.env.each_pair do |env_var_name, arg_node|
-          world.env[env_var_name] = process_EnvArgumentNode(arg_node)
-        end
-        node.node.accept(self)
-      end
-    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)
-      debug_visit(node)
-      node.env.each_pair do |key, arg_node|
-        world.env[key] = process_EnvArgumentNode(arg_node)
-      end
-      Yap::Shell::Execution::Result.new(status_code:0, directory:Dir.pwd, n:1, of:1)
-    end
-
-    def visit_ConditionalNode(node)
-      debug_visit(node)
-      case node.operator
-      when '&&'
-        node.expr1.accept self
-        if @world.last_result.status_code == 0
-          node.expr2.accept self
-        end
-      when '||'
-        node.expr1.accept self
-        if @world.last_result.status_code != 0
-          node.expr2.accept self
-        end
-      else
-        raise "Don't know how to visit conditional node: #{node.inspect}"
-      end
-    end
-
-    def visit_PipelineNode(node, options={})
-      debug_visit(node)
-
-      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)
-
-        # Modify @stdin starting with the second command to read from the
-        # read portion of our above stdout.
-        @stdin = stdin
-
-        # 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
-        @stdin = stdin
-      end
-    end
-
-    def visit_InternalEvalNode(node)
-      debug_visit(node)
-
-      command = CommandFactory.build_command_for(
-        world: world,
-        command: node.command,
-        args:    node.args,
-        heredoc: node.heredoc,
-        internally_evaluate: node.internally_evaluate?,
-        line: @input)
-      set_last_result @blk.call command, @stdin, @stdout, @stderr, pipeline_stack.empty?
-    end
-
-    ######################################################################
-    #                                                                    #
-    #               HELPER / UTILITY METHODS                             #
-    #                                                                    #
-    ######################################################################
-
-    def process_ArgumentNodes(nodes)
-      nodes.map { |arg_node| process_ArgumentNode(arg_node) }
-    end
-
-    def process_ArgumentNode(node)
-      if node.single_quoted?
-        debug_visit(node, 'single quoted argument, performing no expansion')
-        ["#{node.lvalue}"]
-      elsif node.double_quoted?
-        debug_visit(node, 'double quoted argument, performing variable expansion')
-        [variable_expand(node.lvalue)]
-      elsif node.escaped?
-        debug_visit(node, 'escaped argument, skipping variable expansion')
-        [node.lvalue]
-      else
-        debug_visit(node, 'unquoted argument, performing shell expansion')
-        shell_expand(node.lvalue, escape_directory_expansions: false)
-      end
-    end
-
-    # process_EnvArgumentNode is separate from process_ArgumentNode since
-    # it doesn't allow full shell expansion. For example, the following
-    # will not be expanded to "FOO=a_1 a_2", it will be stored as provided:
-    #
-    #   > FOO=a_{1,2}
-    #
-    def process_EnvArgumentNode(node)
-      if node.single_quoted?
-        debug_visit(node, 'single quoted argument, performing no expansion')
-        node.lvalue
-      else
-        debug_visit(node, 'not singled quoted argument, performing variable expansion')
-        variable_expand(node.lvalue)
-      end
-    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
-
-    def alias_expand(input)
-      ShellExpansions.new(world: world).expand_aliases_in(input)
-    end
-
-    def variable_expand(input)
-      ShellExpansions.new(world: world).expand_variables_in(input)
-    end
-
-    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)
-      stdin, stdout, stderr = @stdin, @stdout, @stderr
-      yield stdin, stdout, stderr
-      @stdin, @stdout, @stderr = stdin, stdout, stderr
-    end
-
-    def stream_redirections_for(node)
-      debug_visit(node)
-
-      stdin, stdout, stderr = @stdin, @stdout, @stderr
-      node.redirects.each do |redirect|
-        case redirect.kind
-        when "<"
-          stdin = redirect.target
-          stdin = File.open(stdin, "rb") if stdin.is_a?(String)
-        when ">", "1>"
-          stdout = redirect.target
-          stdout = File.open(stdout, "wb") if stdout.is_a?(String)
-        when "1>&2"
-          stdout = redirect.target
-          stdout = File.open(stdout, "wb") if stdout.is_a?(String)
-          stderr = stdout
-        when "2>"
-          stderr = redirect.target
-          stderr = File.open(stderr, "wb") if stderr.is_a?(String)
-        when "2>&1"
-          stderr = redirect.target
-          stderr = File.open(stderr, "wb") if stderr.is_a?(String)
-          stdout = stderr
-        when "1>>", ">>"
-          stdout = redirect.target
-          stdout = File.open(stdout, "ab") if stdout.is_a?(String)
-        when "2>>"
-          stderr = redirect.target
-          stderr = File.open(stderr, "ab") if stderr.is_a?(String)
-        when "&>"
-          stdout = redirect.target
-          stdout = File.open(stdout, "wb") if stdout.is_a?(String)
-          stderr = stdout
-        when "&>>"
-          stdout = redirect.target
-          stdout = File.open(stdout, "ab") if stdout.is_a?(String)
-          stderr = stdout
-        end
-      end
-
-      [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