rush-shell 0.0.2

data/lib/rush/builtins/test_expr.rb

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # Pure evaluator for `test`/`[` expressions. POSIX specifies the result
+    # by argument count (XCU test), so #evaluate applies that table in dash's
+    # order: at three arguments a binary primary outranks any other reading;
+    # a leading `!` at three or four arguments negates the rest (re-checked,
+    # so `! a = b` reads as the negated compare); a full `( ... )` wrapper at
+    # three or four arguments drops to its contents. Everything else — zero
+    # to two arguments and the shapes POSIX leaves unspecified — is handed to
+    # TestGrammar, the transcription of dash's recursive descent. A malformed
+    # expression raises TestError, which the builtin maps to exit 2.
+    #
+    # One deliberate divergence, on POSIX's side: dash zeroes (rather than
+    # toggles) its negation parity when it peels `!` twice, so `[ ! ! ! x ]`
+    # is true and `[ ! ! -n x ]` false there; POSIX defines the four-argument
+    # `!` form as the negated three-argument test, so rush negates honestly.
+    # Pinned in the unit specs.
+    class TestExpr
+      def initialize(args, context)
+        @args = args
+        @context = context
+      end
+
+      def true?
+        evaluate(@args)
+      end
+
+      private
+
+      # A binary primary at exactly three arguments outranks every other
+      # reading; only then do the `!` and `( ... )` rows apply.
+      def evaluate(args)
+        return binary(args) if shortcut?(args)
+
+        peel(args)
+      end
+
+      def shortcut?(args)
+        args.size == 3 && TestOperators.binary?(args[1])
+      end
+
+      def peel(args)
+        return !evaluate(args.drop(1)) if negation?(args)
+        return grammar(args[1...-1].to_a) if wrapped?(args)
+
+        grammar(args)
+      end
+
+      # `!` peels only at three or four arguments (POSIX's 3- and 4-argument
+      # rows); at other lengths the grammar owns `!` with tighter binding.
+      def negation?(args)
+        (3..4).cover?(args.size) && args.first == '!'
+      end
+
+      # A full `( ... )` wrapper likewise drops to its contents only at three
+      # or four arguments; longer groupings are parsed as grammar primaries.
+      def wrapped?(args)
+        (3..4).cover?(args.size) && args.first == '(' && args.last == ')'
+      end
+
+      def binary(args)
+        args => [lhs, op, rhs]
+        TestOperators.apply_binary(op, lhs, rhs)
+      end
+
+      def grammar(args)
+        TestGrammar.new(args, @context).truth
+      end
+    end
+  end
+end

data/lib/rush/builtins/test_grammar.rb

@@ -0,0 +1,117 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # The historical `test`/`[` grammar, transcribed from dash's recursive
+    # descent (oexpr/aexpr/nexpr/primary). POSIX leaves test beyond four
+    # arguments unspecified and marks the -a/-o connectives obsolescent, but
+    # countless real scripts use them, so rush reproduces dash here:
+    #
+    #   or      ::= and { "-o" and }         (both arms always evaluated)
+    #   and     ::= not { "-a" not }
+    #   not     ::= "!" not | primary
+    #   primary ::= "(" or ")" | unary-op word | word binary-op word | word
+    #
+    # The cursor mirrors dash's t_wp pointer discipline: it rests on the last
+    # consumed word, and a word left over after the parse is the "unexpected
+    # operator" syntax error (TestError, exit 2). A missing operand after a
+    # connective parses as the missing expression, which is false, so
+    # `[ x -o ]` is true and `[ x -a ]` is false, exactly as in dash.
+    class TestGrammar
+      def initialize(args, context)
+        @args = args
+        @context = context
+        @tokens = TestTokens.new(args)
+        @pos = 0
+      end
+
+      def truth
+        result = or_expr(kind_at(@pos))
+        trailing = @args[@pos + 1]
+        raise TestError, "#{trailing}: unexpected operator" if @args[@pos] && trailing
+
+        result
+      end
+
+      private
+
+      def kind_at(index)
+        @tokens.kind_at(index)
+      end
+
+      def or_expr(kind)
+        result = and_expr(kind)
+        result = and_expr(kind_at(@pos += 2)) || result while connective == :bor
+        result
+      end
+
+      def and_expr(kind)
+        result = not_expr(kind)
+        result = not_expr(kind_at(@pos += 2)) && result while connective == :band
+        result
+      end
+
+      # The kind of the word after the cursor, or :eoi once the current word
+      # is exhausted — dash's `if (!*t_wp) break; t_lex(t_wp + 1)`.
+      def connective
+        @args.fetch(@pos) { return :eoi }
+        kind_at(@pos + 1)
+      end
+
+      def not_expr(kind)
+        return primary(kind) unless kind == :bunop
+
+        negand = kind_at(@pos + 1)
+        @pos += 1 unless negand == :eoi
+        !not_expr(negand)
+      end
+
+      # The missing expression is false, `(` opens a grouping, a unary
+      # primary applies, and any other kind reads as a word primary.
+      def primary(kind)
+        case kind
+        in :eoi then false
+        in :lparen then group
+        else kind == :unop ? unary : word
+        end
+      end
+
+      def group
+        inner = kind_at(@pos += 1)
+        return false if inner == :rparen
+
+        result = or_expr(inner)
+        raise TestError, 'closing paren expected' unless kind_at(@pos += 1) == :rparen
+
+        result
+      end
+
+      # The operand always exists: a unary primary with nothing after it is
+      # demoted to a plain operand by TestTokens, never classified :unop.
+      def unary
+        op = current
+        @context.unary(op, @args.fetch(@pos += 1))
+      end
+
+      # A word primary: a binary comparison when a binary primary follows,
+      # otherwise the plain non-empty test of the word itself.
+      def word
+        return binary if kind_at(@pos + 1) == :binop
+
+        !current.empty?
+      end
+
+      def binary
+        lhs = current
+        op = @args.fetch(@pos += 1)
+        rhs = @args.fetch(@pos += 1) { raise TestError, "#{op}: argument expected" }
+        TestOperators.apply_binary(op, lhs, rhs)
+      end
+
+      def current
+        @args.fetch(@pos)
+      end
+    end
+  end
+end

data/lib/rush/builtins/test_operators.rb

@@ -0,0 +1,94 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # The operator vocabulary of `test`/`[`, shared by the argument-count
+    # front end (TestExpr) and the recursive-descent grammar (TestGrammar).
+    # The tables map to lambdas, not method symbols, so each primary carries
+    # its operand types past both checkers (the #: types each lambda for
+    # Steep, the T.let the table for Sorbet). File primaries ask the
+    # SystemCalls port; -t parses its operand as a file-descriptor number
+    # first, rejecting non-numbers like dash's "Illegal number" (exit 2).
+    module TestOperators
+      UNARY = T.let({
+        '-n' => ->(_files, val) { !val.empty? },                          #: ^(SystemCalls, String) -> bool
+        '-z' => ->(_files, val) { val.empty? },                           #: ^(SystemCalls, String) -> bool
+        '-t' => ->(files, val) { files.tty_fd?(fd_number(val)) },         #: ^(SystemCalls, String) -> bool
+        '-e' => ->(files, val) { files.exist?(val) },                     #: ^(SystemCalls, String) -> bool
+        '-f' => ->(files, val) { files.file?(val) },                      #: ^(SystemCalls, String) -> bool
+        '-d' => ->(files, val) { files.directory?(val) },                 #: ^(SystemCalls, String) -> bool
+        '-r' => ->(files, val) { files.readable?(val) },                  #: ^(SystemCalls, String) -> bool
+        '-w' => ->(files, val) { files.writable?(val) },                  #: ^(SystemCalls, String) -> bool
+        '-x' => ->(files, val) { files.executable?(val) },                #: ^(SystemCalls, String) -> bool
+        '-s' => ->(files, val) { files.file_nonempty?(val) },             #: ^(SystemCalls, String) -> bool
+        '-h' => ->(files, val) { files.symlink?(val) },                   #: ^(SystemCalls, String) -> bool
+        '-L' => ->(files, val) { files.symlink?(val) },                   #: ^(SystemCalls, String) -> bool
+        '-p' => ->(files, val) { files.pipe?(val) },                      #: ^(SystemCalls, String) -> bool
+        '-b' => ->(files, val) { files.blockdev?(val) },                  #: ^(SystemCalls, String) -> bool
+        '-c' => ->(files, val) { files.chardev?(val) },                   #: ^(SystemCalls, String) -> bool
+        '-S' => ->(files, val) { files.socket?(val) },                    #: ^(SystemCalls, String) -> bool
+        '-g' => ->(files, val) { files.setgid?(val) },                    #: ^(SystemCalls, String) -> bool
+        '-u' => ->(files, val) { files.setuid?(val) }                     #: ^(SystemCalls, String) -> bool
+      }.freeze, T::Hash[String, T.proc.params(files: SystemCalls, val: String).returns(T::Boolean)])
+      STRING = T.let({
+        '=' => ->(lhs, rhs) { lhs == rhs },  #: ^(String, String) -> bool
+        '!=' => ->(lhs, rhs) { lhs != rhs }  #: ^(String, String) -> bool
+      }.freeze, T::Hash[String, T.proc.params(lhs: String, rhs: String).returns(T::Boolean)])
+      INTEGER = T.let({
+        '-eq' => ->(lhs, rhs) { lhs == rhs },  #: ^(Integer, Integer) -> bool
+        '-ne' => ->(lhs, rhs) { lhs != rhs },  #: ^(Integer, Integer) -> bool
+        '-gt' => ->(lhs, rhs) { lhs > rhs },   #: ^(Integer, Integer) -> bool
+        '-ge' => ->(lhs, rhs) { lhs >= rhs },  #: ^(Integer, Integer) -> bool
+        '-lt' => ->(lhs, rhs) { lhs < rhs },   #: ^(Integer, Integer) -> bool
+        '-le' => ->(lhs, rhs) { lhs <= rhs }   #: ^(Integer, Integer) -> bool
+      }.freeze, T::Hash[String, T.proc.params(lhs: Integer, rhs: Integer).returns(T::Boolean)])
+
+      # A string that may name an integer for the numeric primaries: #value is its
+      # integer when it is a valid (optionally signed, blank-padded) decimal, else
+      # nil. Underscores and 0x are rejected, matching dash's strtol-strictness.
+      class MaybeInteger
+        PATTERN = /\A\s*[+-]?\d+\s*\z/
+
+        def initialize(text)
+          @text = text
+        end
+
+        def valid?
+          @text.match?(PATTERN)
+        end
+
+        def value
+          Integer(@text, 10) if valid?
+        end
+      end
+
+      def self.unary?(word)
+        UNARY.key?(word)
+      end
+
+      def self.binary?(word)
+        STRING.key?(word) || INTEGER.key?(word)
+      end
+
+      def self.unary(op)
+        UNARY.fetch(op)
+      end
+
+      def self.apply_binary(op, lhs, rhs)
+        string = STRING[op]
+        return string.call(lhs, rhs) if string
+
+        INTEGER.fetch(op).call(to_int(lhs), to_int(rhs))
+      end
+
+      def self.to_int(text)
+        MaybeInteger.new(text).value || raise(TestError, "#{text}: integer expected")
+      end
+
+      def self.fd_number(text)
+        MaybeInteger.new(text).value || raise(TestError, "Illegal number: #{text}")
+      end
+    end
+  end
+end

data/lib/rush/builtins/test_tokens.rb

@@ -0,0 +1,69 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # Positional word classification for `test`/`[`, mirroring dash's t_lex:
+    # a word is an operator only in operator position. A unary primary is
+    # demoted to a plain operand when it is the last word (`[ -n ]` is the
+    # non-empty test of "-n") or when a binary primary follows with more
+    # beyond (`[ -t = -t ]` compares strings); a `(` closing the argument
+    # list is likewise a word. Everything else keeps its table kind: unary
+    # and binary primaries, `!`, the XSI-obsolescent -a/-o connectives, and
+    # the parentheses.
+    class TestTokens
+      extend T::Sig
+
+      KINDS = T.let({ '!' => :bunop, '-a' => :band, '-o' => :bor,
+                      '(' => :lparen, ')' => :rparen }.freeze, T::Hash[String, Symbol])
+
+      # The t_lex demotion rules, keyed by table kind (a registry, so the
+      # classifier itself never branches on the kind it is computing).
+      DEMOTIONS = T.let({
+        unop: ->(args, index) { operand_position?(args, index) },  #: ^(Array[String], Integer) -> bool
+        lparen: ->(args, index) { args[index + 1].nil? }           #: ^(Array[String], Integer) -> bool
+      }.freeze, T::Hash[Symbol, T.proc.params(args: T::Array[String], index: Integer).returns(T::Boolean)])
+
+      NEVER = T.let(->(_args, _index) { false },
+                    T.proc.params(args: T::Array[String], index: Integer).returns(T::Boolean))
+
+      sig { params(args: T::Array[String]).void }
+      def initialize(args)
+        @args = args
+      end
+
+      sig { params(index: Integer).returns(Symbol) }
+      def kind_at(index)
+        positional(@args.fetch(index) { return :eoi }, index)
+      end
+
+      # dash's isoperand: a unary primary reads as an operand when nothing
+      # follows, or when the next word is a binary primary and more follows.
+      sig { params(args: T::Array[String], index: Integer).returns(T::Boolean) }
+      def self.operand_position?(args, index)
+        following = args.fetch(index + 1) { return true }
+        args.fetch(index + 2) { return false }
+        TestOperators.binary?(following)
+      end
+      private_class_method :operand_position?
+
+      private
+
+      sig { params(word: String, index: Integer).returns(Symbol) }
+      def positional(word, index)
+        kind = KINDS[word] || primary_kind(word)
+        return :operand if DEMOTIONS.fetch(kind, NEVER).call(@args, index)
+
+        kind
+      end
+
+      sig { params(word: String).returns(Symbol) }
+      def primary_kind(word)
+        return :unop if TestOperators.unary?(word)
+        return :binop if TestOperators.binary?(word)
+
+        :operand
+      end
+    end
+  end
+end

data/lib/rush/builtins/times.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `times` — write the accumulated CPU times: line 1 the shell's own user and
+    # system time, line 2 the user and system time of its children, each formatted
+    # `<min>m<sec>s <min>m<sec>s` with six-decimal seconds (POSIX, matching dash).
+    # The values are non-deterministic, so behaviour is verified by format.
+    class Times < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        tms = executor.system.times
+        write_times(tms)
+        success
+      end
+
+      private
+
+      sig { params(tms: Process::Tms).void }
+      def write_times(tms)
+        stdout.puts("#{clock(tms.utime)} #{clock(tms.stime)}")
+        stdout.puts("#{clock(tms.cutime)} #{clock(tms.cstime)}")
+      end
+
+      sig { params(seconds: Float).returns(String) }
+      def clock(seconds)
+        minutes, secs = seconds.divmod(60)
+        format('%<min>dm%<sec>fs', min: minutes, sec: secs)
+      end
+    end
+  end
+end

data/lib/rush/builtins/trap.rb

@@ -0,0 +1,85 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `trap [action] signal...` sets, ignores ("" action) or resets ("-" action)
+    # the handler for each signal; EXIT (or 0) runs when the shell exits. With no
+    # operands it lists the active traps, one `trap -- 'action' NAME` line each in
+    # signal-number order. The action word is consumed only when a signal follows
+    # it, so `trap INT` resets INT (matching dash). A spec that names no signal is
+    # reported as "trap: SPEC: bad trap" and stops processing with status 1.
+    class Trap < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        return list if operands.empty?
+
+        action, signals = split
+        apply(action, signals)
+      end
+
+      private
+
+      # tuple, not Array: split feeds `apply(*split)`, a fixed-arity call.
+      sig { returns([T.nilable(String), T::Array[String]]) }
+      def split
+        return [nil, operands] if operands.size < 2
+
+        [operands.first, operands.drop(1)]
+      end
+
+      # Apply left to right, stopping at (but keeping the work before) the first
+      # spec that names no signal — dash's behaviour for `trap x INT BADD TERM`.
+      sig { params(action: T.nilable(String), signals: T::Array[String]).returns(Status) }
+      def apply(action, signals)
+        bad = signals.find { |spec| !place(action, spec) }
+        bad ? bad_trap(bad) : success
+      end
+
+      sig { params(action: T.nilable(String), spec: String).returns(T.nilable(String)) }
+      def place(action, spec)
+        name = Signals.decode(spec)
+        change(name, action) if name
+        name
+      end
+
+      sig { params(name: String, action: T.nilable(String)).void }
+      def change(name, action)
+        if action && action != '-'
+          executor.trap_runner.set(name, action)
+        else
+          executor.trap_runner.reset(name)
+        end
+      end
+
+      sig { params(spec: String).returns(Status) }
+      def bad_trap(spec)
+        stderr.puts("trap: #{spec}: bad trap")
+        failure(1)
+      end
+
+      sig { returns(Status) }
+      def list
+        traps.listing.each { |name, action| stdout.puts(line(name, action)) }
+        success
+      end
+
+      sig { params(name: String, action: String).returns(String) }
+      def line(name, action)
+        "trap -- #{quote(action)} #{name}"
+      end
+
+      sig { params(action: String).returns(String) }
+      def quote(action)
+        "'#{action.gsub("'", %q('"'"'))}'"
+      end
+
+      sig { returns(TrapTable) }
+      def traps
+        executor.state.traps
+      end
+    end
+  end
+end

data/lib/rush/builtins/true_.rb

@@ -0,0 +1,16 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `true` — does nothing, succeeds (status 0).
+    class True < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        success
+      end
+    end
+  end
+end

data/lib/rush/builtins/type_.rb

@@ -0,0 +1,28 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module Builtins
+    # `type name ...` — report how each name would be used: a shell keyword,
+    # function, special or regular builtin, or the executable found in PATH.
+    # Exit status 127 if any name is unknown (the message still goes to stdout).
+    class Type < Base
+      extend T::Sig
+
+      sig { returns(Status) }
+      def call
+        unknown = operands.reject { |name| report(name) }
+        unknown.empty? ? success : failure(127)
+      end
+
+      private
+
+      sig { params(name: String).returns(T.nilable(String)) }
+      def report(name)
+        line = CommandLookup.new(executor).describe(name)
+        stdout.puts(line || "#{name}: not found")
+        line
+      end
+    end
+  end
+end