rash-command-shell 0.1.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 925fc43795fdb6dedccf7680890bad76aa0f4e2294bf4db6eef10bfb67e6cdc4
-  data.tar.gz: 4f57d6387ecfdf2261e491edce9c8f38b2bccc3de23eb16096df0d8312acb444
+  metadata.gz: 45f54bfa6b60f6a2a35a32d087ad1a722fb88f36fcd46933ae7145ee9dfc944d
+  data.tar.gz: 4dd605ed6fcbfb8a5fbacbd4ff11075933e3e6829785f7605442822f4e5fd508
 SHA512:
-  metadata.gz: d2f3aae4dbd89d00963b235a28f6901fdfc7f4aa4dbe1ec592656f1c9acddc48dfd874a77395fd1a4d2e81e2c8c08f1c700f76ae76049d265f148f5985cb294d
-  data.tar.gz: 69a3a6d0623f316ba75c8a14a3eefde9f2e81214656b9f86836ade185dc83f300be0b97d5df90f383cd106ee71a000ce20ec02bbe2de63aa2d8ceb97cb06560b
+  metadata.gz: 55dde4dead963ce469de63b5c7490224d3d29ca406aafb3ef1d1fd0c2813d3433ba258ed433629fc7983cbe9a399560cf7dee912df871e86cf8c491f3ad83a3b
+  data.tar.gz: 5fe62b4dcc77acb7774f8b06360d4a4768b6b7bd63633886c40fbdbc7e0af41bd4240cbb1c867912ee11eec287e61f19f468ab9b354ac842346e5b46f6a9caea

data/bin/rash

@@ -2,6 +2,9 @@
 
 if ARGV.empty?
   exec("irb", "-r", "rash", *ARGV)
+elsif ARGV[0] =~ /(-)?-v(ersion)?/
+  puts "Rash (c) 2020 Kellen Watt"
+  puts "Version 0.4.0" # I may forget to update this
 elsif File.exists?(ARGV[0]) && !File.directory?(ARGV[0])
   require "rash"
   file = ARGV.shift

data/lib/rash.rb

@@ -1,7 +1,7 @@
 class Environment
   
   attr_reader :aliasing_disabled
-  attr_reader :superuser_mode
+  attr_reader :umask
 
   def initialize
     common_init
@@ -14,7 +14,21 @@ class Environment
     ENV["OLDPWD"] = old.to_s
     Dir.pwd
   end
-  
+
+  # Note that this works regardless of which version of chdir is used.
+  def push_dir(dir = nil)
+    @directory_stack.push(Dir.pwd)
+    self.chdir(dir)
+  end
+
+  def pop_dir
+    self.chdir(@directory_stack.pop) if @directory_stack.size > 0
+  end
+
+  def dirs
+    @directory_stack
+  end
+
   def add_path(path) 
     ENV["PATH"] += File::PATH_SEPARATOR + (path.respond_to?(:path) ? path.path : path.to_s)
   end
@@ -28,6 +42,11 @@ class Environment
       super
     end
   end
+  
+  def umask=(mask)
+    File.umask(mask)
+    @umask = mask
+  end
 
   def as_superuser(&block)
     @superuser_mode = true
@@ -37,27 +56,72 @@ class Environment
       @superuser_mode = false
     end
   end
+
+  def with_limits(limits, &block)
+    if block_given?
+      pid = fork do
+        limits.each {|resource, limit| Process.setrlimit(resource, *limit)}
+        block.call
+        exit!(true)
+      end
+      Process.wait(pid)
+    else
+      limits.each {|resource, limit| Process.setrlimit(resource, *limit)}
+    end
+  end
   
+  def dispatch(m, *args)
+    if @in_pipeline
+      add_pipeline(m, *args)
+    else
+      system_command(m, *args)
+    end
+  end
+
   private
 
   def common_init
     @working_directory = Dir.pwd
+    @umask = File.umask
 
     @aliases = {}
     @aliasing_disabled = false
     @active_jobs = []
 
+    @active_pipelines = []
+
+    @directory_stack = []
+
     @prompt = {
       AUTO_INDENT: true,
       RETURN: ""
     }
     ENV["RASHDIR"] = File.dirname(__FILE__)
   end
+
+  def resolve_command(m, *args, literal: false) 
+    (literal ? [m.to_s] : resolve_alias(m)) + args.flatten.map{|a| a.to_s} 
+  end
+  
+  def system_command(m, *args, except: false, literal: false, out: nil, input: nil, err: nil)
+    command = resolve_command(m, *args, literal: literal)
+    command.unshift("sudo") if @superuser_mode
+    opts = {out: out || $stdout, 
+            err: err || $stderr, 
+            in: input || $stdin, 
+            exception: except || @superuser_mode,
+            umask: @umask}
+
+    system(*command, opts)
+  end
+
 end
 
 require_relative "rash/redirection"
 require_relative "rash/aliasing"
 require_relative "rash/jobcontrol"
+require_relative "rash/pipeline"
+require_relative "rash/capturing"
 
 $env = Environment.new
 
@@ -73,6 +137,17 @@ def cd(dir = nil)
   $env.chdir(d)
 end
 
+def pushd(dir = nil)
+  case dir
+  when File, Dir
+    dir = dir.path if File.directory(dir.path)
+  end
+  $env.push_dir(dir)
+end
+
+def popd
+  $env.pop_dir
+end
 
 def run(file, *args)
   filename = file.to_s
@@ -80,13 +155,15 @@ def run(file, *args)
   unless File.executable?(exe)
     raise SystemCallError.new("No such executable file - #{exe}", Errno::ENOENT::Errno)
   end
-  system(exe, *args.flatten.map{|a| a.to_s}, {out: $stdout, err: $stderr, in: $stdin})
+  $env.dispatch(exe, *args, literal: true)
 end
 
 alias cmd __send__
 
 # Defines `bash` psuedo-compatibility. Filesystem effects happen like normal 
 # and environmental variable changes are copied
+#
+# This is an artifact of an old design and is deprecated until further notice.
 def sourcesh(file) 
   bash_env = lambda do |cmd = nil|
     tmpenv = `#{cmd + ';' if cmd} printenv`
@@ -101,7 +178,7 @@ end
 
 
 def which(command)
-  cmd = File.expand_path(command)
+  cmd = File.expand_path(command.to_s)
   return cmd if File.executable?(cmd) && !File.directory?(cmd)
   
   exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
@@ -121,11 +198,7 @@ end
 def self.method_missing(m, *args, &block) 
   exe = which(m.to_s)
   if exe || ($env.alias?(m) && !$env.aliasing_disabled)
-    if $env.superuser_mode
-      system("sudo", *$env.resolve_alias(m), *args.flatten.map{|a| a.to_s}, {out: $stdout, err: $stderr, in: $stdin, exception: true}) 
-    else
-      system(*$env.resolve_alias(m), *args.flatten.map{|a| a.to_s}, {out: $stdout, err: $stderr, in: $stdin})
-    end
+    $env.dispatch(m, *args)
   else
     super
   end

data/lib/rash/aliasing.rb

@@ -7,26 +7,12 @@ class Environment
     @aliases.delete(func.to_sym)
   end
 
-  # recursive aliases not currently possible. In the works
-  def resolve_alias(f)
-    result = [f.to_s]
-    aliases = @aliases.dup
-    found_alias = true
-    while found_alias
-      found_alias = false
-      if aliases.has_key?(result[0].to_sym)
-        found_alias = true
-        match = result[0].to_sym
-        result[0] = aliases[match]
-        aliases.delete(match)
-        result.flatten! 
-      end
-    end
-    result
-  end
- 
   def alias?(f)
-    @aliases.has_key?(f.to_sym)
+    @aliases.key?(f.to_sym)
+  end
+
+  def aliases
+    @aliases.dup
   end
 
   def without_aliasing
@@ -52,4 +38,25 @@ class Environment
       end
     end
   end
+  
+  private
+
+  # Unless given a compelling reason, this doesn't need to be public. For most 
+  # purposes, some combination of `alias?` and `aliases` should be sufficient.
+  def resolve_alias(f)
+    result = [f.to_s]
+    aliases = @aliases.dup
+    found_alias = true
+    while found_alias
+      found_alias = false
+      if aliases.has_key?(result[0].to_sym)
+        found_alias = true
+        match = result[0].to_sym
+        result[0] = aliases[match]
+        aliases.delete(match)
+        result.flatten! 
+      end
+    end
+    result
+  end
 end

data/lib/rash/capturing.rb

@@ -0,0 +1,45 @@
+class Environment
+  def capture_block(&block)
+    raise ArgumentError.new("no block provided") unless block_given?
+    result = nil
+    old_pipeline = @in_pipeline
+    begin
+      reader, writer = IO.pipe
+      self.stdout = writer
+      @in_pipeline = false
+      block.call
+    ensure
+      @in_pipeline = old_pipeline
+      reset_stdout
+      writer.close
+      result = reader.read
+      reader.close
+    end
+    result
+  end
+
+  def capture_command(m, *args)
+    raise NameError.new("no such command", m) unless which(m) || ($env.alias?(m) && !$env.aliasing_disabled)
+    result = nil
+    begin 
+      reader, writer = IO.pipe
+      system_command(m, *args, out: writer)
+    ensure
+      writer.close
+      result = reader.read
+      reader.close
+    end
+    result
+  end
+end
+
+# This explicitly doesn't support pipelining, as the output is ripped out of sequence.
+def capture(*cmd, &block)
+  if block_given?
+    $env.capture_block(&block)
+  elsif cmd.size > 0 && (which(cmd[0]) || ($env.alias?(m) && !$env.aliasing_disabled))
+    $env.capture_command(cmd[0].to_s, *cmd[1..])
+  else
+    raise ArgumentError.new("nothing to capture from")
+  end
+end

data/lib/rash/ext/filesystem.rb

@@ -2,6 +2,7 @@ class Environment
 
   RASH_LOCAL_FILE = ".rashrc.local"
 
+  # Has to be a better way of adding extensions and dynamically loading them
   def initialize
     common_init
     @working_directory = Directory.root("/") 
@@ -15,26 +16,30 @@ class Environment
     Dir.pwd
   end
 
-  def local_def(name, &block)
-    @working_directory.add_local_method(name.to_sym, &block)
+  def local_def(name, locked: false, &block)
+    @working_directory.add_local_method(name, &block)
+    @working_directory.lock_method(name) if locked
+    name.to_sym
   end
 
   def local_undef(name)
-    @working_directory.clear_local_method(name.to_sym)
+    @working_directory.clear_local_method(name)
   end
 
   def local_method?(name)
-    @working_directory.local_methods.key?(name.to_sym)
+    @working_directory.local_method?(name)
+  end
+
+  def local_methods
+    @working_directory.local_methods
   end
 
   def local_call(name, *args, &block)
-    @working_directory.local_methods[name.to_sym].call(*args, &block)
+    @working_directory.local_method(name).call(*args, &block)
   end
 
   private
 
-  LOCAL_FUNCTIONS_ENABLED = true
-
   # from and to are strings
   def traverse_filetree(from, to)
     abs_from = File.expand_path(from)
@@ -66,7 +71,6 @@ class Environment
   end
 
   class Directory
-    attr_reader :local_methods
     attr_reader :parent, :children
 
     def self.root(dir)
@@ -77,7 +81,31 @@ class Environment
       @path = Dir.new(dir)
       @parent = parent
       @children = []
-      @local_methods = parent&.local_methods.dup || {}
+      @local_methods = parent&.unlocked_local_methods || {}
+      @locked_methods = []
+    end
+
+    def local_method(name)
+      @local_methods[name.to_sym]
+    end
+
+    def local_methods
+      @local_methods.keys
+    end
+
+    def unlocked_local_methods
+      @local_methods.filter{|k, v| !@locked_methods.include?(k)}
+    end
+
+    def lock_method(name)
+      n = name.to_sym
+      raise NameError.new("#{name} is not a local method", n) unless @local_methods.key?(n)
+      @locked_methods << n unless @locked_methods.include?(n)
+      n
+    end
+
+    def local_method?(name)
+      @local_methods.key?(name.to_sym)
     end
 
     def root?
@@ -104,14 +132,14 @@ class Environment
 
     def add_local_method(name, &block)
       raise ArgumentError.new "no method body provided" unless block_given?
-      @local_methods[name] = block # if name already exists, its function is overriden
-      name
+      @local_methods[name.to_sym] = block # if name already exists, its function is overriden
+      name.to_sym
     end
 
     # might not be useful
     def clear_local_method(name)
-      @local_methods.delete(name)
-      name
+      @local_methods.delete(name.to_sym)
+      name.to_sym
     end
 
     def to_s
@@ -120,16 +148,13 @@ class Environment
   end
 end
 
+# still could absolutely be more cleaned up, but it works
 def self.method_missing(m, *args, &block)
   exe = which(m.to_s)
   if $env.local_method?(m)
     $env.local_call(m, *args, &block)
   elsif exe || ($env.alias?(m) && !$env.aliasing_disabled)
-    if $env.superuser_mode
-      system("sudo", *$env.resolve_alias(m), *args.flatten.map{|a| a.to_s}, {out: $stdout, err: $stderr, in: $stdin})
-    else
-      system(*$env.resolve_alias(m), *args.flatten.map{|a| a.to_s}, {out: $stdout, err: $stderr, in: $stdin})
-    end
+    $env.dispatch(m, *args)
   else
     super
   end

data/lib/rash/jobcontrol.rb

@@ -1,6 +1,6 @@
 class Environment
   def jobs
-    @active_jobs.keep_if {|pid| Process.kill(0, pid) rescue false}
+    @active_jobs.keep_if{|pid| Process.kill(0, pid) rescue false}.dup
   end
 
   def async(&block)
@@ -17,5 +17,3 @@ end
 def as_background(&block)
   $env.async(&block)
 end
-  
-

data/lib/rash/pipeline.rb

@@ -0,0 +1,198 @@
+class Environment
+
+  def pipelined?
+    @in_pipeline
+  end
+
+  def synced_pipeline?
+    @in_pipeline && @synchronous_pipeline
+  end
+
+  def make_pipeline(&block) 
+    raise IOError.new("pipelining already enabled") if @in_pipeline
+    start_pipeline
+    begin
+      block.call
+    ensure
+      end_pipeline
+    end
+    nil
+  end
+
+  def make_sync_pipeline(&block)
+    raise IOError.new("pipelining already enabled") if @in_pipeline
+    start_sync_pipeline
+    begin
+      block.call
+    ensure
+      end_sync_pipeline
+    end
+    nil
+  end
+  
+  def as_pipe_command(&block)
+    raise IOError.new("pipelining not enabled") unless @in_pipeline
+    return as_sync_pipe_command(&block) if @synchronous_pipeline
+    
+    input = (@active_pipelines.empty? ? $stdin : @active_pipelines.last.reader)
+    @active_pipelines << Pipeline.new
+    output = @active_pipelines.last.writer
+    error = ($stderr == $stdout ? output : $stderr)
+
+    pid = fork do
+      @in_pipeline = false
+      $stdin = input
+      $stdout = output
+      $stderr = error
+      block.call
+      output.close
+      exit!(true)
+    end
+    output.close
+
+    @active_pipelines.last.link_process(pid)
+    nil
+  end
+
+  def as_sync_pipe_command(&block)
+    raise IOError.new("pipelining not enabled") unless @in_pipeline
+    raise IOError.new("pipeline is not synchronous") unless @synchronous_pipeline
+   
+    @next_pipe.close
+    @next_pipe = Pipeline.new # flush the output pipe
+    @prev_pipe.writer.close
+
+    input = (@first_sync_command ? $stdin : @prev_pipe.reader)
+    @first_sync_command = false
+    output = @next_pipe.writer
+    error = ($stderr == $stdout ? @next_pipe.writer : $stdin)
+
+    pid = fork do
+      @in_pipeline = false
+      @synchronous_pipeline = false
+      $stdin = input
+      $stdout = output
+      $stderr = error
+      block.call
+      exit!(true)
+    end
+
+    Process.wait(pid)
+    @prev_pipe, @next_pipe = @next_pipe, @prev_pipe
+    nil
+  end
+
+  private
+  
+  def start_pipeline
+    @in_pipeline = true
+  end
+
+  def start_sync_pipeline
+    @in_pipeline = true
+    @synchronous_pipeline = true
+    @first_sync_command = true
+    @prev_pipe = Pipeline.new
+    @next_pipe = Pipeline.new
+  end
+
+  def end_pipeline
+    raise IOError.new("pipelining not enabled") unless @in_pipeline
+    @in_pipeline = false
+    if @active_pipelines.size > 0
+      begin
+        Process.wait(@active_pipelines.last.pid)
+        @active_pipelines.last.writer.close # probably redundant, but leaving it for now
+        IO.copy_stream(@active_pipelines.last.reader, $stdout)
+        @active_pipelines.pop.close
+        @active_pipelines.reverse_each {|pipe| pipe.terminate}
+      ensure
+        @active_pipelines.clear
+      end
+    end
+  end
+
+  def end_sync_pipeline
+    raise IOError.new("pipelining not enabled") unless @in_pipeline
+    raise IOError.new("pipeline is not synchronous") unless @synchronous_pipeline
+    @next_pipe.close
+    @prev_pipe.writer.close
+    IO.copy_stream(@prev_pipe.reader, $stdout)
+    @prev_pipe.close
+
+    @next_pipe = @prev_pipe = @first_sync_command = nil
+    @synchronous_pipeline = @in_pipeline = false
+  end
+
+  # special method to be referenced from Environment#dispatch. Do not use directly
+  def add_pipeline(m, *args)
+    raise IOError.new("pipelining not enabled") unless @in_pipeline
+    return add_sync_pipeline(m, *args) if @synchronous_pipeline
+
+    input = (@active_pipelines.empty? ? $stdin : @active_pipelines.last.reader)
+    @active_pipelines << Pipeline.new
+    output = @active_pipelines.last.writer
+    error = ($stderr == $stdout ? output : $stderr)
+    pid = fork do # might not be necessary, spawn might cover it. Not risking it before testing
+      system_command(m, *args, out: output, input: input, err: error, except: true)
+      output.close
+      exit!(true)
+    end
+    output.close
+    @active_pipelines.last.link_process(pid)
+  end
+
+  def add_sync_pipeline(m, *args)
+    raise IOError.new("pipelining not enabled") unless @in_pipeline
+    raise IOError.new("pipeline is not synchronous") unless @synchronous_pipeline
+
+    # Ensure pipe is empty for writing
+    @next_pipe.close
+    @next_pipe = Pipeline.new
+    @prev_pipe.writer.close
+
+    input = (@first_sync_command ? $stdin : @prev_pipe.reader)
+    @first_sync_command = false
+    error = ($stderr == $stdout ? @next_pipe.writer : $stdin)
+    system_command(m, *args, out: @next_pipe.writer, input: input, err: error, except: true)
+    @prev_pipe, @next_pipe = @next_pipe, @prev_pipe
+    nil
+  end
+
+  class Pipeline
+    attr_reader :writer, :reader, :pid
+
+    def initialize
+      @reader, @writer = IO.pipe
+    end
+
+    def link_process(pid)
+      @pid ||= pid
+      self
+    end
+
+    def close
+      @writer.close
+      @reader.close
+    end
+
+    def terminate
+      self.close
+      Process.kill(:TERM, @pid)
+      Process.wait(@pid)
+    end
+
+    def to_s
+      @pid
+    end
+  end
+end
+
+
+def in_pipeline(async: true, &block)
+  if async
+    $env.make_pipeline(&block)
+  else
+    $env.make_sync_pipeline(&block)
+  end
+end

data/lib/rash/redirection.rb

@@ -1,7 +1,5 @@
 class Environment
 
-  DEFAULT_IO = {in: STDIN, out: STDOUT, err: STDERR}
-
   def reset_io
     reset_stdout
     reset_stderr
@@ -78,6 +76,10 @@ class Environment
   def standard_stream?(f)
     DEFAULT_IO.values.include?(f)
   end
+  
+  private
+
+  DEFAULT_IO = {in: STDIN, out: STDOUT, err: STDERR}
 end
 
 # If you want to append, you need to get the file object yourself.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rash-command-shell
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Kellen Watt
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-description: A Ruby-based shell
+description: A Ruby-based command shell
 email:
 executables:
 - rash
@@ -34,8 +34,10 @@ files:
 - bin/rash
 - lib/rash.rb
 - lib/rash/aliasing.rb
+- lib/rash/capturing.rb
 - lib/rash/ext/filesystem.rb
 - lib/rash/jobcontrol.rb
+- lib/rash/pipeline.rb
 - lib/rash/prompt/irb.rb
 - lib/rash/redirection.rb
 homepage: https://github.com/KellenWatt/rash