Function run_interactive

cli/src/lib.rs:124–179

Executes the `path` program in a fresh machine allowing any interactive-only calls. `local_drive` is the optional local drive to mount and use as the default location. `service_url` is the base URL of the cloud service. If `path` starts with `cloud://`, this uses the same auto-run features that the web UI exposes. The presence of this here is kind of a hack but avoids having too much logic just

(
    path: &str,
    console_factory: Box<dyn ConsoleFactory>,
    signals_chan: (Sender<Signal>, Receiver<Signal>),
    gpio_pins_spec: Option<&str>,
    local_drive_spec: &str,
    service_url: &st

/// exposes.  The presence of this here is kind of a hack but avoids having too much logic
/// just in the web and helps test this feature.
pub async fn run_interactive(
    path: &str,
    console_factory: Box<dyn ConsoleFactory>,
    signals_chan: (Sender<Signal>, Receiver<Signal>),
    gpio_pins_spec: Option<&str>,
    local_drive_spec: &str,
    service_url: &str,
) -> Result<i32> {
    let mut builder = new_machine_builder(console_factory, signals_chan, gpio_pins_spec)?;
    let console = builder.get_console();
    let program = Rc::from(RefCell::from(endbasic_repl::editor::Editor::default()));
    let storage = Rc::from(RefCell::from(Storage::default()));
    setup_storage(&mut storage.borrow_mut(), local_drive_spec)?;

    let service = Rc::from(RefCell::from(CloudService::new(service_url)?));
    endbasic_client::add_all(
        &mut builder,
        service,
        console.clone(),
        storage.clone(),
        "https://repl.endbasic.dev/",
    );

    let mut machine = builder
        .make_interactive()
        .with_program(program.clone())
        .with_storage(storage.clone())
        .build();

    match path.strip_prefix("cloud://") {
        Some(username_path) => {
            let path =
                endbasic_repl::mount_cloud_share(console.clone(), storage.clone(), username_path)?;
            let code = endbasic_repl::run_from_storage_path(
                &mut machine,
                console.clone(),
                storage.clone(),
                program.clone(),
                &path,
                false,
            )
            .await?;
            Ok(code)
        }
        None => {
            let mut input = File::open(path)?;
            machine.compile(&mut input)?;
            match machine.exec().await {
                Ok(Some(code)) => Ok(code),
                Ok(None) => Ok(0),
                Err(StdError::Break) => Ok(INTERRUPTED_EXIT_CODE),
                Err(e) => Err(e.into()),
            }
        }
    }
}

/// Representation of the CLI execution mode and the arguments required for each.