rush-shell 0.0.2

data/lib/rush/alias_table.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  # The shell's alias definitions: a name maps to the replacement text the lexer
+  # splices in when the name appears in command position (POSIX 2.3.1). The
+  # `alias` builtin validates names; the table just stores what it is given.
+  class AliasTable
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @aliases = {}
+    end
+
+    sig { params(name: String, value: String).returns(String) }
+    def define(name, value)
+      @aliases[name] = value
+    end
+
+    sig { params(name: String).returns(T.nilable(String)) }
+    def remove(name)
+      @aliases.delete(name)
+    end
+
+    sig { params(name: String).returns(T.nilable(String)) }
+    def value(name)
+      @aliases.fetch(name, nil)
+    end
+
+    sig { params(name: String).returns(T::Boolean) }
+    def key?(name)
+      @aliases.key?(name)
+    end
+
+    sig { void }
+    def clear
+      @aliases.clear
+    end
+
+    # name => value pairs sorted by name, for `alias` with no operands. dash lists
+    # in hash order; rush sorts for a deterministic, testable listing.
+    sig { returns(T::Array[[String, String]]) }
+    def listing
+      @aliases.sort
+    end
+  end
+end

data/lib/rush/assignments.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  # Applies `name[=value]` declaration operands to shell variables. A missing `=`
+  # leaves the variable unchanged; `name=` assigns the empty string. The local
+  # path snapshots the parsed name before assignment.
+  class Assignments
+    extend T::Sig
+
+    sig { params(variables: ShellVariables).void }
+    def initialize(variables)
+      @variables = variables
+    end
+
+    sig { params(text: String).returns(String) }
+    def apply(text)
+      name, value = parse(text)
+      assign(name, value)
+      name
+    end
+
+    sig { params(text: String).returns(String) }
+    def apply_local(text)
+      name, value = parse(text)
+      @variables.declare_local(name)
+      assign(name, value)
+      name
+    end
+
+    private
+
+    sig { params(text: String).returns([String, T.nilable(String)]) }
+    def parse(text)
+      return [text, nil] unless text.include?('=')
+
+      parts = text.split('=', 2)
+      name = parts.fetch(0)
+      value = parts.fetch(1)
+      [name, value]
+    end
+
+    sig { params(name: String, value: T.nilable(String)).void }
+    def assign(name, value)
+      @variables.assign(name, value) if value
+    end
+  end
+end

data/lib/rush/ast/and_or.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `pipeline && pipeline` / `pipeline || pipeline`, left-associative. Runs the
+    # left side, then the right side only when the operator's short-circuit allows.
+    class AndOr < Node
+      extend T::Sig
+
+      attr_reader :left, :op, :right
+
+      sig { params(left: Node, op: Symbol, right: Node).void }
+      def initialize(left, op, right)
+        @left = left
+        @op = op
+        @right = right
+      end
+
+      # The left side is non-final, so it runs in a tested context (errexit
+      # suppressed); only the final command's status reaches the errexit check.
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        status = executor.errexit.tested { executor.run(left) }
+        run_right?(status) ? executor.run(right) : status
+      end
+
+      private
+
+      sig { params(status: Status).returns(T::Boolean) }
+      def run_right?(status)
+        succeeded = status.success?
+        op == :and ? succeeded : !succeeded
+      end
+    end
+  end
+end

data/lib/rush/ast/assignment.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `name=value` — value is an unexpanded Word (it receives tilde and the
+    # step-1 expansions, but no field splitting or pathname expansion).
+    Assignment = Data.define(:name, :value)
+
+    # Behaviour for the Data-defined assignment payload.
+    class Assignment
+      extend T::Sig
+
+      sig { returns(Integer) }
+      def source_line
+        value.source_line
+      end
+    end
+  end
+end

data/lib/rush/ast/brace_group.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `{ list; }` — groups commands without a subshell, so they run in the
+    # current shell environment. (Redirections on the group arrive with the
+    # fd-management slice.)
+    class BraceGroup < Node
+      extend T::Sig
+
+      attr_reader :body
+
+      sig { params(body: Node).void }
+      def initialize(body)
+        @body = body
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        executor.run(body)
+      end
+    end
+  end
+end

data/lib/rush/ast/case_node.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # One `pattern|pattern) body ;;` arm of a case statement.
+    CaseItem = Data.define(:patterns, :body)
+
+    # `case word in pattern) body ;; ... esac`. Expands the subject, then runs the
+    # body of the first arm with a pattern (fnmatch glob) that matches it; no
+    # match yields status 0. There is no fall-through.
+    class Case < Node
+      extend T::Sig
+
+      attr_reader :word, :items
+
+      sig { params(word: Word, items: T::Array[CaseItem]).void }
+      def initialize(word, items)
+        @word = word
+        @items = items
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        subject = executor.expander.expand_value(word)
+        item = items.find { |candidate| matches?(executor, candidate, subject) }
+        item ? executor.run(item.body) : Status.success
+      end
+
+      private
+
+      sig { params(executor: Executor, item: CaseItem, subject: String).returns(T::Boolean) }
+      def matches?(executor, item, subject)
+        item.patterns.any? do |pattern|
+          expanded = executor.expander.expand_pattern(pattern)
+          executor.system.fnmatch?(expanded, subject, locale: executor.state.variables.locale_settings)
+        end
+      end
+    end
+  end
+end

data/lib/rush/ast/condition_loop.rb

@@ -0,0 +1,34 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # Shared shape of the two condition-driven loops: hold the condition and
+    # body, delegate to LoopRunner with the subclass's kind — :while runs the
+    # body while the condition succeeds, :until until it does.
+    class ConditionLoop < Node
+      extend T::Sig
+
+      attr_reader :condition, :body
+
+      sig { params(condition: Node, body: Node).void }
+      def initialize(condition, body)
+        @condition = condition
+        @body = body
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        LoopRunner.new(executor, condition, body, kind).call
+      end
+
+      private
+
+      # The LoopRunner mode this node runs in.
+      sig { returns(Symbol) }
+      def kind
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rush/ast/for_node.rb

@@ -0,0 +1,34 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `for name [in words]; do body; done`. With an explicit word list the words
+    # are expanded (and field-split); with no `in` clause the loop iterates over
+    # the positional parameters ($@).
+    class For < Node
+      extend T::Sig
+
+      attr_reader :name, :words, :body
+
+      sig { params(name: String, words: T.nilable(T::Array[Word]), body: Node).void }
+      def initialize(name, words, body)
+        @name = name
+        @words = words
+        @body = body
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        ForRunner.new(executor, name, values(executor), body).call
+      end
+
+      private
+
+      sig { params(executor: Executor).returns(T::Array[String]) }
+      def values(executor)
+        words ? executor.expander.expand(words) : executor.state.positional.to_a
+      end
+    end
+  end
+end

data/lib/rush/ast/function_def.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `name() compound-command` — registers the body in the function table and
+    # succeeds. The body runs (in the current shell) when the name is invoked.
+    class FunctionDef < Node
+      extend T::Sig
+
+      attr_reader :name, :body
+
+      sig { params(name: String, body: Node).void }
+      def initialize(name, body)
+        @name = name
+        @body = body
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        executor.state.functions.define(name, body)
+        Status.success
+      end
+    end
+  end
+end

data/lib/rush/ast/if_node.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `if cond; then body; [elif/else ...] fi`. Runs the condition list; on
+    # success runs the consequent, otherwise the alternative (an else List, a
+    # nested If for elif, or nil). With no matching branch the status is 0.
+    class If < Node
+      extend T::Sig
+
+      attr_reader :condition, :consequent, :alternative
+
+      sig { params(condition: Node, consequent: Node, alternative: T.nilable(Node)).void }
+      def initialize(condition, consequent, alternative)
+        @condition = condition
+        @consequent = consequent
+        @alternative = alternative
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        return executor.run(consequent) if executor.succeeds?(condition)
+
+        alternative ? executor.run(alternative) : Status.success
+      end
+    end
+  end
+end

data/lib/rush/ast/list.rb

@@ -0,0 +1,47 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # One element of a list: an and-or list and whether it was terminated by `&`.
+    ListEntry = Data.define(:and_or, :async)
+
+    # A `;` / `&` / newline-separated list of and-or lists and the program root.
+    # Runs each entry in order; the list's status is the last entry's. An empty
+    # list (a blank or comment-only line, which is its own program under
+    # command-by-command reading) preserves $?, like dash. Async (`&`) entries
+    # fork a background subshell and return launch status in the parent.
+    class List < Node
+      extend T::Sig
+
+      attr_reader :entries
+
+      sig { params(entries: T::Array[ListEntry]).void }
+      def initialize(entries)
+        @entries = entries
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        entries.reduce(executor.state.last_status) { |_status, entry| run_entry(executor, entry) }
+      end
+
+      # A blank or comment-only program runs no command; SourceRunner skips it
+      # when tracking eval/dot's result status.
+      sig { returns(T::Boolean) }
+      def empty?
+        entries.empty?
+      end
+
+      private
+
+      # An async (&) command is exempt from errexit, so it runs in a tested context.
+      sig { params(executor: Executor, entry: ListEntry).returns(Status) }
+      def run_entry(executor, entry)
+        return executor.errexit.tested { executor.run_async(entry.and_or) } if entry.async
+
+        executor.run(entry.and_or)
+      end
+    end
+  end
+end

data/lib/rush/ast/node.rb

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # Base for every AST node. Subclasses implement #execute(executor) so the
+    # executor dispatches polymorphically and never switches on node type.
+    class Node
+      extend T::Sig
+
+      sig { params(_executor: Executor).returns(Status) }
+      def execute(_executor)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rush/ast/param_ref.rb

@@ -0,0 +1,59 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # Parses the body of ${...}: a parameter name plus an optional operator — the
+    # default/assign/error/alternative forms (- = ? +, optionally ':'-prefixed),
+    # the prefix/suffix removal forms (# ## % %%), or the ${#name} length form
+    # (recognised before the others, since a leading # also names $#).
+    PARAM_BRACED = /\A(\w+|[@*#?$!0-])(:?[-=?+]|\#{1,2}|%{1,2})?(.*)\z/m
+
+    ParamRef = Data.define(:name, :op, :arg)
+
+    # A parameter reference parsed from $name or ${...}. The operator word is
+    # expanded lazily at expansion time.
+    class ParamRef
+      extend T::Sig
+
+      sig { params(name: String).returns(ParamRef) }
+      def self.simple(name)
+        new(name: name, op: nil, arg: nil)
+      end
+
+      sig { params(body: String).returns(ParamRef) }
+      def self.parse(body)
+        return new(name: body.delete_prefix('#'), op: '#len', arg: nil) if length?(body)
+
+        match = braced_match(body)
+        new(name: braced_name(match), op: match[2], arg: match[3])
+      end
+
+      sig { params(body: String).returns(T::Boolean) }
+      def self.length?(body)
+        body.start_with?('#') && body.length > 1
+      end
+
+      # dash's job text always braces a parameter — ${T}, "${@}", ${T:-9}
+      # with the op's raw source argument (CommandText).
+      sig { returns(String) }
+      def canon
+        return "${##{name}}" if op == '#len'
+
+        "${#{name}#{op}#{arg}}"
+      end
+
+      sig { params(body: String).returns(MatchData) }
+      def self.braced_match(body)
+        PARAM_BRACED.match(body) || raise(ExpansionError, 'bad substitution')
+      end
+      private_class_method :braced_match
+
+      sig { params(match: MatchData).returns(String) }
+      def self.braced_name(match)
+        match[1] || raise(ExpansionError, 'bad substitution')
+      end
+      private_class_method :braced_name
+    end
+  end
+end

data/lib/rush/ast/pipeline.rb

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # A pipeline of one or more commands, optionally negated with `!`. A single
+    # command runs in-process (so builtins affect the shell); a multi-stage
+    # pipeline forks each stage via PipelineRunner. Negation inverts the status.
+    class Pipeline < Node
+      extend T::Sig
+
+      attr_reader :commands, :negate
+
+      sig { params(commands: T::Array[Node], negate: T::Boolean).void }
+      def initialize(commands, negate)
+        @commands = commands
+        @negate = negate
+      end
+
+      # A negated pipeline (`! cmd`) is exempt from errexit and runs its stages in
+      # a tested context; otherwise the leaf status is the errexit check point.
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        return invert(executor.errexit.tested { run_stages(executor) }) if negate
+
+        executor.errexit.exit_on_error(run_stages(executor))
+      end
+
+      private
+
+      sig { params(executor: Executor).returns(Status) }
+      def run_stages(executor)
+        case commands
+        in [command] then executor.run(command)
+        else PipelineRunner.new(executor, commands).call
+        end
+      end
+
+      sig { params(status: Status).returns(Status) }
+      def invert(status)
+        status.success? ? Status.failure : Status.success
+      end
+    end
+  end
+end

data/lib/rush/ast/redirect.rb

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # A redirection: a kind (:in/:out/:append/:dup_in/:dup_out/:readwrite/
+    # :clobber), an unexpanded target Word, and an optional explicit fd parsed
+    # from a leading IO_NUMBER (nil means the kind's default fd).
+    Redirect = Data.define(:kind, :target, :io_number)
+
+    # Behaviour for the Data-defined redirection payload.
+    class Redirect
+      extend T::Sig
+
+      sig { returns(Integer) }
+      def source_line
+        target.source_line
+      end
+    end
+  end
+end

data/lib/rush/ast/redirected.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # A compound command (group, subshell, loop, if, case) carrying redirections
+    # on the whole command: they build a base IoTable that every command in the
+    # body inherits, restored once the command finishes. Its status is the body's.
+    class Redirected < Node
+      extend T::Sig
+
+      attr_reader :command, :redirects
+
+      sig { params(command: Node, redirects: T::Array[Redirect]).void }
+      def initialize(command, redirects)
+        @command = command
+        @redirects = redirects
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        executor.run_redirected(command, redirects)
+      end
+    end
+  end
+end

data/lib/rush/ast/simple_command.rb

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `name=val ... cmd arg ... >file` — variable assignments, argv words and
+    # redirections, preserving both grouped accessors and original source parts.
+    class SimpleCommand < Node
+      extend T::Sig
+
+      Part = T.type_alias { T.any(Assignment, Word, Redirect) }
+
+      attr_reader :parts, :source_line
+
+      sig do
+        params(assignments: T::Array[Assignment], words: T::Array[Word], redirects: T::Array[Redirect],
+               source_line: Integer).returns(SimpleCommand)
+      end
+      def self.from_groups(assignments, words, redirects, source_line: 1)
+        new(assignments + words + redirects, source_line: source_line)
+      end
+
+      sig { params(parts: T::Array[Part]).returns(Integer) }
+      def self.source_line(parts)
+        parts.map(&:source_line).min || 1
+      end
+
+      sig { params(parts: T::Array[Part], source_line: Integer).void }
+      def initialize(parts, source_line: self.class.source_line(parts))
+        @parts = parts
+        @source_line = source_line
+      end
+
+      sig { returns(T::Array[Assignment]) }
+      def assignments
+        result = T.let([], T::Array[Assignment])
+        parts.each { |part| result << part if part.is_a?(Assignment) }
+        result
+      end
+
+      sig { returns(T::Array[Word]) }
+      def words
+        result = T.let([], T::Array[Word])
+        parts.each { |part| result << part if part.is_a?(Word) }
+        result
+      end
+
+      sig { returns(T::Array[Redirect]) }
+      def redirects
+        result = T.let([], T::Array[Redirect])
+        parts.each { |part| result << part if part.is_a?(Redirect) }
+        result
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        executor.state.record_lineno(source_line)
+        executor.run_simple(self)
+      end
+    end
+  end
+end

data/lib/rush/ast/subshell.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `( list )` — runs the list in a subshell (a forked child) so cd and
+    # variable changes do not affect the current shell. Its status is the list's.
+    class Subshell < Node
+      extend T::Sig
+
+      attr_reader :body
+
+      sig { params(body: Node).void }
+      def initialize(body)
+        @body = body
+      end
+
+      sig { params(executor: Executor).returns(Status) }
+      def execute(executor)
+        SubshellRunner.new(executor, body).call
+      end
+    end
+  end
+end

data/lib/rush/ast/until_node.rb

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: true
+
+module Rush
+  module AST
+    # `until cond; do body; done` — runs the body until the condition succeeds.
+    class Until < ConditionLoop
+      extend T::Sig
+
+      private
+
+      sig { returns(Symbol) }
+      def kind
+        :until
+      end
+    end
+  end
+end