Function hyper_scripter::util::hijack_ctrlc_once

pub fn hijack_ctrlc_once()

Examples found in repository

src/query/util.rs (line 184)

fn prompt_fuzz_acceptable(script: &ScriptInfo) -> Result {
    use colored::{Color, Colorize};
    use console::{Key, Term};

    let term = Term::stderr();

    let ty = get_display_type(&script.ty);
    let msg = format!(
        "{} [Y/N]",
        format!("{}({})?", script.name, ty.display())
            .color(ty.color())
            .bold(),
    );

    term.hide_cursor()?;
    hijack_ctrlc_once();

    enum Res {
        Y,
        N,
        Exit,
    }

    let res = loop {
        term.write_str(&msg)?;
        match term.read_key() {
            Ok(Key::Char('Y' | 'y') | Key::Enter) => break Res::Y,
            Ok(Key::Char('N' | 'n')) => break Res::N,
            Ok(Key::Char(ch)) => term.write_line(&format!(" Unknown key '{}'", ch))?,
            Ok(Key::Escape) => {
                break Res::Exit;
            }
            Err(e) => {
                if e.kind() == std::io::ErrorKind::Interrupted {
                    break Res::Exit;
                } else {
                    return Err(e.into());
                }
            }
            _ => term.write_line(" Unknown key")?,
        }
    };
    term.show_cursor()?;

    match res {
        Res::Exit => {
            term.show_cursor()?;
            std::process::exit(1);
        }
        Res::Y => {
            term.write_line(&" Y".color(Color::Green).to_string())?;
            Ok(())
        }
        Res::N => {
            term.write_line(&" N".color(Color::Red).to_string())?;
            Err(Error::DontFuzz)
        }
    }
}

src/util/main_util.rs (line 217)

pub async fn run_n_times(
    repeat: u64,
    dummy: bool,
    entry: &mut RepoEntry<'_>,
    mut args: Vec<String>,
    res: &mut Vec<Error>,
    use_previous: bool,
    error_no_previous: bool,
    dir: Option<PathBuf>,
) -> Result {
    log::info!("執行 {:?}", entry.name);
    super::hijack_ctrlc_once();

    let mut env_vec = vec![];
    if use_previous {
        let dir = super::option_map_res(dir, |d| path::normalize_path(d))?;
        let historian = &entry.get_env().historian;
        match historian.previous_args(entry.id, dir.as_deref()).await? {
            None if error_no_previous => {
                return Err(Error::NoPreviousArgs);
            }
            None => log::warn!("無前一次參數，當作空的"),
            Some((arg_str, envs_str)) => {
                log::debug!("撈到前一次呼叫的參數 {}", arg_str);
                let mut prev_arg_vec: Vec<String> =
                    serde_json::from_str(&arg_str).context(format!("反序列失敗 {}", arg_str))?;
                env_vec =
                    serde_json::from_str(&envs_str).context(format!("反序列失敗 {}", envs_str))?;
                prev_arg_vec.extend(args.into_iter());
                args = prev_arg_vec;
            }
        }
    }

    let here = path::normalize_path(".").ok();
    let script_path = path::open_script(&entry.name, &entry.ty, Some(true))?;
    let content = super::read_file(&script_path)?;

    let mut hs_env_desc = vec![];
    for (need_save, line) in extract_env_from_content_help_aware(&content) {
        hs_env_desc.push(line.to_owned());
        if need_save {
            EnvPair::process_line(line, &mut env_vec);
        }
    }
    EnvPair::sort(&mut env_vec);
    let env_record = serde_json::to_string(&env_vec)?;

    let run_id = entry
        .update(|info| info.exec(content, &args, env_record, here))
        .await?;

    if dummy {
        log::info!("--dummy 不用真的執行，提早退出");
        return Ok(());
    }
    // Start packing hs tmpl val
    let hs_home = path::get_home();
    let hs_tags: Vec<_> = entry.tags.iter().map(|t| t.as_ref()).collect();
    let hs_cmd = std::env::args().next().unwrap_or_default();

    let hs_exe = std::env::current_exe()?;
    let hs_exe = hs_exe.to_string_lossy();

    let content = &entry.exec_time.as_ref().unwrap().data().unwrap().0;
    let hs_tmpl_val = json!({
        "path": script_path,
        "home": hs_home,
        "run_id": run_id,
        "tags": hs_tags,
        "cmd": hs_cmd,
        "exe": hs_exe,
        "env_desc": hs_env_desc,
        "name": &entry.name.key(),
        "content": content,
    });
    // End packing hs tmpl val

    for _ in 0..repeat {
        let run_res = run(&script_path, &*entry, &args, &hs_tmpl_val, &env_vec);
        let ret_code: i32;
        match run_res {
            Err(Error::ScriptError(code)) => {
                ret_code = code;
                res.push(run_res.unwrap_err());
            }
            Err(e) => return Err(e),
            Ok(_) => ret_code = 0,
        }
        entry
            .update(|info| info.exec_done(ret_code, run_id))
            .await?;
    }
    Ok(())
}