fusion-lang 0.0.1.alpha2 → 0.0.1

data/lib/fusion/cli/serializer.rb

@@ -14,22 +14,23 @@ module Fusion
       def serialize(runtime_value, lenient: false)
         message = catch(:unserializable) do
           if runtime_value.is_a?(Interpreter::ErrorVal)
-            data = convert(runtime_value.payload, lenient: lenient || runtime_value.internal_error?).to_json
+            error = runtime_value
+            data = convert(error.payload, lenient: lenient || error.runtime?).to_json
             return WirePair.new(status: 1, data: data)
           else
             return WirePair.new(status: 0, data: convert(runtime_value, lenient: lenient).to_json)
           end
         end
 
-        internal_error = Interpreter::ErrorVal.internal(
+        runtime_error = Interpreter::ErrorVal.from_runtime(
           kind: "serialization_error",
-          location: "output",
+          origin: "output",
           operation: "serializing result",
           input: runtime_value,
           message: message
         )
 
-        serialize(internal_error, lenient: true)
+        serialize(runtime_error, lenient: true)
       end
 
       private

data/lib/fusion/cli.rb

@@ -21,40 +21,67 @@ module Fusion
   module CLI
     extend self
 
-    # Run the use case selected on the command line.
+    def prepare!
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdin.set_encoding(Encoding::UTF_8)
+      $stdout.set_encoding(Encoding::UTF_8)
+      $stderr.set_encoding(Encoding::UTF_8)
+    end
+
     def run(options)
       case options.use_case
-      when :pipe then run_pipe(options)
-      when :stream then run_stream(options)
-      when :repl then Repl.new.run
-      else raise Unreachable, "Unknown use case #{options.use_case}"
+      when :pipe
+        run_pipe(options)
+      when :stream
+        run_stream(options)
+      when :repl
+        run_repl(options)
+      else
+        raise Unreachable, "Unknown use case #{options.use_case}"
       end
     end
 
-    # pipe: load the program, pipe one input through it, emit one output.
     def run_pipe(options)
-      function = load_program(options)
-      input    = parse(load_input(options))
-      output   = apply(input, function)
+      prepare!
+
+      root = root_environment(jail: jail_root(options))
+      program = load_program(options, root)
+
+      input = load_input(options)
+      output = if input.nil?
+        program
+      else
+        apply(parse(input), program, environment: root)
+      end
+
       emit_output(serialize(output), output_mode: options.output_mode)
     end
 
-    # stream: load the program once, then treat stdin/stdout as NDJSON streams —
-    # one input per line, one output line per input. Errors stay in-band (the
-    # unix mode is unavailable here), so the exit code is always 0.
     def run_stream(options)
-      function = load_program(options)
-      $stdout.sync = true
-      $stdin.each_line do |line|
-        next if line.strip.empty?
+      prepare!
+
+      root = root_environment(jail: jail_root(options))
+      program = load_program(options, root)
 
-        input  = parse(decode(line, mode: options.input_mode))
-        output = apply(input, function)
-        $stdout.puts(encode(serialize(output), mode: options.output_mode))
+      $stdin.each_line do |line|
+        record = line.chomp
+
+        if record.strip.empty?
+          $stdout.puts unless options.skip_blank_lines?
+        else
+          input = decode(record, mode: options.input_mode)
+          output = apply(parse(input), program, environment: root)
+          $stdout.puts(encode(serialize(output), mode: options.output_mode))
+        end
       end
     end
 
-    # String -> WirePair
+    def run_repl(options)
+      Repl.new(root_env: root_environment(jail: jail_root(options))).run
+    end
+
+    # String (treated as stdin) -> WirePair
     # Doesn't support mode `:unix`
     def decode(string, mode:)
       Decoder.decode(string, mode:)
@@ -65,18 +92,56 @@ module Fusion
       Parser.parse(wire_pair)
     end
 
+    # A binding-free root environment
+    def root_environment(jail: Dir.pwd)
+      Interpreter::Env.new.set_context(:jail, jail)
+    end
+
+    # String (treated as inline source) -> runtime value
+    def load_source(inline_source, root_env)
+      ast = Fusion::Parser.parse_file(inline_source, site: { origin: "code", file: "<inline>" })
+      return ast if ast.is_a?(Fusion::Interpreter::ErrorVal) # a parse error
+
+      inline_env = root_env.child.set_context(:dir, Dir.pwd)
+      Fusion::Interpreter.new(inline_env).evaluate_unit(ast)
+    end
+
+    # relative path -> runtime_value
+    def load_file(rel_path, root_env)
+      interp = Fusion::Interpreter.new(root_env)
+      abspath = File.expand_path(rel_path)
+      # The top-level program file is loaded by the runtime, not via an @-reference:
+      # the operation is "loading code", with the path as `input` (which file).
+      interp.load_file(abspath).force(operation: "loading code", input: interp.display_path(abspath), site: { origin: "code", file: nil })
+    end
+
+    # runtime value + runtime value -> runtime value
     # input | function -> output
-    def apply(input, function)
-      Interpreter.safe_apply(function, input)
+    # Confines @-resolution to the environment's jail.
+    # Ignores the environment's bindings. The function carries its own closure.
+    def apply(input, function, environment:)
+      Interpreter.safe_apply(function, input, environment)
     end
 
-    # expression -> runtime value
-    # Mutates environment (REPL variable binding)
-    def evaluate(expression, environment)
-      Interpreter.safe_evaluate(expression, environment)
+    # expression (AST) -> runtime value
+    # Mutates environment if given an assignment statement.
+    # Confines @-resolution to the environment's jail.
+    # Has access to the environment's bindings.
+    def evaluate(ast, environment)
+      case ast
+      when AST::Statement::Assignment
+        value = Interpreter.safe_evaluate(ast.expression, environment)
+        environment.bind(ast.name, value, checked: false)
+        value
+      when AST::Expression
+        Interpreter.safe_evaluate(ast, environment)
+      else
+        raise Unreachable, "Unhandled AST node #{ast.class}"
+      end
     end
 
     # runtime value -> WirePair
+    # CAUTION: resolves "internal" error status, only use for final output
     def serialize(runtime_value)
       Serializer.serialize(runtime_value)
     end
@@ -89,22 +154,23 @@ module Fusion
 
     private
 
-    # input -> WirePair
+    # stdin -> WirePair
     def load_input(options)
-      text = options.explicit_input || ($stdin.tty? ? "" : $stdin.read)
-      empty = text.strip.empty?
-
-      if options.input_mode == :unix || empty
-        WirePair.new(
-          status: options.error_input? ? 1 : 0,
-          data: empty ? "null" : text
-        )
+      text = $stdin.tty? ? "" : $stdin.read.strip
+
+      if text.empty?
+        # "-!" promises that stdin carries an error payload. CLI contract violation.
+        raise Options::UsageError, "-! requires input to mark as an error, but stdin was empty" if options.error_input?
+
+        nil
+      elsif options.input_mode == :unix
+        WirePair.new(status: options.error_input? ? 1 : 0, data: text)
       else
         decode(text, mode: options.input_mode)
       end
     end
 
-    # WirePair -> output
+    # WirePair -> stdout/stderr
     def emit_output(wire_pair, output_mode:)
       if output_mode == :unix
         channel = wire_pair.status.zero? ? $stdout : $stderr
@@ -116,21 +182,26 @@ module Fusion
       end
     end
 
-    # Load the program (a `.fsn` file or an inline `-e` source) into the runtime
-    # value it evaluates to — usually a function. A parse error or a non-function
-    # value flows on as the program value and surfaces when `apply` runs it.
-    def load_program(options)
-      interpreter = Fusion::Interpreter.new
+    # file/inline -> runtime value
+    def load_program(options, root_env)
       if options.inline_source
-        ast = Fusion::Parser.parse_file(options.inline_source, location: "code <inline>")
-        return ast if ast.is_a?(Fusion::Interpreter::ErrorVal) # a parse error
-
-        env = interpreter.root_env.child
-        env.define("__dir__", Dir.pwd)
-        interpreter.eval_expr(ast, env)
+        load_source(options.inline_source, root_env)
       else
-        interpreter.load_file(File.expand_path(options.program_path)).force
+        load_file(options.program_path, root_env)
       end
     end
+
+    # The jail root for this run: the program's directory by default (cwd for
+    # inline `-e` and the REPL), or `--jail DIR` resolved against that base.
+    # `--jail '*'` opts out of confinement entirely (nil = unconfined).
+    def jail_root(options)
+      return nil if options.jail == "*"
+
+      base = options.program_path ? File.dirname(File.expand_path(options.program_path)) : Dir.pwd
+      root = options.jail ? File.expand_path(options.jail, base) : base
+      raise Options::UsageError, "jail directory not found: #{options.jail}" unless File.directory?(root)
+
+      root
+    end
   end
 end