srsh 0.8.0 → 1.0.0

data/lib/srsh/shell/job.rb

@@ -0,0 +1,101 @@
+module Srsh
+  module Shell
+    class Job
+      WAIT_FLAGS = begin
+        flags = Process::WNOHANG | Process::WUNTRACED
+        flags |= Process.const_get(:WCONTINUED) if Process.const_defined?(:WCONTINUED)
+        flags
+      end
+
+      attr_accessor :id, :notified
+      attr_reader :pgid, :pids, :command, :status
+
+      def initialize(pgid:, pids:, command:, background:)
+        @pgid = pgid
+        @pids = pids.freeze
+        @command = command
+        @background = background
+        @pid_states = pids.to_h { |pid| [pid, :running] }
+        @status = :running
+        @notified = false
+      end
+
+      def background? = @background
+      def running? = @status == :running
+      def stopped? = @status == :stopped
+      def done? = @status == :done
+
+      def mark_background! = @background = true
+      def mark_foreground! = @background = false
+
+      def mark_running!
+        @pid_states.each_key do |pid|
+          @pid_states[pid] = :running unless @pid_states[pid] == :done
+        end
+        recalculate!
+      end
+
+      def mark_stopped!(pid = nil)
+        if pid
+          @pid_states[pid] = :stopped unless @pid_states[pid] == :done
+        else
+          @pid_states.each_key { |p| @pid_states[p] = :stopped unless @pid_states[p] == :done }
+        end
+        recalculate!
+      end
+
+      def observe(pid, process_status)
+        return self unless @pid_states.key?(pid)
+        if process_status.stopped?
+          @pid_states[pid] = :stopped
+        elsif process_status.exited? || process_status.signaled?
+          @pid_states[pid] = :done
+        elsif process_status.respond_to?(:continued?) && process_status.continued?
+          @pid_states[pid] = :running
+        end
+        recalculate!
+      end
+
+      def refresh!
+        return self if done?
+
+        @pids.each do |pid|
+          next if @pid_states[pid] == :done
+          begin
+            result = Process.waitpid2(pid, WAIT_FLAGS)
+            observe(*result) if result
+          rescue Errno::ECHILD
+            # No waitable child means it was reaped by the synchronous path or
+            # elsewhere in srsh. Treat it as terminal, never as magically live.
+            @pid_states[pid] = :done
+          rescue Errno::EINVAL
+            # Some libc/Ruby combinations expose a wait flag constant but reject
+            # the combination at runtime. Retry with the universally portable set.
+            begin
+              result = Process.waitpid2(pid, Process::WNOHANG | Process::WUNTRACED)
+              observe(*result) if result
+            rescue Errno::ECHILD
+              @pid_states[pid] = :done
+            end
+          end
+        end
+
+        recalculate!
+      end
+
+      private
+
+      def recalculate!
+        states = @pid_states.values
+        @status = if states.all? { |s| s == :done }
+                    :done
+                  elsif states.none? { |s| s == :running } && states.any? { |s| s == :stopped }
+                    :stopped
+                  else
+                    :running
+                  end
+        self
+      end
+    end
+  end
+end

data/lib/srsh/shell/lexer.rb

@@ -0,0 +1,114 @@
+require_relative '../errors'
+
+module Srsh
+  module Shell
+    Lexeme = Data.define(:type, :text)
+
+    class Lexer
+      OPERATORS = %w[2>> 2> >> && || | & ; > <].freeze
+      MAX_INPUT = 1024 * 1024
+      MAX_LEXEMES = 100_000
+
+      def self.scan(input)
+        new(input).scan
+      end
+
+      def initialize(input)
+        @s = input.to_s
+        raise ParseError, 'command line too large' if @s.bytesize > MAX_INPUT
+      end
+
+      def scan
+        out = []
+        buf = +''
+        quote = nil
+        escaped = false
+        subst_depth = 0
+        i = 0
+
+        flush = lambda do
+          unless buf.empty?
+            raise ParseError, 'command has too many tokens' if out.length >= MAX_LEXEMES
+            out << Lexeme.new(:word, buf)
+            buf = +''
+          end
+        end
+
+        while i < @s.length
+          c = @s[i]
+
+          if escaped
+            buf << c
+            escaped = false
+            i += 1
+            next
+          end
+
+          if c == '\\'
+            buf << c
+            escaped = true
+            i += 1
+            next
+          end
+
+          if quote
+            buf << c
+            quote = nil if c == quote
+            i += 1
+            next
+          end
+
+          if c == "'" || c == '"'
+            quote = c
+            buf << c
+            i += 1
+            next
+          end
+
+          if c == '$' && @s[i + 1] == '('
+            subst_depth += 1
+            buf << '$('
+            i += 2
+            next
+          elsif c == '(' && subst_depth.positive?
+            subst_depth += 1
+            buf << c
+            i += 1
+            next
+          elsif c == ')' && subst_depth.positive?
+            subst_depth -= 1
+            buf << c
+            i += 1
+            next
+          end
+
+          if subst_depth.zero? && c.match?(/\s/)
+            flush.call
+            i += 1
+            next
+          end
+
+          if subst_depth.zero?
+            op = OPERATORS.find { |candidate| @s[i, candidate.length] == candidate }
+            if op
+              flush.call
+              raise ParseError, 'command has too many tokens' if out.length >= MAX_LEXEMES
+              out << Lexeme.new(:op, op)
+              i += op.length
+              next
+            end
+          end
+
+          buf << c
+          i += 1
+        end
+
+        raise IncompleteInput, 'trailing backslash' if escaped
+        raise IncompleteInput, 'unterminated quote' if quote
+        raise IncompleteInput, 'unterminated command substitution' unless subst_depth.zero?
+        flush.call
+        out
+      end
+    end
+  end
+end

data/lib/srsh/shell/terminal.rb

@@ -0,0 +1,26 @@
+module Srsh
+  module Shell
+    module Terminal
+      module_function
+
+      begin
+        require 'fiddle/import'
+        module LibC
+          extend Fiddle::Importer
+          dlload Fiddle.dlopen(nil)
+          extern 'int tcsetpgrp(int, int)'
+        end
+        AVAILABLE = true
+      rescue LoadError, Fiddle::DLError
+        AVAILABLE = false
+      end
+
+      def foreground(pgid, io = STDIN)
+        return false unless AVAILABLE && io.tty?
+        LibC.tcsetpgrp(io.fileno, pgid.to_i).zero?
+      rescue SystemCallError, Fiddle::DLError
+        false
+      end
+    end
+  end
+end

data/lib/srsh/state.rb

@@ -0,0 +1,136 @@
+module Srsh
+  class State
+    attr_accessor :theme_name
+    attr_reader :aliases, :functions, :prototypes, :traits, :hooks, :jobs, :owner_thread, :options
+
+    def initialize
+      @owner_thread = Thread.current
+      @last_status = 0
+      @last_bg_pid = nil
+      @theme_name = 'classic'
+      @options = { 'pipefail' => false, 'nounset' => false, 'noclobber' => false }
+      @aliases = {}
+      @functions = {}
+      @prototypes = {}
+      @traits = {}
+      @hooks = Hash.new { |h, k| h[k] = [] }
+      @root_locals = {}
+      @owner_locals = [@root_locals]
+      @scope_key = :"srsh_scopes_#{object_id}"
+      @status_key = :"srsh_status_#{object_id}"
+      @bg_key = :"srsh_bg_#{object_id}"
+      @jobs = []
+      @jobs_lock = Mutex.new
+      @next_job_id = 1
+    end
+
+    # RSH threads share global definitions and the root interactive scope for
+    # reads, but each OS thread gets its own scope stack. Function/lambda calls
+    # therefore cannot stomp another thread's locals while closures still see
+    # the snapshot they captured.
+    def locals
+      return @owner_locals if Thread.current == @owner_thread
+      Thread.current[@scope_key] ||= [@root_locals]
+    end
+
+    def push_scope(seed = {}) = locals << seed
+
+    def pop_scope
+      stack = locals
+      stack.pop if stack.length > 1
+    end
+
+    def local_get(name)
+      locals.reverse_each { |scope| return scope[name] if scope.key?(name) }
+      nil
+    end
+
+    def local_defined?(name) = locals.reverse_each.any? { |s| s.key?(name) }
+
+    def locals_snapshot
+      locals.each_with_object({}) { |scope, merged| merged.merge!(scope) }
+    end
+
+    # `:=` always binds in the current lexical/function scope. Compound
+    # assignment walks outward to the nearest existing binding.
+    def local_define(name, value) = locals.last[name] = value
+
+    def local_set(name, value)
+      stack = locals
+      if worker_thread?
+        # Never let an ordinary compound assignment in a worker mutate the
+        # shared root REPL/script scope. If the binding only exists globally,
+        # shadow it in the task's current scope instead.
+        scope = stack[1..].to_a.reverse.find { |s| s.key?(name) } || stack.last
+      else
+        scope = stack.reverse.find { |s| s.key?(name) } || stack.last
+      end
+      scope[name] = value
+    end
+
+    def last_status
+      return @last_status if Thread.current == @owner_thread
+      Thread.current[@status_key].nil? ? @last_status : Thread.current[@status_key]
+    end
+
+    def last_status=(value)
+      if Thread.current == @owner_thread
+        @last_status = value
+      else
+        Thread.current[@status_key] = value
+      end
+    end
+
+    def last_bg_pid
+      return @last_bg_pid if Thread.current == @owner_thread
+      Thread.current[@bg_key].nil? ? @last_bg_pid : Thread.current[@bg_key]
+    end
+
+    def last_bg_pid=(value)
+      if Thread.current == @owner_thread
+        @last_bg_pid = value
+      else
+        Thread.current[@bg_key] = value
+      end
+    end
+
+    def worker_thread? = Thread.current != @owner_thread
+
+    def add_job(job)
+      @jobs_lock.synchronize do
+        job.id = @next_job_id
+        @next_job_id += 1
+        @jobs << job
+      end
+      job
+    end
+
+    def jobs_snapshot = @jobs_lock.synchronize { @jobs.dup }
+
+    def prune_jobs!
+      snapshot = jobs_snapshot
+      snapshot.each do |job|
+        next if job.done?
+        begin
+          job.refresh!
+        rescue StandardError => e
+          # Job bookkeeping is housekeeping. A platform-specific wait quirk must
+          # never tear down the user's interactive shell.
+          warn "srsh: job refresh failed for [#{job.id || '?'}]: #{e.class}: #{e.message}"
+        end
+      end
+      @jobs_lock.synchronize { @jobs.reject! { |job| job.done? && job.notified } }
+    end
+
+    def hook(type, &block) = @hooks[type.to_sym] << block
+    def clear_hooks! = @hooks.clear
+
+    def run_hooks(type, *args)
+      @hooks[type.to_sym].each do |block|
+        block.call(*args)
+      rescue StandardError => e
+        warn "srsh hook #{type}: #{e.class}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/srsh/theme.rb

@@ -0,0 +1,108 @@
+require 'json'
+require_relative 'security'
+
+module Srsh
+  class Theme
+    MAX_THEME_BYTES = 256 * 1024
+    ANSI_RE = /\A(?:\d{1,3})(?:;\d{1,3}){0,6}\z/
+
+    DEFAULTS = {
+      'classic' => {
+        border: '1;35', title: '1;33', key: '1;36', value: '0;37',
+        ok: '32', warn: '33', error: '31', dim: '90', path: '33', host: '36', mark: '35'
+      },
+      'mono' => {
+        border: '1;37', title: '1;37', key: '0;37', value: '0;37',
+        ok: '0;37', warn: '0;37', error: '0;37', dim: '90', path: '0;37', host: '0;37', mark: '0;37'
+      },
+      'neon' => {
+        border: '1;35', title: '1;92', key: '1;95', value: '0;37',
+        ok: '1;92', warn: '1;93', error: '1;91', dim: '90', path: '1;93', host: '1;96', mark: '1;95'
+      },
+      'ocean' => {
+        border: '1;34', title: '1;96', key: '36', value: '0;37',
+        ok: '1;92', warn: '1;93', error: '1;91', dim: '90', path: '34', host: '96', mark: '36'
+      }
+    }.freeze
+
+    attr_reader :name
+
+    def initialize(paths, state)
+      @paths = paths
+      @state = state
+      @themes = DEFAULTS.transform_values(&:dup)
+      load_user_themes
+      @base_themes = @themes.transform_values(&:dup).freeze
+      wanted = ENV['SRSH_THEME'].to_s.strip
+      wanted = File.read(paths.theme_state).strip if wanted.empty? && File.file?(paths.theme_state)
+      use(wanted.empty? ? 'classic' : wanted)
+    end
+
+    def names = @themes.keys.sort
+
+    def reset_dynamic!
+      current = @name
+      @themes = @base_themes.transform_values(&:dup)
+      use(@themes.key?(current) ? current : 'classic')
+    end
+
+    def register(name, values)
+      clean = {}
+      values.each do |key, value|
+        value = value.to_s
+        clean[key.to_sym] = value if value.match?(ANSI_RE)
+      end
+      @themes[name.to_s] = @themes['classic'].merge(clean) unless clean.empty?
+    end
+
+    def use(name)
+      return false unless @themes.key?(name)
+      @name = name
+      @state.theme_name = name
+      Security.atomic_write(@paths.theme_state, "#{name}\n") rescue nil
+      true
+    end
+
+    def code(key) = @themes.fetch(@name, @themes['classic'])[key.to_sym]
+
+    def paint(text, key, io: STDOUT)
+      code = code(key)
+      color_ok = io.respond_to?(:tty?) && io.tty?
+      return text.to_s if !color_ok || code.nil?
+      "\e[#{code}m#{text}\e[0m"
+    end
+
+    private
+
+    def load_user_themes
+      Dir.glob(File.join(@paths.themes, '*.{theme,json}')).sort.each do |path|
+        next unless Security.private_regular_file?(path)
+        next if File.size(path) > MAX_THEME_BYTES
+        raw = File.extname(path) == '.json' ? JSON.parse(File.binread(path, MAX_THEME_BYTES + 1)) : parse_kv(path)
+        next unless raw.is_a?(Hash)
+        clean = {}
+        raw.each do |key, value|
+          value = value.to_s
+          clean[key.to_sym] = value if value.match?(ANSI_RE)
+        end
+        next if clean.empty?
+        @themes[File.basename(path, '.*')] = @themes['classic'].merge(clean)
+      rescue JSON::ParserError, SystemCallError
+        next
+      end
+    end
+
+    def parse_kv(path)
+      data = File.binread(path, MAX_THEME_BYTES + 1)
+      return {} if data.bytesize > MAX_THEME_BYTES
+      data.force_encoding(Encoding::UTF_8)
+      return {} unless data.valid_encoding?
+      data.each_line.filter_map do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+        key, value = line.split('=', 2)
+        [key&.strip, value&.strip] if key && value
+      end.to_h
+    end
+  end
+end

data/lib/srsh/version.rb

@@ -0,0 +1,3 @@
+module Srsh
+  VERSION = '1.0.0'
+end

data/lib/srsh.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "srsh/runner"
-
-module Srsh
-  def self.run(argv = ARGV)
-    Runner.run(argv)
+begin
+  require 'srsh_native'
+rescue LoadError
+  begin
+    require_relative '../ext/srsh_native/srsh_native'
+  rescue LoadError
+    # Optional: the complete shell remains Ruby-only when this is absent.
   end
 end
+
+require_relative 'srsh/app'
+
+require_relative 'srsh/process_identity'

metadata

@@ -1,32 +1,78 @@
 --- !ruby/object:Gem::Specification
 name: srsh
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 1.0.0
 platform: ruby
 authors:
 - RobertFlexx
-bindir: exe
+autorequire:
+bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-02 00:00:00.000000000 Z
 dependencies: []
-description: srsh is a Ruby-based interactive shell featuring a custom scripting language
-  (RSH), themes, plugins, and advanced line editing.
+description: A Unix shell written in Ruby with a structured scripting language for
+  shell programs.
 email:
-- ''
 executables:
 - srsh
-extensions: []
+extensions:
+- ext/srsh_native/extconf.rb
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- exe/srsh
+- bin/srsh
+- docs/assets/slut.txt
+- docs/assets/srsh-mark.svg
+- docs/css/style.css
+- docs/index.html
+- docs/js/app.js
+- examples/bridge.rsh
+- examples/calculator.rsh
+- examples/defer.rsh
+- examples/hot.rsh
+- examples/meta.rsh
+- examples/modules.rsh
+- examples/modules/text.rsh
+- examples/paste.rsh
+- examples/plugin.rb
+- examples/power.rsh
+- examples/tour.rsh
+- ext/srsh_native/extconf.rb
+- ext/srsh_native/srsh_native.c
+- language-docs/LANGUAGE.md
+- language-docs/MIGRATION.md
+- language-docs/SECURITY.md
 - lib/srsh.rb
-- lib/srsh/runner.rb
-homepage: https://github.com/RobertFlexx/srsh
+- lib/srsh/app.rb
+- lib/srsh/builtins.rb
+- lib/srsh/editor.rb
+- lib/srsh/errors.rb
+- lib/srsh/history.rb
+- lib/srsh/language/evaluator.rb
+- lib/srsh/language/lexer.rb
+- lib/srsh/language/parser.rb
+- lib/srsh/language/token.rb
+- lib/srsh/language/values.rb
+- lib/srsh/paths.rb
+- lib/srsh/plugins.rb
+- lib/srsh/process_identity.rb
+- lib/srsh/security.rb
+- lib/srsh/shell/executor.rb
+- lib/srsh/shell/job.rb
+- lib/srsh/shell/lexer.rb
+- lib/srsh/shell/terminal.rb
+- lib/srsh/state.rb
+- lib/srsh/theme.rb
+- lib/srsh/version.rb
+homepage: https://github.com/RobertFlexx/RSH
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/RobertFlexx/RSH
+  bug_tracker_uri: https://github.com/RobertFlexx/RSH/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -34,14 +80,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
-summary: srsh - a simple Ruby shell with RSH scripting
+summary: Simple Ruby Shell with the RSH scripting language
 test_files: []

data/exe/srsh

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "srsh"
-
-exit(Srsh.run(ARGV) || 0)