rash-command-shell 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19cb922bc55b83424f375e375c2015dff74690720b4d611357646bfd11e04c44
+  data.tar.gz: 48ce02ad077cd0a89a7fc62987907cbfc0ca80997e398c6e9699ac4beacf4521
+SHA512:
+  metadata.gz: 6e1d9cd6e7270bd206d79db56b9ca20e2bab9b976c7e76b835c3af078e9a16816714807b8c96eafdc5f403369404bce243c31105bd33869fabb5fbffba65adf7
+  data.tar.gz: 6e36ba48448f4aed666807150a8819855ccb2e8802093f56cfc6f357277cd24a6ff91c43de0889affd15fddd2d642b1601ffcd7c347949766a434c124b1d7b1b

data/bin/rash

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+if ARGV.size == 0
+  exec("irb", "-r", "rash")
+else
+  require "rash"
+  file = ARGV.shift
+  load file
+end

data/lib/rash.rb

@@ -0,0 +1,130 @@
+class Environment
+  
+  attr_reader :aliasing_disabled
+  attr_reader :superuser_mode
+
+  def initialize
+    common_init
+  end
+
+  def chdir(dir = nil)
+    old = @working_directory
+    Dir.chdir(dir.nil? ? "~" : dir.to_s)
+    @working_directory = Dir.pwd
+    ENV["OLDPWD"] = old.to_s
+    Dir.pwd
+  end
+  
+  def add_path(path) 
+    ENV["PATH"] += File::PATH_SEPARATOR + (path.respond_to?(:path) ? path.path : path.to_s)
+  end
+
+  def method_missing(m, *args, &block) 
+    if args.length == 0 && !block_given?
+      ENV[m.to_s.upcase]
+    elsif m.to_s[-1] == "=" && args.length == 1  && !block_given?
+      ENV[m.to_s.upcase.delete_suffix("=")] = args[0].to_s
+    else
+      super
+    end
+  end
+
+  def as_superuser(&block)
+    @superuser_mode = true
+    begin
+      block.call
+    ensure
+      @superuser_mode = false
+    end
+  end
+  
+  private
+
+  def common_init
+    @working_directory = Dir.pwd
+
+    @aliases = {}
+    @aliasing_disabled = false
+    @active_jobs = []
+
+    @prompt = {
+      AUTO_INDENT: true,
+      RETURN: ""
+    }
+    ENV["RASHDIR"] = File.dirname(__FILE__)
+  end
+end
+
+require_relative "rash/redirection"
+require_relative "rash/aliasing"
+require_relative "rash/jobcontrol"
+
+$env = Environment.new
+
+
+# note for later documentation: any aliases of cd must be functions, not 
+# environmental aliases. Limitation of implementation.
+def cd(dir = nil)
+  $env.chdir(dir)
+end
+
+
+def run(file, *args)
+  filename = file.to_s
+  exe = (filename.start_with?("/") ? filename : File.expand_path(filename.strip))
+  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})
+end
+
+
+# Defines `bash` psuedo-compatibility. Filesystem effects happen like normal 
+# and environmental variable changes are copied
+def sourcesh(file) 
+  bash_env = lambda do |cmd = nil|
+    tmpenv = `#{cmd + ';' if cmd} printenv`
+    tmpenv.split("\n").grep(/[a-zA-Z0-9_]+=.*/).map {|l| l.split("=")}
+  end
+  bash_source = lambda do |f|
+    Hash[bash_env.call("source #{File.realpath f}") - bash_env.()]
+  end
+
+  bash_source.call(file).each {|k,v| ENV[k] = v if k != "SHLVL" && k != "_"}
+end
+
+
+def which(command)
+  cmd = File.expand_path(command)
+  return cmd if File.executable?(cmd) && !File.directory?(cmd)
+  
+  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+  ENV['PATH'].split(File::PATH_SEPARATOR).each do |pt|
+    path = File.expand_path(pt)
+    exts.each do |ext|
+      exe = File.join(path, "#{command}#{ext}")
+      return exe if File.executable?(exe) && !File.directory?(exe)
+    end
+  end
+  nil
+end
+
+
+# Note that I defy convention and don't define `respond_to_missing?`. This
+# is because doing so screws with irb.
+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}) 
+    else
+      system(*$env.resolve_alias(m), *args.flatten.map{|a| a.to_s}, {out: $stdout, err: $stderr, in: $stdin})
+    end
+  else
+    super
+  end
+end
+
+
+run_command_file = "#{$env.HOME}/.rashrc"
+load run_command_file if File.file?(run_command_file)

data/lib/rash/aliasing.rb

@@ -0,0 +1,55 @@
+class Environment
+  def make_alias(new_func, old_func)
+    @aliases[new_func.to_sym] = old_func.to_s.split(" ")
+  end
+
+  def clear_alias(func) 
+    @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)
+  end
+
+  def without_aliasing
+    old_aliasing = @aliasing_disabled
+    @aliasing_disabled = true
+    if block_given?
+      begin
+        yield
+      ensure
+        @aliasing_disabled = old_aliasing
+      end
+    end
+  end
+
+  def with_aliasing
+    old_aliasing = @aliasing_disabled
+    @aliasing_disabled = false
+    if block_given?
+      begin
+        yield
+      ensure
+        @aliasing_disabled = old_aliasing
+      end
+    end
+  end
+end

data/lib/rash/ext/filesystem.rb

@@ -0,0 +1,138 @@
+class Environment
+
+  RASH_LOCAL_FILE = ".rashrc.local"
+
+  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))
+    ENV["OLDPWD"] = old.to_s
+    Dir.pwd
+  end
+
+  def local_def(name, &block)
+    @working_directory.add_local_method(name.to_sym, &block)
+  end
+
+  def local_undef(name)
+    @working_directory.clear_local_method(name.to_sym)
+  end
+
+  def local_method?(name)
+    @working_directory.local_methods.key?(name.to_sym)
+  end
+
+  def local_call(name, *args, &block)
+    @working_directory.local_methods[name.to_sym].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)
+    abs_to = File.expand_path(to)
+    raise SystemCallError(from, Errno::ENOENT::Errno) unless Dir.exists?(abs_from) 
+    raise SystemCallError(to, Errno::ENOENT::Errno) unless Dir.exists?(abs_to)
+    
+    from_parts = (abs_from == "/" ? [""] : abs_from.split(File::SEPARATOR))
+    to_parts = (abs_to == "/" ? [""] : abs_to.split(File::SEPARATOR))
+    common_path = from_parts.filter.with_index {|p, i| p == to_parts[i]}
+    
+    from_parts = from_parts.drop(common_path.size)
+    to_parts = to_parts.drop(common_path.size)
+
+    from_parts.each do |p|
+      @working_directory.add_parent(File.expand_path("..")) if @working_directory.root?
+      @working_directory = @working_directory.parent
+      Dir.chdir(@working_directory.to_s)
+    end
+
+    to_parts.each do |p|
+      @working_directory = @working_directory.child(File.expand_path(p, @working_directory.to_s))
+      Dir.chdir(@working_directory.to_s)
+      # rashrc_local = @working_directory.to_s + File::SEPARATOR + RASH_LOCAL_FILE
+      load RASH_LOCAL_FILE if File.exists?(RASH_LOCAL_FILE) && !File.directory?(RASH_LOCAL_FILE)
+    end
+  
+    Dir.pwd
+  end
+
+  class Directory
+    attr_reader :local_methods
+    attr_reader :parent, :children
+
+    def self.root(dir)
+      Directory.new(nil, dir)
+    end
+
+    def initialize(parent, dir)
+      @path = Dir.new(dir)
+      @parent = parent
+      @children = []
+      @local_methods = parent&.local_methods.dup || {}
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def add_parent(dir)
+      @parent = Directory.root(dir)
+      @parent.add_child(self.to_s)
+      @parent
+    end
+
+    def child(path)
+      ch = @children.find {|c| c.to_s == path}
+      ch = add_child(path) unless ch
+      ch
+    end
+
+    def add_child(path)
+      dir = Directory.new(self, path)
+      @children << dir
+      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
+  end
+end
+
+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
+  else
+    super
+  end
+end
+
+$env = Environment.new

data/lib/rash/jobcontrol.rb

@@ -0,0 +1,21 @@
+class Environment
+  def jobs
+    @active_jobs.keep_if {|pid| Process.kill(0, pid) rescue false}
+  end
+
+  def async(&block)
+    pid = fork {
+      block.call
+      exit!(true)
+    }
+    @active_jobs << pid
+    Process.detach(pid)
+    pid
+  end
+end
+
+def as_background(&block)
+  $env.async(&block)
+end
+  
+

data/lib/rash/prompt/irb.rb

@@ -0,0 +1,80 @@
+class Environment
+  attr_reader :prompt
+  def standard_prompt=(prompt)
+    @prompt[:prompt_i] = case prompt
+                         when Proc
+                           prompt
+                         else
+                           err_msg = "expecting stringable type or method that resolves to string"
+                           raise ArgumentError.new(err_msg) unless prompt.respond_to?(:to_s)
+                           lambda {prompt.to_s}
+                         end
+    @prompt[:PROMPT_I] = "".tap {|s| def s.dup; $env.prompt[:prompt_i].call; end}
+  end
+
+  def indent_prompt=(prompt)
+    @prompt[:prompt_n] = case prompt
+                         when Proc
+                           prompt
+                         else
+                           err_msg = "expecting stringable type or method that resolves to string"
+                           raise ArgumentError.new(err_msg) unless prompt.respond_to?(:to_s)
+                           lambda {prompt.to_s}
+                         end
+
+    @prompt[:PROMPT_N] = "".tap {|s| def s.dup; $env.prompt[:prompt_n].call; end}
+  end
+
+  def string_prompt=(prompt)
+    @prompt[:prompt_s] = case prompt
+                         when Proc
+                           prompt
+                         else
+                           err_msg = "expecting stringable type or method that resolves to string"
+                           raise ArgumentError.new(err_msg) unless prompt.respond_to?(:to_s)
+                           lambda {prompt.to_s}
+                         end
+
+    @prompt[:PROMPT_S] = "".tap {|s| def s.dup; $env.prompt[:prompt_s].call; end}
+  end
+
+  def continued_prompt=(prompt)
+    @prompt[:prompt_c] = case prompt
+                         when Proc
+                           prompt
+                         else
+                           err_msg = "expecting stringable type or method that resolves to string"
+                           raise ArgumentError.new(err_msg) unless prompt.respond_to?(:to_s)
+                           lambda {prompt.to_s}
+                         end
+
+    @prompt[:PROMPT_C] = "".tap {|s| def s.dup; $env.prompt[:prompt_c].call; end}
+  end
+
+  # This method can only be run from .rashrc. Anywhere else and it will simply do nothing
+  def return_value_header=(prompt)
+    @prompt[:RETURN] = prompt
+  end
+
+  def use_irb_prompt
+    if $0 == "irb"
+      IRB.conf[:PROMPT][:RASH] = @prompt
+      IRB.conf[:PROMPT_MODE] = :RASH
+    end
+  end
+end
+
+if $0 == "irb"
+  IRB.conf[:PROMPT][:RASH] = {
+    :PROMPT_I => "rash $",
+    :PROMPT_N => "rash ",
+    :PROMPT_S => "rash%l>",
+    :PROMPT_C => "rash >",
+    :RETURN => "%s\n" # used to printf
+  }
+  IRB.conf[:PROMPT_MODE] = :RASH
+  IRB.conf[:SAVE_HISTORY] = 1000
+  IRB.conf[:AP_NAME] = "rash"
+  IRB.conf[:AUTO_INDENT] = true
+end
+

data/lib/rash/redirection.rb

@@ -0,0 +1,151 @@
+class Environment
+
+  DEFAULT_IO = {in: STDIN, out: STDOUT, err: STDERR}
+
+  def reset_io
+    reset_stdout
+    reset_stderr
+    reset_stdin
+  end
+
+  def stdout=(file)
+    $stdout.flush
+    old_stdout = $stdout
+    case file
+    when String
+      $stdout = File.new(file, "w")
+    when :out
+      $stdout = STDOUT
+    when :err
+      $stdout = STDERR
+    else
+      raise ArgumentError.new("not an output stream - #{file}") unless file.is_a?(IO)
+      $stdout = file
+    end
+    old_stdout.close unless standard_stream?(old_stdout)
+  end
+
+  def reset_stdout
+    $stdout.flush
+    $stdout.close unless standard_stream?($stdout)
+    $stdout = DEFAULT_IO[:out]
+  end
+
+  def stderr=(file)
+    $stderr.flush
+    old_stderr = $stderr
+    case file
+    when String
+      $stderr = File.new(file, "w")
+    when :out
+      $stderr = STDOUT
+    when :err
+      $stderr = STDERR
+    else
+      raise ArgumentError.new("not an output stream - #{file}") unless file.is_a?(IO)
+      $stderr = file
+    end
+    old_stderr.close unless standard_stream?(old_stderr)
+  end
+  
+  def reset_stderr
+    $stderr.flush
+    $stderr.close unless standard_stream?($stderr)
+    $stderr = DEFAULT_IO[:err]
+  end
+
+  def stdin=(file)
+    old_stdin = $stdin
+    case file
+    when String
+      $stdin = File.new(file, "r")
+    when :in
+      $stdin = STDIN
+    else
+      raise ArgumentError.new("not an input stream - #{file}") unless file.is_a?(IO)
+      $stdin = file
+    end
+    old_stdin.close unless standard_stream?(old_stdin)
+  end
+
+  def reset_stdin
+    $stdin.close unless standard_stream>($stdin)
+    $stdin = DEFAULT_IO[:in]
+  end
+
+  private
+  
+  def standard_stream?(f)
+    DEFAULT_IO.values.include?(f)
+  end
+end
+
+# If you want to append, you need to get the file object yourself.
+# Check if not flushing immediately is a concern. If so, set $stdout.sync for files
+def with_stdout_as(file = STDOUT)
+  $env.stdout = file
+  if block_given?
+    begin
+      yield $stdout
+    ensure
+      $env.reset_stdout
+    end
+  end
+end
+
+def with_stderr_as(file = STDERR)
+  $env.stderr = file
+  if block_given?
+    begin
+      yield $stderr
+    ensure
+      $env.reset_stderr
+    end
+  end 
+end
+
+def with_stdin_as(file = STDIN)
+  $env.stdin = file
+  if block_given?
+    begin
+      yield $stdin
+    ensure
+      $env.reset_stdin
+    end
+  end
+end
+
+def with_stdout_as_stderr
+  $env.stdout = $stderr
+  if block_given?
+    begin
+      yield $stdout
+    ensure
+      $env.reset_stdout
+    end
+  end
+end
+
+def with_stderr_as_stdout
+  $env.stderr = $stdout
+  if block_given?
+    begin
+      yield $stderr
+    ensure
+      $env.reset_stderr
+    end
+  end
+end
+
+def with_all_out_as(file)
+  $env.stdout = file
+  $env.stderr = $stdout
+  if block_given?
+    begin
+      yield $stdout
+    ensure
+      $env.reset_stdout
+      $env.reset_stderr
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: rash-command-shell
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kellen Watt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: A Ruby-based shell
+email:
+executables:
+- rash
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rash
+- lib/rash.rb
+- lib/rash/aliasing.rb
+- lib/rash/ext/filesystem.rb
+- lib/rash/jobcontrol.rb
+- lib/rash/prompt/irb.rb
+- lib/rash/redirection.rb
+homepage: https://github.com/KellenWatt/rash
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Rash Ain't SH
+test_files: []