xcodebuild 0.1.10

xcodebuild command wrapper, runner and log parser.
Documentation 
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::parser::Step;

use super::super::{
    util::consume_till_empty_line, Description, Error, OutputStream, ParsableFromStream,
    ProcessItem,
};
use async_trait::async_trait;
use std::{fmt::Display, path::PathBuf};
use tap::Pipe;
use tokio_stream::StreamExt;

/// Code Sign step
#[derive(Debug)]
pub struct CodeSign {
    pub description: Description,
    pub identity: String,
    pub profile: Option<String>,
    pub dir: PathBuf,
    pub sign_key: String,
}

#[async_trait]
impl ParsableFromStream for CodeSign {
    async fn parse_from_stream(
        line: String,
        stream: &mut OutputStream,
    ) -> Result<Vec<Step>, Error> {
        let mut steps = vec![];
        let mut chunks = line.split_whitespace();
        let dir = chunks
            .next()
            .map(PathBuf::from)
            .ok_or_else(|| Error::EOF("CodeSign".into(), "dir".into()))?;

        chunks.next();
        let description = Description::from_line(line)?;

        // Skip exports
        steps.extend(consume_till_empty_line(stream).await);

        let identity = if let Some(ProcessItem::Output(line)) = stream.next().await {
            line.trim()
                .strip_prefix("Signing Identity:")
                .ok_or_else(|| {
                    #[cfg(feature = "with_tracing")]
                    tracing::error!("line: {line}");
                    Error::Failure("Striping identity prefix".into())
                })?
                .trim()
                .replace("\"", "")
        } else {
            return Err(Error::EOF("CodeSign".into(), "identity".into()));
        };

        let profile = if let Some(ProcessItem::Output(line)) = stream.next().await {
            line.trim()
                .strip_prefix("Provisioning Profile:")
                .map(|s| s.trim().replace("\"", ""))
        } else {
            return Err(Error::EOF("CodeSign".into(), "profile".into()));
        };

        // Skip emptry lines
        steps.extend(consume_till_empty_line(stream).await);

        let sign_key = if let Some(ProcessItem::Output(line)) = stream.next().await {
            line.trim()
                .split_whitespace()
                .collect::<Vec<&str>>()
                .get(3)
                .map(ToString::to_string)
                .ok_or_else(|| Error::EOF("CodeSign".into(), "sign_key".into()))?
        } else {
            return Err(Error::EOF("CodeSign".into(), "profile".into()));
        };

        steps.push(Step::CodeSign(Self {
            description,
            identity,
            profile,
            dir,
            sign_key,
        }));

        steps.pipe(Ok)
    }
}

#[tokio::test]
#[cfg_attr(feature = "with_tracing", tracing_test::traced_test)]
async fn test() {
    use crate::parser::util::test::to_stream_test;

    let steps = to_stream_test! {
        CodeSign,
r#"CodeSign path/to/build/Debug-iphoneos/DemoTarget.app (in target 'DemoTarget' from project 'DemoProject')
    cd /path/to/project
    export CODESIGN_ALLOCATE\=/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/codesign_allocate
    
    Signing Identity:     "Apple Development: email@email.com (XXXXXXXXXX)"
    Provisioning Profile: "iOS Team Provisioning Profile: tami5.DemoProject"
                          (42dd5b24-0395-46bb-bb88-2aed95a7831b)
    
    /usr/bin/codesign --force --sign XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX --entitlements path/to/build/DemoTarget.build/Debug-iphoneos/DemoTarget.build/DemoTarget.app.xcent --timestamp\=none --generate-entitlement-der path/to/build/Debug-iphoneos/DemoTarget.app

       "#
    };

    if let Step::CodeSign(step) = steps.first().unwrap() {
        assert_eq!("DemoTarget", &step.description.target);
        assert_eq!("DemoProject", &step.description.project);
        assert_eq!(
            "Apple Development: email@email.com (XXXXXXXXXX)",
            &step.identity
        );
        assert_eq!(
            Some("iOS Team Provisioning Profile: tami5.DemoProject".to_string()),
            step.profile
        );
        assert_eq!("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", &step.sign_key);
    } else {
        panic!("{steps:#?}")
    }
}

impl Display for CodeSign {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{} Signing `{}`",
            self.description,
            self.dir.file_name().unwrap().to_str().unwrap(),
        )
    }
}

#[tokio::test]
#[cfg_attr(feature = "with_tracing", tracing_test::traced_test)]
async fn fmt() {
    let data = CodeSign {
        description: Description {
            project: "Project".into(),
            target: "Target".into(),
        },
        identity: "Apple Development: email@email.com (XXXXXXXXXX)".into(),
        profile: Some("iOS Team Provisioning Profile: tami5.DemoProject".into()),
        dir: "/path/to/Target.App".into(),
        sign_key: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX".into(),
    };

    assert_eq!(
        "[Project.Target] Signing     `Target.App`",
        &format!("{}", data),
    );
}