rash-command-shell 0.3.1 → 0.4.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6654b1ecfaff25cb1008143b0c7718d5d36f6d7e3d3d3764ac77aff47c47e6ea
-  data.tar.gz: 49436d272bf4a5bac674862c1541fe66f335751cf853482f027925b1e6d6f421
+  metadata.gz: dfc5e5ad65a440c46d61615f3af54351e8cea6d65ca029c0a6d6a8ad8532d1ea
+  data.tar.gz: fe22cba6e10c9e03ff2dac578fb21f5247defb3e8523ae596f67b372667d1c2e
 SHA512:
-  metadata.gz: 6e587842b8b49be6832f6c0f05a4ed5a48605712a2cff5b98684c00061292f4d332dba8e63dda380ffff2775535e33c78060649e0d34e1c2c9904b0b3665dad9
-  data.tar.gz: 7b3ff24eb70080a2f70d1e39bcddb07b0d675465ff70e00e90e9e140443bec1c78c9bea22c47d52c9bd9685e01b4a9808736f373c6669bc9f7bb0743b11f635b
+  metadata.gz: 48d51cb3c68949accf870d3e80fd526d570d420fd28bc3de4a4a5a94ac18a3fb070c37531ef736a467e8c0642aa790f9ae99db9e565bbd46a12f0f170e86e5c1
+  data.tar.gz: c61f1b1689ccd5031b14c4a4bb14dba0b002f9d820af0eb0c4b1be03e13bb026449bfa0b5159d9aaa92c8e178f80e83cb7447ce17af6c64613295aa6838fa561

data/bin/rash

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

data/lib/rash.rb

@@ -12,9 +12,24 @@ class Environment
     Dir.chdir(dir.nil? ? "~" : dir.to_s)
     @working_directory = Dir.pwd
     ENV["OLDPWD"] = old.to_s
+    ENV["PWD"] = Dir.pwd
     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
@@ -64,6 +79,10 @@ class Environment
     end
   end
 
+  def name?(v)
+    v.kind_of?(String) || v.kind_of?(Symbol)
+  end
+
   private
 
   def common_init
@@ -76,11 +95,12 @@ class Environment
 
     @active_pipelines = []
 
+    @directory_stack = []
+
     @prompt = {
       AUTO_INDENT: true,
       RETURN: ""
     }
-    ENV["RASHDIR"] = File.dirname(__FILE__)
   end
 
   def resolve_command(m, *args, literal: false) 
@@ -121,6 +141,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
@@ -165,6 +196,11 @@ def which(command)
   nil
 end
 
+# This breaks some default IRB functionality
+# def self.respond_to_missing?(m, *args)
+#   
+#   which(m.to_s) || ($env.alias?(m) && !$env.aliasing_disabled) || $env.local_method?(m) || super
+# end
 
 # Note that I defy convention and don't define `respond_to_missing?`. This
 # is because doing so screws with irb.
@@ -177,6 +213,6 @@ def self.method_missing(m, *args, &block)
   end
 end
 
-
+Process.setproctitle("rash")
 run_command_file = "#{$env.HOME}/.rashrc"
 load run_command_file if File.file?(run_command_file)

data/lib/rash/ext/filesystem.rb

@@ -6,30 +6,58 @@ class Environment
   def initialize
     common_init
     @working_directory = Directory.root("/") 
-    traverse_filetree("/", Dir.pwd)
   end
 
   def chdir(dir = nil)
     old = @working_directory
-    traverse_filetree(Dir.pwd, (dir.nil? ? "~" : dir.to_s))
+    traverse_filetree(@working_directory.to_s, (dir.nil? ? "~" : dir.to_s))
     ENV["OLDPWD"] = old.to_s
+    ENV["PWD"] = Dir.pwd
     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
+
+  # This ultimately behaves similarly to a lambda in function if that ever changes, 
+  # then the proc needs to be converted to a lambda.
   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
+
+  def local_var(name, v = nil, locked: false)
+    res = nil
+    if v.nil?
+      res = @working_directory.local_variable(name)
+    else
+      @working_directory.set_local_variable(name, v)
+      res = v
+    end
+    @working_directory.lock_variable(name) if locked
+    res
+  end
+  
+  def local_var?(name)
+    @working_directory.local_variable?(name)
+  end
+  
+  def local_vars
+    @working_directory.local_variables
   end
 
   private
@@ -65,7 +93,6 @@ class Environment
   end
 
   class Directory
-    attr_reader :local_methods
     attr_reader :parent, :children
 
     def self.root(dir)
@@ -76,9 +103,121 @@ class Environment
       @path = Dir.new(dir)
       @parent = parent
       @children = []
-      @local_methods = parent&.local_methods.dup || {}
+      @local_methods = {}
+      @locked_methods = []
+      @local_variables = {}
+      @locked_variables = []
+    end
+
+    ######################
+    # Local method methods
+    ######################
+
+    def local_method(name)
+      name = name.to_sym
+      @local_methods[name] || @parent&.unlocked_local_method(name)
+    end
+
+    def local_method?(name)
+      name = name.to_sym
+      @local_methods.key?(name) || !!@parent&.unlocked_local_method?(name)
+    end
+    
+    def local_methods
+      @local_methods.keys + (@parent&.unlocked_local_methods).to_a
+    end
+
+    def add_local_method(name, &block)
+      raise ArgumentError.new "no method body provided" unless block_given?
+      @local_methods[name.to_sym] = block # if name already exists, its function is overriden
+      name.to_sym
+    end
+
+    def unlocked_local_method(name)
+      name = name.to_sym
+      @local_methods[name] || @parent&.unlocked_local_method(name)
+    end
+
+    def unlocked_local_method?(name)
+      name = name.to_sym
+      @local_methods.filter{|k, v| !@locked_methods.include?(k)}.key?(name) ||
+        !!@parent&.unlocked_local_method?(name)
+    end
+
+    def unlocked_local_methods
+      @local_methods.filter{|k, v| !@locked_methods.include?(k)}.keys + (@parent&.unlocked_local_methods).to_a
+    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
+
+    # might not be useful
+    def clear_local_method(name)
+      @local_methods.delete(name.to_sym)
+      name.to_sym
+    end
+
+    ######################
+    # Local variable stuff
+    ######################
+
+    def local_variable(name)
+      name = name.to_sym
+      @local_variables[name] || @parent&.unlocked_local_variable(name)
+    end
+    
+    def local_variable?(name)
+      @local_variables.include?(name.to_sym) || !!@parent&.unlocked_local_variable?(name.to_sym)
+    end
+    
+    def local_variables
+      @local_variables.keys + (@parent&.unlocked_local_variables).to_a
+    end
+    
+    def set_local_variable(name, value)
+      name = name.to_sym
+      if !@local_variables.key?(name) && @parent&.unlocked_local_variable?(name)
+        @parent&.set_local_variable(name, value)
+      else
+        @local_variables[name] = value
+      end
+    end
+    
+    def unlocked_local_variable(name)
+      name = name.to_sym
+      @local_variables.filter{|k| !@locked_variables.include?(k)}[name] || @parent&.unlocked_local_variable(name)
+    end
+
+    def unlocked_local_variable?(name)
+      name = name.to_sym
+      @local_variables.filter{|k,_v| !@locked_variables.include?(k)}.key?(name) ||
+        !!@parent&.unlocked_local_variable?(name)
+    end
+    
+    def unlocked_local_variables
+      @local_variables.keys.filter{|k| !@locked_variables.include?(k)} + (@parent&.unlocked_local_variables).to_a
+    end
+
+    def lock_variable(name)
+      n = name.to_sym
+      raise NameError.new("#{name} is not a local variable", n) unless @local_variables.key?(n)
+      @locked_variables << n unless @locked_variables.include?(n)
+      n
+    end
+    
+    def clear_local_variable(name)
+      @local_variables.delete(name.to_sym)
+      name.to_sym
     end
 
+    ###########################
+    # Generic traversal methods
+    ###########################
+
     def root?
       parent.nil?
     end
@@ -101,18 +240,6 @@ class Environment
       dir
     end
 
-    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
-    end
-
-    # might not be useful
-    def clear_local_method(name)
-      @local_methods.delete(name)
-      name
-    end
-
     def to_s
       @path.path
     end
@@ -121,10 +248,9 @@ 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)
+  elsif which(m.to_s) || ($env.alias?(m) && !$env.aliasing_disabled)
     $env.dispatch(m, *args)
   else
     super
@@ -132,3 +258,4 @@ def self.method_missing(m, *args, &block)
 end
 
 $env = Environment.new
+$env.chdir(Dir.pwd)

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)

data/lib/rash/pipeline.rb

@@ -4,6 +4,10 @@ class Environment
     @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
@@ -14,9 +18,21 @@ class Environment
     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
@@ -38,28 +54,81 @@ class Environment
     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
-      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}
-      @active_pipelines.clear
+      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
@@ -73,6 +142,23 @@ class Environment
     @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
 
@@ -103,6 +189,10 @@ class Environment
 end
 
 
-def in_pipeline(&block) 
-  $env.make_pipeline(&block)
+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

@@ -67,7 +67,7 @@ class Environment
   end
 
   def reset_stdin
-    $stdin.close unless standard_stream>($stdin)
+    $stdin.close unless standard_stream?($stdin)
     $stdin = DEFAULT_IO[:in]
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rash-command-shell
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.2.2
 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
@@ -43,7 +43,9 @@ files:
 homepage: https://github.com/KellenWatt/rash
 licenses:
 - MIT
-metadata: {}
+metadata:
+  documentation_uri: https://github.com/KellenWatt/rash/wiki
+  wiki_uri: https://github.com/KellenWatt/rash/wiki
 post_install_message:
 rdoc_options: []
 require_paths: