cargo-pipe 0.1.14

A command-line tool to generate and build data integration app using pipebase framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use crate::print::Printer;
use pipegen::models::App;
use pipegen::models::Dependency;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::Path;

pub(crate) fn read_pipe_manifest(
    manifest_path: &Path,
    printer: &mut Printer,
) -> anyhow::Result<App> {
    printer.status(&"Parse", manifest_path.to_str().unwrap())?;
    let app = match App::read_from_path(manifest_path) {
        Ok(app) => app,
        Err(err) => {
            printer.error(err.to_string())?;
            return Err(err.into());
        }
    };
    printer.status(&"Parse", "succeed")?;
    Ok(app)
}

#[derive(Deserialize, Serialize, Debug)]
pub struct PipeTomlProject {
    name: String,
    version: String,
    authors: Option<Vec<String>>,
    edition: Option<String>,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct PipeTomlDependency {
    version: Option<String>,
    path: Option<String>,
    git: Option<String>,
    branch: Option<String>,
    tag: Option<String>,
    features: Option<Vec<String>>,
    package: Option<String>,
}

impl From<Dependency> for PipeTomlDependency {
    fn from(pd: Dependency) -> Self {
        PipeTomlDependency {
            version: pd.get_version(),
            path: pd.get_path(),
            git: pd.get_git(),
            branch: pd.get_branch(),
            tag: pd.get_tag(),
            features: pd.get_features(),
            package: pd.get_package(),
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
pub struct PipeTomlWorkspace {}

impl PipeTomlWorkspace {
    pub fn new() -> Self {
        PipeTomlWorkspace {}
    }
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct PipeTomlManifest {
    package: Option<PipeTomlProject>,
    dependencies: Option<HashMap<String, PipeTomlDependency>>,
    workspace: Option<PipeTomlWorkspace>,
}

impl PipeTomlManifest {
    pub fn init(&mut self) {
        self.dependencies = Some(HashMap::new());
        self.workspace = Some(PipeTomlWorkspace::new());
    }

    pub fn add_dependency(&mut self, name: String, dependency: PipeTomlDependency) {
        let dependencies = self.dependencies.as_mut().unwrap();
        dependencies.insert(name, dependency);
    }
}