ruby-shell 2.6.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c448c172084960387cf539a563720fdc291cac640eb74a5d34fa4b65bc21b966
-  data.tar.gz: bf946b66b54703b33e8f001739ae5b143475525b2faa7e6428f027a7303475de
+  metadata.gz: 35706aa5efb5ce661a102e1c6a5b22638a750b567f41930b683f239d42386964
+  data.tar.gz: 164ea239fc7081182c031cf002dc7e3c64696536f5795057e24ba027a899f998
 SHA512:
-  metadata.gz: f098198470e145eae96a6d59438279d38f786129b1b45370b407403a4de8c11d595304b5d975b0d590aca5ae8bf4e5cab2b9311a3c3806b6d2b41d6cbd307a46
-  data.tar.gz: e682544786e24f145682628c7598e1b848a99f3db2e8df910adeb3b30f7c422d15f50c80326b9d7d02a8d7ca11fef8d8d50b332ff7b327b614fbb21dd79b319a
+  metadata.gz: 952d3ba93d41715d50a6b8a4f669f8f670f3b5c403f300f24fd7a28fe9cb432a4f66b2ba747fb9ddbab6e3ec6a33ec94113c3e499ee6014a25ec6d7861266929
+  data.tar.gz: 41ea80063e2fd754acd4a449ddac1f418bb3450b10bd70a9a99432159fefbcf2002bf6964638cd03079585088974d382c0978d830eb3beb8f28936cc2bc2cf65

data/.rshrc

@@ -1,29 +1,48 @@
 # vim: set ft=ruby sw=2 sts=2 et :
+# Example config file for rsh (.rshrc)
 
 # ENVIRONMENT
-#@lscolors       = "/home/geir/.local/share/lscolors.sh"
-ENV["EDITOR"]   = "vim"
-ENV["MANPAGER"] = "vim +MANPAGER -"
+@lscolors            = "/home/geir/.local/share/lscolors.sh"
+ENV["EDITOR"]        = "vim"
+ENV["IRCNAME"]       = "Geir Isene"                  
+ENV["IRCNICK"]       = "isene"                       
+ENV["LESS"]          = "-M-Q-r"
+ENV["LESSCHARDEF"]   = "8bcccbcc13b.4b95.33b."   
+ENV["LESSCHARSET"]   = "latin1"                  
+ENV["LESSEDIT"]      = "%E ?lt+%lt. %f"             
+ENV["LESSOPEN"]      = "| /home/geir/bin/lesspipe %s"    
+ENV["MANPAGER"]      = "vim +MANPAGER -"
+ENV["PAGER"]         = "less"                          
+ENV["TZ"]            = 'Europe/Oslo'
+ENV["VISUAL"]        = "vim"                        
+ENV["XDG_DATA_HOME"] = "/home/geir/.local/share"
+ENV["PATH"]         += ":/home/geir/bin"
 
 # PROMPT
 if @user == "root"
-  @prompt = "#{@user}@#{@node}".c(160).b + ":".c(255) + " #{Dir.pwd}/".c(196) + " ".c(7)
+  @prompt = @user.c(1).b + "@#{@node}".c(1) 
 else
-  @prompt = "#{@user}@#{@node}".c(46) + ":".c(255) + " #{Dir.pwd}/".c(196) + " ".c(7)
+  @prompt = @user.c(2).b + "@#{@node}".c(2)
 end
+@prompt += ":".c(252) + " #{Dir.pwd}/".c(3) + " ".c(255)
 
 # THEME
-@c_prompt    = 196  # Color for basic prompt
-@c_cmd       = 48   # Color for valid command
-@c_nick      = 51   # Color for matching nick
-@c_gnick     = 87   # Color for matching gnick
-@c_path      = 208  # Color for valid path
-@c_switch    = 148  # Color for switches/options
-@c_tabselect = 207  # Color for selected tabcompleted item
-@c_taboption = 244  # Color for unselected tabcompleted item
-@c_stamp     = 244  # Color for time stamp/command
+#@c_prompt    = 196  # Color for basic prompt
+#@c_cmd       = 84   # Color for valid command
+#@c_nick      = 87   # Color for matching nick
+#@c_gnick     = 123  # Color for matching gnick
+#@c_path      = 208  # Color for valid path
+#@c_switch    = 148  # Color for switches/options
+#@c_tabselect = 220  # Color for selected tabcompleted item
+#@c_taboption = 94   # Color for unselected tabcompleted item
+#@c_stamp     = 244  # Color for time stamp/command
+
+def pre_cmd
+end
+
+def post_cmd
+end
 
 # NICKS AND HISTORY
-@nick = {"ls"=>"ls --color -F"}
-@gnick = {}
+@nick = {"ls"=>"ls --color -F", "l"=>"less", "v"=>"vim", "gu"=>"gitmagic -u", "gc"=>"git clone", "gs"=>"git status .", "vv"=>"vim ~/.vimrc", "vr"=>"vim ~/.rshrc"}
 @history = []

data/README.md

@@ -18,6 +18,8 @@ Or simply `gem install ruby-shell`.
 [![rsh screencast](/img/rsh-screencast.png)](https://youtu.be/4P2z8oSo1u4)
 
 # Features
+
+## Core Shell Features
 * Aliases (called nicks in rsh) - both for commands and general nicks
 * Syntax highlighting, matching nicks, system commands and valid dirs/files
 * Tab completions for nicks, system commands, command switches and dirs/files
@@ -30,6 +32,22 @@ Or simply `gem install ruby-shell`.
 * rsh specific commands and full set of Ruby commands available via :<command>
 * All colors are themeable in .rshrc (see github link for possibilities)
 * Copy current command line to primary selection (paste w/middle button) with `Ctrl-y`
+
+## NEW in v2.7.0 - Ruby Functions ⭐
+* **Define Ruby functions as shell commands**: `:defun 'weather(*args) = system("curl -s wttr.in/#{args[0] || \"oslo\"}")'`
+* **Call like any shell command**: `weather london`
+* **Full Ruby power**: Access to Ruby stdlib, file operations, JSON parsing, web requests, etc.
+* **Function management**: `:defun?` to list, `:defun '-name'` to remove
+* **Syntax highlighting**: Ruby functions highlighted in bold
+
+## Advanced Shell Features
+* **Job Control**: Background jobs (`command &`), job suspension (`Ctrl-Z`), process management
+* **Job Management**: `:jobs`, `:fg [id]`, `:bg [id]` commands
+* **Command Substitution**: `$(date)` and backtick support  
+* **Variable Expansion**: `$HOME`, `$USER`, `$?` (exit status)
+* **Conditional Execution**: `cmd1 && cmd2 || cmd3`
+* **Brace Expansion**: `{a,b,c}` expands to `a b c`
+* **Login Shell Support**: Proper signal handling and profile loading
   
 Special functions/integrations:
 * Use `r` to launch rtfm (https://github.com/isene/RTFM) - if you have it installed
@@ -42,9 +60,18 @@ Special commands:
 * `:gnick 'h = /home/me'` to make a general alias (h) point to something (/home/me)
 * `:nick?` will list all command nicks and general nicks (you can edit your nicks in .rshrc)
 * `:history` will list the command history, while `:rmhistory` will delete the history
+* `:jobs` will list background jobs, `:fg [job_id]` brings jobs to foreground, `:bg [job_id]` resumes stopped jobs
+* `:defun 'func(args) = code'` defines Ruby functions callable as shell commands
+* `:defun?` lists all user-defined functions, `:defun '-func'` removes functions
 * `:version` Shows the rsh version number and the last published gem file version
 * `:help` will display this help text
 
+Background jobs:
+* Use `command &` to run commands in background
+* Use `:jobs` to list active background jobs  
+* Use `:fg` or `:fg job_id` to bring jobs to foreground
+* Use `Ctrl-Z` to suspend running jobs, `:bg job_id` to resume them
+
 ## Moving around
 While you `cd` around to different directories, you can see the last 10 directories visited via the command `:dirs` or the convenient shortcut `#`. Entering the number in the list (like `6` and ENTER) will jump you to that directory. Entering `-` will jump you back to the previous dir (equivalent of `1`. Entering `~` will get you to your home dir. If you want to bookmark a special directory, you can do that via a general nick like this: `:gnick "x = /path/to/a/dir/"` - this would bookmark the directory to the single letter `x`.
 
@@ -60,7 +87,60 @@ Hitting Shift-TAB will do a similar search through the command history - but wit
 If you press `ENTER` after writing or tab-completing to a file, rsh will try to open the file in the user's EDITOR of choice (if it is a valid text file) or use `xdg-open` to open the file using the correct program. If you, for some reason want to use `run-mailcap` instead of `xdg-open` as the file opener, simply add `@runmailcap = true` to your `.rshrc`.
 
 ## History
-Show the history with `:history`. Redo a history command with an exclamation mark and the number corresponding to the position in the history, like `!5` would do the 5th history command again.
+Show the history with `:history`. Redo a history command with an exclamation mark and the number corresponding to the position in the history, like `!5` would do the 5th history command again. To delete a specific entry in history, hit `UP` and move up to that entry and hit `Ctrl-k` (for "kill").
+
+## Ruby Functions - The Power Feature ⭐
+
+rsh's unique Ruby functions let you define custom shell commands using the full power of Ruby:
+
+### Basic Examples
+```bash
+# File operations
+:defun 'count(*args) = puts Dir.glob(args[0] || "*").length'
+count *.rb
+
+# System monitoring  
+:defun 'mem = puts `free -h`.lines[1].split[2]'
+mem
+
+# JSON pretty-printing
+:defun 'jsonpp(file) = require "json"; puts JSON.pretty_generate(JSON.parse(File.read(file)))'
+jsonpp config.json
+```
+
+### Advanced Examples
+```bash
+# Network tools
+:defun 'ports = puts `netstat -tlnp`.lines.grep(/LISTEN/).map{|l| l.split[3]}'
+ports
+
+# Git helpers
+:defun 'branches = puts `git branch`.lines.map{|l| l.strip.sub("* ", "")}'
+branches
+
+# Directory analysis
+:defun 'sizes(*args) = Dir.glob(args[0] || "*").each{|f| puts "#{File.size(f).to_s.rjust(8)} #{f}" if File.file?(f)}'
+sizes
+
+# Weather (using external API)
+:defun 'weather(*args) = system("curl -s wttr.in/#{args[0] || \"oslo\"}")'
+weather london
+```
+
+### Function Management
+```bash
+:defun?           # List all defined functions
+:defun '-myls'    # Remove a function
+```
+
+Ruby functions have access to:
+- Full Ruby standard library
+- Shell environment variables via `ENV`
+- rsh internals like `@history`, `@dirs`
+- File system operations
+- Network requests
+- JSON/XML parsing
+- And everything else Ruby can do!
 
 ## Integrations
 rsh is integrated with the [rtfm file manager](https://github.com/isene/RTFM), with [fzf](https://github.com/junegunn/fzf) and with the programming language [XRPN](https://github.com/isene/xrpn). 

data/bin/rsh

@@ -8,7 +8,7 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rsh
 # License:    Public domain
-@version    = "2.6.1"
+@version    = "2.7.0" # Major release: Ruby functions, job control, command substitution, login shell support
 
 # MODULES, CLASSES AND EXTENSIONS
 class String # Add coloring to strings (with escaping for Readline)
@@ -50,18 +50,6 @@ module Cursor # Terminal cursor movement ANSI codes (thanks to https://github.co
     row, col = self.pos
     return col
   end
-  def up(n = nil) # Move cursor up by n
-    print(CSI + "#{(n || 1)}A")
-  end
-  def down(n = nil) # Move the cursor down by n
-    print(CSI + "#{(n || 1)}B")
-  end
-  def left(n = nil) # Move the cursor backward by n
-    print(CSI + "#{n || 1}D")
-  end
-  def right(n = nil) # Move the cursor forward by n
-    print(CSI + "#{n || 1}C")
-  end
   def col(n = nil) # Cursor moves to nth position horizontally in the current line
     print(CSI + "#{n || 1}G")
   end
@@ -71,24 +59,12 @@ module Cursor # Terminal cursor movement ANSI codes (thanks to https://github.co
   def next_line # Move cursor down to beginning of next line
     print(CSI + 'E' + CSI + "1G")
   end
-  def prev_line # Move cursor up to beginning of previous line
-    print(CSI + 'A' +  CSI + "1G")
-  end
-  def clear_char(n = nil) # Erase n characters from the current cursor position
-    print(CSI + "#{n}X")
-  end
   def clear_line # Erase the entire current line and return to beginning of the line
     print(CSI + '2K' +  CSI + "1G")
   end
-  def clear_line_before # Erase from the beginning of the line up to and including the current cursor position.
-    print(CSI + '1K')
-  end
   def clear_line_after # Erase from the current position (inclusive) to the end of the line
     print(CSI + '0K')
   end
-  def scroll_up # Scroll display up one line
-    print(ESC + 'M')
-  end
   def scroll_down # Scroll display down one line
     print(ESC + 'D')
   end
@@ -96,12 +72,6 @@ module Cursor # Terminal cursor movement ANSI codes (thanks to https://github.co
     print(CSI + 'J')
   end
 end
-def stdin_clear
-  begin
-    $stdin.getc while $stdin.ready?
-  rescue
-  end
-end
 
 # INITIALIZATION
 begin # Requires
@@ -137,6 +107,9 @@ begin # Initialization
   @runmailcap  = false
   # Variable initializations
   @dirs        = ["."]*10
+  @jobs        = {}                       # Background jobs tracking
+  @job_id      = 0                        # Job counter
+  @last_exit   = 0                        # Last command exit status
   def pre_cmd; end                        # User-defined function to be run BEFORE command execution
   def post_cmd; end                       # User-defined function to be run AFTER  command execution
 end
@@ -176,9 +149,24 @@ end
   * `:gnick 'h = /home/me'` to make a general alias (h) point to something (/home/me)
   * `:nick?` will list all command nicks and general nicks (you can edit your nicks in .rshrc)
   * `:history` will list the command history, while `:rmhistory` will delete the history
+  * `:jobs` will list background jobs, `:fg [job_id]` brings jobs to foreground, `:bg [job_id]` resumes stopped jobs
+  * `:defun 'func(args) = code'` defines Ruby functions callable as shell commands
+  * `:defun?` lists all user-defined functions, `:defun '-func'` removes functions
   * `:version` Shows the rsh version number and the last published gem file version
   * `:help` will display this help text
   
+  Background jobs:
+  * Use `command &` to run commands in background
+  * Use `:jobs` to list active background jobs  
+  * Use `:fg` or `:fg job_id` to bring jobs to foreground
+  * Use `Ctrl-Z` to suspend running jobs, `:bg job_id` to resume them
+  
+  Ruby Functions:
+  * Define with `:defun 'myls(*args) = Dir.glob("*").each {|f| puts f}'`
+  * Call like any shell command: `myls` or `myls arg1 arg2`
+  * Functions have full access to Ruby stdlib and rsh internals
+  * Remove with `:defun '-myls'` and list with `:defun?`
+  
 HELP
 
 # GENERIC FUNCTIONS
@@ -254,13 +242,13 @@ def getchr # Process key presses
   when "" then chr = "C-T"
   when "" then chr = "C-Y"
   when "" then chr = "WBACK"
+  when "\u001A" then chr = "C-Z"
   when "" then chr = "LDEL"
   when "\r" then chr = "ENTER"
   when "\t" then chr = "TAB"
   when /[[:print:]]/  then chr = c
   else chr = ""
   end
-  #stdin_clear
   return chr
 end
 def getstr # A custom Readline-like function
@@ -398,6 +386,14 @@ def getstr # A custom Readline-like function
     when 'C-Y'   # Copy command line to primary selection
       system("echo -n '#{@history[0]}' | xclip")
       puts "\n#{Time.now.strftime("%H:%M:%S")}: Copied to primary selection (paste with middle buttoni)".c(@c_stamp)
+    when 'C-Z'   # Suspend current process (background job)
+      if @current_pid
+        puts "\n[#{@job_id}] Suspended #{@current_pid}"
+        Process.kill("STOP", @current_pid)
+        @jobs[@job_id] = {pid: @current_pid, cmd: @cmd, status: :stopped}
+      else
+        puts "\nNo active job to suspend"
+      end
     when 'C-K'   # Kill/delete that entry in the history
       @history.delete_at(@stk)
       @stk -= 1
@@ -433,20 +429,20 @@ def getstr # A custom Readline-like function
       @pos += 1
     end
   end
-  #@c.col(@pos0 + @history[0].length)
   @c.clear_screen_down
 end
 def tab(type)
   i = 0
   chr = ""
   @tabarray = []
-  @pretab = @history[0][0...@pos].to_s        # Extract the current line up to cursor
-  @postab = @history[0][@pos..].to_s          # Extract the current line from cursor to end
-  @c_row, @c_col = @c.pos                     # Get cursor position
-  @tabstr = @pretab.split(/[|, ]/).last.to_s  # Get the sustring that is being tab completed
-  @tabstr = "" if @pretab[-1] =~ /[ |]/       # Tab from nothing if tabbing starts with space or pipe
-  @tabstr = @pretab if type == "hist"         # Searching for matches with whole string in history
-  @pretab = @pretab.delete_suffix(@tabstr)
+  @pretab   = @history[0][0...@pos].to_s        # Extract the current line up to cursor
+  @postab   = @history[0][@pos..].to_s          # Extract the current line from cursor to end
+  @c_row, @c_col = @c.pos                       # Get cursor position
+  @row0     = @c_row                            # Save original row
+  @tabstr   = @pretab.split(/[|, ]/).last.to_s  # Get the sustring that is being tab completed
+  @tabstr   = "" if @pretab[-1] =~ /[ |]/       # Tab from nothing if tabbing starts with space or pipe
+  @tabstr   = @pretab if type == "hist"         # Searching for matches with whole string in history
+  @pretab   = @pretab.delete_suffix(@tabstr)
   type = "switch" if @tabstr[0] == "-"
   while chr != "ENTER"
     case type
@@ -547,6 +543,7 @@ def tab(type)
     end
   end
   @c.clear_screen_down
+  @row0 = @c_row
   @c.row(@c_row)
   @c.col(@c_col)
   @history[0] = @newhist0
@@ -585,6 +582,8 @@ def cmd_check(str) # Check if each element on the readline matches commands, nic
       el.c(@c_nick)
     elsif @gnick.include?(el)
       el.c(@c_gnick)
+    elsif self.respond_to?(el) && singleton_class.instance_methods(false).include?(el.to_sym)
+      el.c(@c_nick).b  # Ruby functions in bold nick color
     elsif el[0] == "-"
       el.c(@c_switch)
     else
@@ -658,12 +657,165 @@ def dirs
     puts "#{i}: #{e}"
   end
 end
+def jobs
+  puts "Active jobs:"
+  @jobs.each do |id, job|
+    begin
+      Process.kill(0, job[:pid])  # Check if process exists
+      puts "[#{id}] #{job[:pid]} #{job[:status]} #{job[:cmd]}"
+    rescue Errno::ESRCH
+      @jobs.delete(id)  # Clean up dead jobs
+    end
+  end
+end
+def fg(job_id = nil)
+  job_id ||= @jobs.keys.max
+  return puts "No jobs" if job_id.nil?
+  job = @jobs[job_id]
+  return puts "Job #{job_id} not found" unless job
+  puts "Bringing job #{job_id} to foreground: #{job[:cmd]}"
+  begin
+    if job[:status] == :stopped
+      Process.kill("CONT", job[:pid])
+    end
+    @current_pid = job[:pid]
+    Process.wait(job[:pid])
+    @jobs.delete(job_id)
+    @current_pid = nil
+  rescue Errno::ECHILD, Errno::ESRCH
+    @jobs.delete(job_id)
+    @current_pid = nil
+  end
+end
+def bg(job_id = nil)
+  job_id ||= @jobs.keys.max
+  return puts "No jobs" if job_id.nil?
+  job = @jobs[job_id]
+  return puts "Job #{job_id} not found" unless job
+  return puts "Job #{job_id} already running" if job[:status] == :running
+  puts "Resuming job #{job_id} in background: #{job[:cmd]}"
+  begin
+    Process.kill("CONT", job[:pid])
+    @jobs[job_id][:status] = :running
+  rescue Errno::ESRCH
+    @jobs.delete(job_id)
+    puts "Job #{job_id} no longer exists"
+  end
+end
+def defun(func_def)  # Define a Ruby function like: `:defun "myls(*args) = Dir.glob('*').each {|f| puts f}"`
+  if func_def.match(/^\s*-/)
+    # Remove function
+    func_name = func_def.sub(/^\s*-/, '')
+    if self.respond_to?(func_name)
+      singleton_class.remove_method(func_name.to_sym)
+      puts "Function '#{func_name}' removed"
+    else
+      puts "Function '#{func_name}' not found"
+    end
+  else
+    # Define function
+    # Extract function name, params, and body from "name(params) = body" format
+    if func_def =~ /^(\w+)\s*\(([^)]*)\)\s*=\s*(.+)$/
+      func_name = $1
+      func_params = $2
+      func_body = $3
+      
+      begin
+        eval_code = "def #{func_name}(#{func_params}); #{func_body}; end"
+        puts "  DEBUG: Evaluating: #{eval_code}" if ENV['RSH_DEBUG']
+        singleton_class.class_eval(eval_code)
+        puts "Function '#{func_name}' defined"
+        puts "  DEBUG: Method created? #{respond_to?(func_name)}" if ENV['RSH_DEBUG']
+      rescue SyntaxError => e
+        puts "Syntax error in function definition: #{e}"
+      rescue => e
+        puts "Error in function definition: #{e}"
+      end
+    else
+      puts "Invalid function format. Use: name(params) = body"
+    end
+  end
+  rshrc
+end
+def defun?  # Show all user-defined functions
+  puts "User-defined Ruby functions:"
+  # Get only methods defined by defun, excluding built-ins and rsh internals
+  all_methods = singleton_class.instance_methods(false)
+  puts "  All singleton methods: #{all_methods}"
+  excluded = [:defun, :defun?, :execute_conditional, :expand_braces]
+  methods = all_methods - excluded
+  if methods.empty?
+    puts "  (none defined after filtering)"
+  else
+    methods.each do |method|
+      puts "  #{method}"
+    end
+  end
+end
+def execute_conditional(cmd_line)
+  # Split on && and || while preserving the operators
+  parts = cmd_line.split(/(\s*&&\s*|\s*\|\|\s*)/)
+  
+  result = true
+  i = 0
+  while i < parts.length
+    command = parts[i].strip
+    next if command.empty?
+    
+    if command == '&&'
+      i += 1
+      next unless result  # Skip if previous command failed
+    elsif command == '||'
+      i += 1
+      next if result      # Skip if previous command succeeded
+    else
+      # Execute the command
+      success = system(command)
+      result = success
+      puts " Command failed: #{command} (exit #{$?.exitstatus})" unless success
+    end
+    i += 1
+  end
+end
+def expand_braces(str)
+  # Simple brace expansion: {a,b,c} -> a b c
+  str.gsub(/\{([^}]+)\}/) do |match|
+    items = $1.split(',').map(&:strip)
+    items.join(' ')
+  end
+end
 
 # INITIAL SETUP
 begin # Load .rshrc and populate @history
   trap "SIGINT" do end
+  trap "SIGHUP" do 
+    rshrc
+    exit
+  end
+  trap "SIGTERM" do 
+    rshrc
+    exit
+  end
   firstrun unless File.exist?(Dir.home+'/.rshrc') # Initial loading - to get history
-  load(Dir.home+'/.rshrc') 
+  load(Dir.home+'/.rshrc')
+  # Load login shell files if rsh is running as login shell
+  if ENV['LOGIN_SHELL'] or $0 == "-rsh" or ARGV.include?('-l') or ARGV.include?('--login')
+    ['/etc/profile', Dir.home+'/.profile', Dir.home+'/.bash_profile', Dir.home+'/.bashrc'].each do |f|
+      if File.exist?(f)
+        puts "Loading #{f}..." if ENV['RSH_DEBUG']
+        begin
+          # Source shell files by extracting export statements
+          File.readlines(f).each do |line|
+            if line =~ /^\s*export\s+(\w+)=(.*)/
+              ENV[$1] = $2.gsub(/['"]/, '')
+            end
+          end
+        rescue => e
+          puts "Warning: Could not source #{f}: #{e}" if ENV['RSH_DEBUG']
+        end
+      end
+    end
+  end 
   ENV["SHELL"] = __FILE__
   ENV["TERM"]  = "rxvt-unicode-256color"
   ENV["PATH"]  ? ENV["PATH"] += ":" : ENV["PATH"] = ""
@@ -735,41 +887,92 @@ loop do
     elsif @cmd == '#' # List previous directories
       dirs
     else # Execute command
-      ca = @nick.transform_keys {|k| /((^\K\s*\K)|(\|\K\s*\K))\b(?<!-)#{Regexp.escape k}\b/}
-      @cmd = @cmd.gsub(Regexp.union(ca.keys), @nick)
-      ga = @gnick.transform_keys {|k| /\b(?<!-)#{Regexp.escape k}\b/}
-      @cmd = @cmd.gsub(Regexp.union(ga.keys), @gnick)
-      @cmd = "~" if @cmd == "cd"
-      @cmd.sub!(/^cd (\S*).*/, '\1')
-      @cmd = Dir.home if @cmd == "~"
-      @cmd = @dirs[1] if @cmd == "-"
-      @cmd = @dirs[@cmd.to_i] if @cmd =~ /^\d$/
-      dir  = @cmd.strip.sub(/~/, Dir.home)
-      if Dir.exist?(dir)
-        Dir.chdir(dir) 
-        system("git status .") if Dir.exist?(".git")
+      # Check if it's a user-defined Ruby function FIRST (before any expansions)
+      cmd_parts = @cmd.split(/\s+/)
+      func_name = cmd_parts[0]
+      if self.respond_to?(func_name) && singleton_class.instance_methods(false).include?(func_name.to_sym)
+        begin
+          args = cmd_parts[1..]
+          puts "DEBUG: Calling #{func_name} with args: #{args}" if ENV['RSH_DEBUG']
+          result = self.send(func_name, *args)
+          puts "DEBUG: Result: #{result.inspect}" if ENV['RSH_DEBUG']
+          puts result unless result.nil?
+        rescue => e
+          puts "Error calling function '#{func_name}': #{e}"
+        end
       else
-        puts "#{Time.now.strftime("%H:%M:%S")}: #{@cmd}".c(@c_stamp)
-        if @cmd == "f" # fzf integration (https://github.com/junegunn/fzf)
-          res = `fzf`.chomp
-          Dir.chdir(File.dirname(res))
-        elsif File.exist?(@cmd) and not File.executable?(@cmd)
-          if File.read(@cmd).force_encoding("UTF-8").valid_encoding?
-            system("#{ENV['EDITOR']} #{@cmd}") # Try open with user's editor
-          else
-            if @runmailcap
-              Thread.new { system("run-mailcap #{@cmd} 2>/dev/null") }
+        # Handle conditional execution (&& and ||)
+        if @cmd.include?('&&') || @cmd.include?('||')
+          execute_conditional(@cmd)
+          next
+        end
+        # Expand brace expansion {a,b,c}
+        @cmd = expand_braces(@cmd)
+        # Expand command substitution $(command) and backticks
+        @cmd = @cmd.gsub(/\$\(([^)]+)\)/) { `#{$1}`.chomp }
+        @cmd = @cmd.gsub(/`([^`]+)`/) { `#{$1}`.chomp }
+        # Expand environment variables and exit status
+        @cmd = @cmd.gsub(/\$\?/) { @last_exit.to_s }
+        @cmd = @cmd.gsub(/\$(\w+)|\$\{(\w+)\}/) { ENV[$1 || $2] || '' }
+        # Expand tilde
+        @cmd = @cmd.gsub(/~/, Dir.home)
+        ca = @nick.transform_keys {|k| /((^\K\s*\K)|(\|\K\s*\K))\b(?<!-)#{Regexp.escape k}\b/}
+        @cmd = @cmd.gsub(Regexp.union(ca.keys), @nick)
+        ga = @gnick.transform_keys {|k| /\b(?<!-)#{Regexp.escape k}\b/}
+        @cmd = @cmd.gsub(Regexp.union(ga.keys), @gnick)
+        @cmd = "~" if @cmd == "cd"
+        @cmd.sub!(/^cd (\S*).*/, '\1')
+        @cmd = Dir.home if @cmd == "~"
+        @cmd = @dirs[1] if @cmd == "-"
+        @cmd = @dirs[@cmd.to_i] if @cmd =~ /^\d$/
+        # Check if it's a directory to change to
+        dir = @cmd.strip.sub(/~/, Dir.home)
+        if Dir.exist?(dir)
+          Dir.chdir(dir) 
+          system("git status .") if Dir.exist?(".git")
+        else
+          puts "#{Time.now.strftime("%H:%M:%S")}: #{@cmd}".c(@c_stamp)
+          if @cmd == "f" # fzf integration (https://github.com/junegunn/fzf)
+            res = `fzf`.chomp
+            Dir.chdir(File.dirname(res))
+          elsif File.exist?(@cmd) and not File.executable?(@cmd) and not @cmd.include?(" ")
+            # Only auto-open files if it's a single filename (no spaces = no command with args)
+            if File.read(@cmd).force_encoding("UTF-8").valid_encoding?
+              system("#{ENV['EDITOR']} #{@cmd}") # Try open with user's editor
             else
-              Thread.new { system("xdg-open #{@cmd} 2>/dev/null") }
+              if @runmailcap
+                Thread.new { system("run-mailcap #{@cmd} 2>/dev/null") }
+              else
+                Thread.new { system("xdg-open #{@cmd} 2>/dev/null") }
+              end
+            end
+          else 
+            begin
+              pre_cmd
+              # Handle background jobs
+              if @cmd.end_with?(' &')
+                @cmd = @cmd[0..-3]  # Remove the &
+                @job_id += 1
+                # Handle pipes and redirections in background
+                if @cmd.include?('|') || @cmd.include?('>') || @cmd.include?('<')
+                  pid = spawn(@cmd, pgroup: true)
+                else
+                  pid = spawn(@cmd)
+                end
+                @jobs[@job_id] = {pid: pid, cmd: @cmd, status: :running}
+                puts "[#{@job_id}] #{pid} #{@cmd}"
+              else
+                # Better handling of pipes and redirections  
+                @current_pid = spawn(@cmd)
+                Process.wait(@current_pid)
+                @last_exit = $?.exitstatus
+                @current_pid = nil
+                puts " Command failed: #{@cmd} (exit #{@last_exit})" unless @last_exit == 0
+              end
+              post_cmd
+            rescue StandardError => err
+              puts "\nError: #{err}"
             end
-          end
-        else 
-          begin
-            pre_cmd
-            puts " Not executed: #{@cmd}" unless system (@cmd) # Try execute the command
-            post_cmd
-          rescue StandardError => err
-            puts "\n#{err}"
           end
         end
       end

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: ruby-shell
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.7.0
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-31 00:00:00.000000000 Z
+date: 2025-07-01 00:00:00.000000000 Z
 dependencies: []
 description: 'A shell written in Ruby with extensive tab completions, aliases/nicks,
-  history, syntax highlighting, theming, auto-cd, auto-opening files and more. In
-  continual development. New in 2.0: Full rewrite of tab completion engine. Lots of
-  other bug fixes. 2.6: Handling line longer than terminal width. 2.6.1: Fixed Ctrl-L
-  bug.'
+  history, syntax highlighting, theming, auto-cd, auto-opening files and more. MAJOR
+  UPDATE v2.7.0: Ruby Functions - define custom shell commands using full Ruby power!
+  Also: job control (background jobs, Ctrl-Z suspension), command substitution, variable
+  expansion, conditional execution, login shell support, and much more.'
 email: g@isene.com
 executables:
 - rsh