yap-shell 0.0.2

data/lib/yap/shell/builtins.rb

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

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

@@ -0,0 +1,25 @@
+require 'yap/shell/aliases'
+require 'shellwords'
+
+module Yap::Shell
+  module Builtins
+    builtin :alias do |*args|
+      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.first
+        name, command = name_eq_value.scan(/^(.*?)\s*=\s*(.*)$/).flatten
+        Yap::Shell::Aliases.instance.set_alias name, command
+      end
+      output.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Yap::Shell
+  module Builtins
+    DIRECTORY_HISTORY = []
+    DIRECTORY_FUTURE  = []
+
+    builtin :cd do |path=ENV['HOME'], *_|
+      DIRECTORY_HISTORY << Dir.pwd
+      Dir.chdir(path)
+      ENV["PWD"] = Dir.pwd
+      output=""
+    end
+
+    builtin :popd do
+      output = []
+      if DIRECTORY_HISTORY.any?
+        DIRECTORY_FUTURE << Dir.pwd
+        path = DIRECTORY_HISTORY.pop
+        execute_builtin :cd, path
+      else
+        output << "popd: directory stack empty\n"
+      end
+      output.join("\n")
+    end
+
+    builtin :pushd do
+      output = []
+      if DIRECTORY_FUTURE.any?
+        DIRECTORY_HISTORY << Dir.pwd
+        path = DIRECTORY_FUTURE.pop
+        execute_builtin :cd, path
+      else
+        output << "pushd: there are no directories in your future\n"
+      end
+      output.join("\n")
+    end
+  end
+end

data/lib/yap/shell/commands.rb

@@ -0,0 +1,127 @@
+require 'shellwords'
+require 'yap/shell/aliases'
+
+module Yap::Shell
+  class CommandError < StandardError ; end
+  class CommandUnknownError < CommandError ; end
+
+  class CommandFactory
+    def self.build_command_for(command:, args:, heredoc:, internally_evaluate:)
+      return RubyCommand.new(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)
+      else
+        raise CommandUnknownError, "Don't know how to execute command: #{command}"
+      end
+    end
+  end
+
+  class Command
+    attr_accessor :str, :args
+    attr_accessor :heredoc
+
+    def initialize(str:, args:[], heredoc:nil)
+      @str = str
+      @args = args
+      @heredoc = heredoc
+    end
+
+    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 { 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
+      action = self.class.builtins.fetch(str.to_sym){ raise("Missing proc for builtin: '#{builtin}' in #{str.inspect}") }
+      action.call *args
+    end
+
+    def type
+      :BuiltinCommand
+    end
+
+    def to_executable_str
+      raise NotImplementedError, "#to_executable_str is not implemented on BuiltInCommand"
+    end
+  end
+
+  class FileSystemCommand < Command
+    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
+      ENV["PATH"].split(":").detect do |path|
+        File.executable?(File.join(path, command))
+      end
+    end
+
+    def type
+      :FileSystemCommand
+    end
+
+    def to_executable_str
+      [
+        str,
+        args.map(&:shellescape).join(' ')
+      ].join(' ')
+    end
+  end
+
+  class ShellCommand < Command
+    def self.registered_functions
+      (@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
+    end
+
+    def self.===(other)
+      registered_functions.include?(other.to_sym)
+    end
+
+    def type
+      :ShellCommand
+    end
+
+    def to_proc
+      self.class.registered_functions.fetch(str.to_sym){
+        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

@@ -0,0 +1,198 @@
+require 'yap/shell/parser'
+require 'yap/shell/commands'
+require 'yap/shell/aliases'
+
+module Yap::Shell
+  class Evaluation
+    def initialize(stdin:, stdout:, stderr:)
+      @stdin, @stdout, @stderr = stdin, stdout, stderr
+      @last_result = nil
+    end
+
+    def evaluate(input, &blk)
+      @blk = blk
+      ast = Yap::Shell::Parser.new.parse(input)
+      ast.accept(self)
+    end
+
+    private
+
+    ######################################################################
+    #                                                                    #
+    #               VISITOR METHODS FOR AST TREE WALKING                 #
+    #                                                                    #
+    ######################################################################
+
+    def visit_CommandNode(node)
+      @aliases_expanded ||= []
+      with_standard_streams do |stdin, stdout, stderr|
+        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(" "))
+          @aliases_expanded.push(node.command)
+          ast.accept(self)
+          @aliases_expanded.pop
+          @suppress_events = false
+        else
+          command = CommandFactory.build_command_for(
+            command: node.command,
+            args:    shell_expand(node.args),
+            heredoc: node.heredoc,
+            internally_evaluate: node.internally_evaluate?)
+          @stdin, @stdout, @stderr = stream_redirections_for(node)
+          @last_result = @blk.call command, @stdin, @stdout, @stderr
+        end
+      end
+    end
+
+    def visit_StatementsNode(node)
+      env = ENV.to_h
+      Yap::Shell::Execution::Context.fire :before_statements_execute, self 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
+    end
+
+    def visit_EnvWrapperNode(node)
+      env = ENV.to_h
+      node.env.each_pair do |k,v|
+        ENV[k] = v
+      end
+      node.node.accept(self)
+      ENV.clear
+      ENV.replace(env)
+    end
+
+    def visit_EnvNode(node)
+      node.env.each_pair do |key,val|
+        ENV[key] = val
+      end
+    end
+
+    def visit_ConditionalNode(node)
+      case node.operator
+      when '&&'
+        node.expr1.accept self
+        if @last_result.status_code == 0
+          node.expr2.accept self
+        end
+      when '||'
+        node.expr1.accept self
+        if @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={})
+      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)
+
+        # 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
+
+        node.tail.accept(self)
+
+        # Set our @stdin back to the original
+        @stdin = stdin
+      end
+    end
+
+    def visit_InternalEvalNode(node)
+      command = CommandFactory.build_command_for(
+        command: node.command,
+        args:    node.args,
+        heredoc: node.heredoc,
+        internally_evaluate: node.internally_evaluate?)
+      @last_result = @blk.call command, @stdin, @stdout, @stderr
+    end
+
+    ######################################################################
+    #                                                                    #
+    #               HELPER / UTILITY METHODS                             #
+    #                                                                    #
+    ######################################################################
+
+    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
+
+        results = results.map! do |s|
+          # Basic bash-style tilde expansion
+          s.gsub!(/\A~(.*)/, ENV["HOME"] + '\1')
+
+          # Basic bash-style variable expansion
+          if s =~ /^\$(.*)/
+            s = ENV.fetch($1, "")
+          end
+
+          # Basic bash-style path-name expansion
+          expansions = Dir[s]
+          if expansions.any?
+            expansions
+          else
+            s
+          end
+        end.flatten
+      end.flatten
+    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)
+      stdin, stdout, stderr = @stdin, @stdout, @stderr
+      node.redirects.each do |redirect|
+        case redirect.kind
+        when "<"
+          stdin = redirect.target
+        when ">", "1>"
+          stdout = redirect.target
+        when "1>&2"
+          stderr = :stdout
+        when "2>"
+          stderr = redirect.target
+        when "2>&1"
+          stdout = :stderr
+        end
+      end
+      [stdin, stdout, stderr]
+    end
+
+  end
+end

data/lib/yap/shell/execution.rb

@@ -0,0 +1,18 @@
+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
+    Context.register RubyCommandExecution,       command_type: :RubyCommand
+  end
+end

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

@@ -0,0 +1,15 @@
+module Yap::Shell::Execution
+  class BuiltinCommandExecution < CommandExecution
+    on_execute do |command:, n:, of:|
+      command_output = command.execute
+      if command_output == :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)
+      end
+    end
+  end
+end