fn try_from()

in components/support/nimbus-cli/src/main.rs [263:418]
151 lines of code
3 McCabe index (conditional complexity)

    fn try_from(cli: &Cli) -> Result<Self> {
        let params = NimbusApp::from(cli);
        Ok(match cli.command.clone() {
            CliCommand::ApplyFile {
                file,
                preserve_nimbus_db,
                open,
            } => {
                let app = LaunchableApp::try_from(cli)?;
                let list = ExperimentListSource::try_from(file.as_path())?;
                AppCommand::ApplyFile {
                    app,
                    open: open.into(),
                    list,
                    preserve_nimbus_db,
                }
            }
            CliCommand::CaptureLogs { file } => {
                let app = LaunchableApp::try_from(cli)?;
                AppCommand::CaptureLogs { app, file }
            }
            CliCommand::Defaults {
                feature_id,
                output,
                manifest,
            } => {
                let manifest = ManifestSource::try_from(&params, &manifest)?;
                AppCommand::Defaults {
                    manifest,
                    feature_id,
                    output,
                }
            }
            CliCommand::Enroll {
                branch,
                rollouts,
                preserve_targeting,
                preserve_bucketing,
                preserve_nimbus_db,
                experiment,
                open,
                ..
            } => {
                let app = LaunchableApp::try_from(cli)?;
                // Ensure we get the rollouts from the same place we get the experiment from.
                let mut recipes: Vec<ExperimentSource> = Vec::new();
                for r in rollouts {
                    let rollout = ExperimentArgs {
                        experiment: r,
                        ..experiment.clone()
                    };
                    recipes.push(ExperimentSource::try_from(&rollout)?);
                }

                let experiment = ExperimentSource::try_from(cli)?;

                Self::Enroll {
                    app,
                    params,
                    experiment,
                    branch,
                    rollouts: recipes,
                    preserve_targeting,
                    preserve_bucketing,
                    preserve_nimbus_db,
                    open: open.into(),
                }
            }
            CliCommand::Features {
                manifest,
                branch,
                feature_id,
                output,
                validate,
                multi,
                ..
            } => {
                let manifest = ManifestSource::try_from(&params, &manifest)?;
                let experiment = ExperimentSource::try_from(cli)?;
                AppCommand::ExtractFeatures {
                    experiment,
                    branch,
                    manifest,
                    feature_id,
                    validate,
                    multi,
                    output,
                }
            }
            CliCommand::Fetch { output, .. } | CliCommand::FetchList { output, .. } => {
                let list = ExperimentListSource::try_from(cli)?;

                AppCommand::FetchList { list, file: output }
            }
            CliCommand::Fml { args } => {
                let cwd = std::env::current_dir().expect("Current Working Directory is not set");
                AppCommand::FmlPassthrough { args, cwd }
            }
            CliCommand::Info { experiment, output } => AppCommand::Info {
                experiment: ExperimentSource::try_from(&experiment)?,
                output,
            },
            CliCommand::List { .. } => {
                let list = ExperimentListSource::try_from(cli)?;
                AppCommand::List { list }
            }
            CliCommand::LogState { open } => {
                let app = LaunchableApp::try_from(cli)?;
                AppCommand::LogState {
                    app,
                    open: open.into(),
                }
            }
            CliCommand::Open { open, .. } => {
                let app = LaunchableApp::try_from(cli)?;
                AppCommand::Open {
                    app,
                    open: open.into(),
                }
            }
            #[cfg(feature = "server")]
            CliCommand::StartServer => AppCommand::StartServer,
            CliCommand::TailLogs => {
                let app = LaunchableApp::try_from(cli)?;
                AppCommand::TailLogs { app }
            }
            CliCommand::TestFeature { files, open, .. } => {
                let app = LaunchableApp::try_from(cli)?;
                let experiment = ExperimentSource::try_from(cli)?;
                let first = files
                    .first()
                    .ok_or_else(|| anyhow::Error::msg("Need at least one file to make a branch"))?;
                let branch = feature_utils::slug(first)?;

                Self::Enroll {
                    app,
                    params,
                    experiment,
                    branch,
                    rollouts: Default::default(),
                    open: open.into(),
                    preserve_targeting: false,
                    preserve_bucketing: false,
                    preserve_nimbus_db: false,
                }
            }
            CliCommand::Unenroll { open } => {
                let app = LaunchableApp::try_from(cli)?;
                AppCommand::Unenroll {
                    app,
                    open: open.into(),
                }
            }
            _ => Self::NoOp,
        })
    }