rush-shell 0.0.2

data/lib/rush/builtins/ulimit.rb

@@ -0,0 +1,258 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # One ulimit resource: option flag, dash list label, SystemCalls key, and display/set scale.
+    UlimitResource = Data.define(:flag, :label, :resource, :scale)
+    # Parsed ulimit invocation: list-all flag, selected resource/limit side, and optional value.
+    UlimitRequest = Data.define(:all, :resource, :target, :explicit_target, :value)
+    # Parser error code plus optional option text for diagnostics.
+    UlimitParseError = Data.define(:kind, :detail)
+    ULIMIT_RESOURCE_LIST = [
+      UlimitResource.new('t', 'time(seconds)', :cpu, 1),
+      UlimitResource.new('f', 'file(blocks)', :fsize, 512),
+      UlimitResource.new('d', 'data(kbytes)', :data, 1024),
+      UlimitResource.new('s', 'stack(kbytes)', :stack, 1024),
+      UlimitResource.new('c', 'coredump(blocks)', :core, 512),
+      UlimitResource.new('m', 'memory(kbytes)', :rss, 1024),
+      UlimitResource.new('l', 'locked memory(kbytes)', :memlock, 1024),
+      UlimitResource.new('p', 'process', :nproc, 1),
+      UlimitResource.new('n', 'nofiles', :nofile, 1),
+      UlimitResource.new('v', 'vmemory(kbytes)', :as, 1024),
+      UlimitResource.new('w', 'locks', :locks, 1),
+      UlimitResource.new('r', 'rtprio', :rtprio, 1)
+    ].freeze
+    ULIMIT_RESOURCES = ULIMIT_RESOURCE_LIST.to_h { |resource| [resource.flag, resource] }.freeze
+    ULIMIT_DEFAULT_RESOURCE = T.let(ULIMIT_RESOURCES.fetch('f'), UlimitResource)
+    ULIMIT_TARGETS = { 'H' => :hard, 'S' => :soft }.freeze
+
+    # Mutable parser for ulimit's compact option clusters (`-Hn`, `-Sn`, `-a`).
+    # It returns either a UlimitRequest or a small parse-error value that the
+    # builtin turns into the user-facing diagnostic.
+    class UlimitRequestBuilder
+      extend T::Sig
+
+      sig { params(resources: T::Hash[String, UlimitResource], default: UlimitResource).void }
+      def initialize(resources, default)
+        @resources = resources
+        @state = { all: false, resource: default, target: :soft, explicit_target: false }
+      end
+
+      sig { params(args: T::Array[String]).returns(T.any(UlimitRequest, UlimitParseError)) }
+      def call(args)
+        rest = args.dup
+        value = extract_value(rest)
+        return error(:too_many) if rest.any? { |arg| !arg.start_with?('-') }
+
+        parse_options(rest, value)
+      end
+
+      private
+
+      sig { params(args: T::Array[String]).returns(T.nilable(String)) }
+      def extract_value(args)
+        last = args.last
+        args.pop if last && !last.start_with?('-')
+      end
+
+      sig { params(args: T::Array[String], value: T.nilable(String)).returns(T.any(UlimitRequest, UlimitParseError)) }
+      def parse_options(args, value)
+        args.each { |arg| apply(arg).tap { |error| return error if error } }
+        return error(:too_many) if @state.fetch(:all) && value
+
+        request(value)
+      end
+
+      sig { params(arg: String).returns(T.nilable(UlimitParseError)) }
+      def apply(arg)
+        return error(:illegal_option, arg) if arg == '-'
+
+        apply_flags(arg.delete_prefix('-'))
+      end
+
+      sig { params(flags: String).returns(T.nilable(UlimitParseError)) }
+      def apply_flags(flags)
+        flags.each_char do |flag|
+          apply_or_error(flag).tap { |error| return error if error }
+        end
+        nil
+      end
+
+      sig { params(flag: String).returns(T::Boolean) }
+      def known_flag?(flag)
+        flag == 'a' || @resources.key?(flag) || ULIMIT_TARGETS.key?(flag)
+      end
+
+      sig { params(flag: String).returns(T.nilable(UlimitParseError)) }
+      def apply_or_error(flag)
+        return return_error(flag) unless known_flag?(flag)
+
+        apply_flag(flag)
+        nil
+      end
+
+      sig { params(flag: String).returns(UlimitParseError) }
+      def return_error(flag)
+        error(:illegal_option, "-#{flag}")
+      end
+
+      sig { params(flag: String).void }
+      def apply_flag(flag)
+        @state[:all] = true if flag == 'a'
+        @state[:resource] = @resources.fetch(flag) if @resources.key?(flag)
+        apply_target(flag) if ULIMIT_TARGETS.key?(flag)
+      end
+
+      sig { params(flag: String).void }
+      def apply_target(flag)
+        @state[:target] = ULIMIT_TARGETS.fetch(flag)
+        @state[:explicit_target] = true
+      end
+
+      sig { params(value: T.nilable(String)).returns(UlimitRequest) }
+      def request(value)
+        UlimitRequest.new(
+          @state.fetch(:all), @state.fetch(:resource), @state.fetch(:target), @state.fetch(:explicit_target), value
+        )
+      end
+
+      sig { params(kind: Symbol, detail: T.nilable(String)).returns(UlimitParseError) }
+      def error(kind, detail = nil)
+        UlimitParseError.new(kind, detail)
+      end
+    end
+
+    # `ulimit [-H|-S] [-a|-resource] [limit]` — query or set process resource
+    # limits. Values are printed in dash/POSIX units (blocks or kbytes for byte
+    # resources); `unlimited` maps to the platform's infinity value.
+    class Ulimit < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        request = parse_request
+        return parse_error(request) if request.is_a?(UlimitParseError)
+
+        run_request(request)
+      end
+
+      private
+
+      sig { returns(T.any(UlimitRequest, UlimitParseError)) }
+      def parse_request
+        UlimitRequestBuilder.new(ULIMIT_RESOURCES, ULIMIT_DEFAULT_RESOURCE).call(operands)
+      end
+
+      sig { params(error: UlimitParseError).returns(Status) }
+      def parse_error(error)
+        return too_many if error.kind == :too_many
+
+        illegal_option(T.must(error.detail))
+      end
+
+      sig { params(request: UlimitRequest).returns(Status) }
+      def run_request(request)
+        return list_all(request) if request.all
+        return change_limit(request) if request.value
+
+        print_limit(request.resource, request.target)
+      end
+
+      sig { params(request: UlimitRequest).returns(Status) }
+      def list_all(request)
+        ULIMIT_RESOURCE_LIST.each { |resource| print_list_entry(resource, request.target) }
+        success
+      end
+
+      sig { params(resource: UlimitResource, target: Symbol).void }
+      def print_list_entry(resource, target)
+        stdout.printf("%<label>-20s %<value>s\n", label: resource.label, value: limit_text(resource, target))
+      end
+
+      sig { params(request: UlimitRequest).returns(Status) }
+      def change_limit(request)
+        value = parse_value(T.must(request.value), request.resource)
+        return value if value.is_a?(Status)
+
+        apply_limit(request, value)
+      end
+
+      sig { params(request: UlimitRequest, value: Integer).returns(Status) }
+      def apply_limit(request, value)
+        limits = limits_for(request, value)
+        executor.system.setrlimit(request.resource.resource, limits.fetch(0), limits.fetch(1))
+        success
+      rescue SystemCallError, ArgumentError
+        limit_error
+      end
+
+      sig { params(request: UlimitRequest, value: Integer).returns([Integer, Integer]) }
+      def limits_for(request, value)
+        soft, hard = executor.system.getrlimit(request.resource.resource)
+        limits_for_set(request, value, soft, hard)
+      end
+
+      sig do
+        params(request: UlimitRequest, value: Integer, soft: Integer, hard: Integer).returns([Integer, Integer])
+      end
+      def limits_for_set(request, value, soft, hard)
+        return [value, hard] if request.explicit_target && request.target == :soft
+        return [soft, value] if request.explicit_target && request.target == :hard
+
+        [value, value]
+      end
+
+      sig { params(resource: UlimitResource, target: Symbol).returns(Status) }
+      def print_limit(resource, target)
+        stdout.puts(limit_text(resource, target))
+        success
+      end
+
+      sig { params(resource: UlimitResource, target: Symbol).returns(String) }
+      def limit_text(resource, target)
+        soft, hard = executor.system.getrlimit(resource.resource)
+        format_limit(target == :hard ? hard : soft, resource)
+      end
+
+      sig { params(text: String, resource: UlimitResource).returns(T.any(Integer, Status)) }
+      def parse_value(text, resource)
+        return executor.system.infinity_limit if text == 'unlimited'
+        return Integer(text, 10) * resource.scale if text.match?(/\A\d+\z/)
+
+        illegal_number(text)
+      end
+
+      sig { params(value: Integer, resource: UlimitResource).returns(String) }
+      def format_limit(value, resource)
+        return 'unlimited' if value >= executor.system.infinity_limit
+
+        (value / resource.scale).to_s
+      end
+
+      sig { returns(Status) }
+      def limit_error
+        stderr.puts('rush: ulimit: error setting limit')
+        failure(2)
+      end
+
+      sig { returns(Status) }
+      def too_many
+        stderr.puts('rush: ulimit: too many arguments')
+        failure(2)
+      end
+
+      sig { params(option: String).returns(Status) }
+      def illegal_option(option)
+        stderr.puts("rush: ulimit: Illegal option #{option}")
+        failure(2)
+      end
+
+      sig { params(text: String).returns(Status) }
+      def illegal_number(text)
+        stderr.puts("rush: ulimit: Illegal number: #{text}")
+        failure(2)
+      end
+    end
+  end
+end

data/lib/rush/builtins/umask.rb

@@ -0,0 +1,81 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `umask [-S] [mode]` — print or set the file creation mask. Octal operands
+    # set the mask directly; symbolic operands edit the allowed permission bits
+    # (the complement of the mask), as shown by `umask -S`.
+    class Umask < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        return illegal_option(operands.first) if invalid_option?
+
+        symbolic, mode = parse_operands
+        return change_mask(mode) if mode
+        return display_symbolic if symbolic
+
+        display_octal
+      end
+
+      private
+
+      sig { returns(Integer) }
+      def current_mask
+        executor.system.current_umask
+      end
+
+      sig { params(mode: String).returns(Status) }
+      def change_mask(mode)
+        parsed = UmaskMode.parse(mode, current_mask)
+        return illegal(mode) unless parsed
+
+        executor.system.change_umask(parsed)
+        success
+      end
+
+      sig { returns(T::Boolean) }
+      def invalid_option?
+        operands.any? { |arg| invalid_option_operand?(arg) }
+      end
+
+      sig { params(arg: String).returns(T::Boolean) }
+      def invalid_option_operand?(arg)
+        arg.start_with?('-') && arg != '-S'
+      end
+
+      sig { returns([T::Boolean, T.nilable(String)]) }
+      def parse_operands
+        args = operands.reject { |arg| arg == '-S' }
+        [operands.include?('-S'), args.first]
+      end
+
+      sig { returns(Status) }
+      def display_symbolic
+        stdout.puts(UmaskMode.format_symbolic(current_mask))
+        success
+      end
+
+      sig { returns(Status) }
+      def display_octal
+        stdout.puts(UmaskMode.format_octal(current_mask))
+        success
+      end
+
+      sig { params(mode: String).returns(Status) }
+      def illegal(mode)
+        label = mode.match?(/\A[0-9]+\z/) ? 'number' : 'mode'
+        stderr.puts("rush: umask: Illegal #{label}: #{mode}")
+        failure(2)
+      end
+
+      sig { params(option: T.nilable(String)).returns(Status) }
+      def illegal_option(option)
+        stderr.puts("rush: umask: Illegal option #{option}")
+        failure(2)
+      end
+    end
+  end
+end

data/lib/rush/builtins/unalias.rb

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `unalias name...` removes each named alias; `unalias -a` removes them all.
+    # A name with no alias is reported as `unalias: NAME not found` on stderr with
+    # status 1, but the remaining names are still processed.
+    class Unalias < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        return remove_all if operands.first == '-a'
+
+        operands.reduce(success) { |status, name| keep(status, remove(name)) }
+      end
+
+      private
+
+      sig { returns(Status) }
+      def remove_all
+        aliases.clear
+        success
+      end
+
+      sig { params(name: String).returns(Status) }
+      def remove(name)
+        return success if aliases.remove(name)
+
+        stderr.puts("unalias: #{name} not found")
+        failure(1)
+      end
+
+      sig { params(status: Status, result: Status).returns(Status) }
+      def keep(status, result)
+        status.success? ? result : status
+      end
+
+      sig { returns(AliasTable) }
+      def aliases
+        executor.state.aliases
+      end
+    end
+  end
+end

data/lib/rush/builtins/unset.rb

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `unset [-fv] name ...` — remove each name. The default (and -v) unsets a
+    # shell variable; -f unsets a function. Unsetting an absent name succeeds.
+    class Unset < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        names.each { |name| remove(name) }
+        success
+      end
+
+      private
+
+      sig { returns(T::Array[String]) }
+      def names
+        operands.first&.start_with?('-') ? operands.drop(1) : operands
+      end
+
+      sig { returns(T::Boolean) }
+      def function?
+        operands.first == '-f'
+      end
+
+      sig { params(name: String).void }
+      def remove(name)
+        function? ? state.functions.undefine(name) : state.variables.unset(name)
+      end
+
+      sig { returns(ShellState) }
+      def state
+        executor.state
+      end
+    end
+  end
+end

data/lib/rush/builtins/wait.rb

@@ -0,0 +1,127 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `wait [pid | %id ...]`: with no operands, wait for every known
+    # background job (status 0); with operands, wait for each and return the
+    # last one's status — 127 when a pid is not a known child, and a %id that
+    # resolves to no job is a status-2 error (No such job / No current job,
+    # like dash). POSIX gives an unknown last pid its 127 even after a known
+    # one; dash instead keeps the last known operand's status — the standard
+    # wins (journal). A malformed operand reports on stderr with status 2,
+    # and wait is a regular builtin, so the shell carries on (dash-verified).
+    class Wait < Base
+      extend T::Sig
+
+      # dash's operand shape: an explicit + sign is accepted; a value past
+      # INT_MAX overflows like a non-numeric one; a leading dash reads as an
+      # (unsupported) option, except the bare `-`, which is a bad number.
+      NUMERIC = /\A\+?\d+\z/
+
+      sig { returns(Status) }
+      def call
+        args = operands
+        args = args.drop(1) if args.first == '--'
+        return all if args.empty?
+
+        each_pid(args)
+      end
+
+      private
+
+      # No operands: collect every known job — a stopped one answers its
+      # 128+stopsig at once, so wait never blocks on it (dash-probed).
+      sig { returns(Status) }
+      def all
+        executor.jobs.ordered.each do |job|
+          status = interruptible_wait(job.pid)
+          return pending_status(T.must(status)) if executor.trap_runner.pending?
+        end
+        success
+      end
+
+      # Malformed pids are rejected up front (observationally equivalent to
+      # dash's lazy check: an already-waited job stays remembered, so a later
+      # wait answers the same); %ids validate through resolution itself.
+      sig { params(args: T::Array[String]).returns(Status) }
+      def each_pid(args)
+        malformed = args.find { |operand| !operand.start_with?('%') && !parse(operand) }
+        return bad(malformed) if malformed
+
+        statuses(args)
+      rescue JobError => e
+        no_job(e)
+      end
+
+      sig { params(args: T::Array[String]).returns(Status) }
+      def statuses(args)
+        status = T.let(success, Status)
+        status = status_of(T.must(args.shift)) until args.empty? || executor.trap_runner.pending?
+        pending_status(status)
+      end
+
+      sig { params(operand: String).returns(Status) }
+      def status_of(operand)
+        return awaited(job_pid(operand)) if operand.start_with?('%')
+
+        awaited(T.must(parse(operand)))
+      end
+
+      sig { params(operand: String).returns(Integer) }
+      def job_pid(operand)
+        JobSpec.resolve(executor.jobs, operand).pid
+      end
+
+      sig { params(error: JobError).returns(Status) }
+      def no_job(error)
+        stderr.puts("wait: #{error.message}")
+        failure(2)
+      end
+
+      sig { params(operand: String).returns(T.nilable(Integer)) }
+      def parse(operand)
+        return unless operand.match?(NUMERIC)
+
+        value = Integer(operand, 10)
+        value if value <= INT_MAX
+      end
+
+      # A pid/%id operand whose job died by a signal reports strsignal on
+      # stderr, like dash's wait-by-pid (probed; the bare `wait` in #all
+      # never reports, also probed).
+      sig { params(pid: Integer).returns(Status) }
+      def awaited(pid)
+        status = interruptible_wait(pid)
+        status ? SignalReport.report(status, stderr) : failure(127)
+      end
+
+      sig { params(pid: Integer).returns(T.nilable(Status)) }
+      def interruptible_wait(pid)
+        executor.jobs.wait_for_interruptibly(pid) { executor.trap_runner.pending_exitstatus }
+      end
+
+      sig { params(status: Status).returns(Status) }
+      def pending_status(status)
+        code = executor.trap_runner.pending_exitstatus
+        code ? Status.new(code) : status
+      end
+
+      sig { params(operand: String).returns(Status) }
+      def bad(operand)
+        stderr.puts("wait: #{diagnosis(operand)}")
+        failure(2)
+      end
+
+      sig { params(operand: String).returns(String) }
+      def diagnosis(operand)
+        option?(operand) ? "Illegal option #{operand}" : "Illegal number: #{operand}"
+      end
+
+      sig { params(operand: String).returns(T::Boolean) }
+      def option?(operand)
+        operand.start_with?('-') && operand != '-'
+      end
+    end
+  end
+end

data/lib/rush/cli.rb

@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  # Entry point: parse the invocation, run the session it implies (interactive
+  # REPL or non-interactive source), and return the process exit code. A
+  # malformed command line — unknown option, missing -c/-o argument, unreadable
+  # script file — reports on stderr and exits 2, like dash.
+  class CLI
+    extend T::Sig
+
+    sig { params(argv: T::Array[String], system: SystemCalls).returns(Integer) }
+    def self.run(argv, system: SystemCalls.new)
+      new(argv, system).run
+    end
+
+    sig { params(argv: T::Array[String], system: SystemCalls).void }
+    def initialize(argv, system)
+      @argv = argv
+      @system = system
+    end
+
+    sig { returns(Integer) }
+    def run
+      Invocation.new(@argv, @system).session.run
+    rescue InvocationError => e
+      @system.stderr.puts("rush: #{e.message}")
+      2
+    end
+  end
+end

data/lib/rush/command_assignments.rb

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  # Applies assignment words attached to a simple command. Bare assignments
+  # persist in shell variables; assignments before an external command overlay
+  # the exported environment without mutating the shell.
+  class CommandAssignments
+    extend T::Sig
+
+    sig { params(assignments: T::Array[AST::Assignment], expander: Expansion::Pipeline).void }
+    def initialize(assignments, expander)
+      @assignments = assignments
+      @expander = expander
+    end
+
+    sig { returns(T::Array[String]) }
+    def names
+      @assignments.map(&:name)
+    end
+
+    sig { params(variables: ShellVariables).void }
+    def persist_to(variables)
+      @assignments.each { |assignment| variables.assign(assignment.name, expand(assignment)) }
+    end
+
+    sig { params(variables: ShellVariables).returns(T::Hash[String, String]) }
+    def environment_for(variables)
+      @assignments.each_with_object(variables.exported) do |assignment, env|
+        env[assignment.name] = expand(assignment)
+      end
+    end
+
+    sig { params(environment: T::Hash[String, String]).returns(T::Hash[String, String]) }
+    def temporary_environment(environment)
+      names.to_h { |name| [name, environment.fetch(name)] }
+    end
+
+    sig { params(environment: T::Hash[String, String], variables: ShellVariables).void }
+    def persist_environment(environment, variables)
+      temporary_environment(environment).each { |name, value| variables.assign(name, value) }
+    end
+
+    sig { params(variables: ShellVariables).void }
+    def validate(variables)
+      @assignments.each { |assignment| variables.validate_assignment(assignment.name) }
+    end
+
+    private
+
+    sig { params(assignment: AST::Assignment).returns(String) }
+    def expand(assignment)
+      @expander.expand_value(assignment.value, tilde: :assignment)
+    end
+  end
+end