intercom-common 0.3.0

See 'intercom'
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


use ::prelude::*;
use super::*;

use ::guid::GUID;
use ::syn::{ LitStr, Path };

intercom_attribute!(
    ComLibraryAttr< ComLibraryAttrParam, Path > {
        libid : LitStr,
    }
);

/// COM library details derived from the `com_library` attribute.
#[derive(Debug, PartialEq)]
pub struct ComLibrary {
    name : String,
    libid : GUID,
    coclasses : Vec<Path>,
}

impl ComLibrary
{
    /// Parses a [com_library] attribute.
    pub fn parse(
        crate_name : &str,
        attr_params : TokenStream,
    ) -> ParseResult<ComLibrary>
    {
        let attr : ComLibraryAttr = ::syn::parse2( attr_params )
            .map_err( |_| ParseError::ComLibrary(
                    "Attribute syntax error".into() ) )?;

        // The first parameter is the LIBID of the library.
        let libid = match attr.libid().map_err( ParseError::ComLibrary )? {
            Some( libid ) => GUID::parse( &libid.value() )
                    .map_err( ParseError::ComLibrary )?,
            None => ::utils::generate_libid( crate_name )
        } ;

        Ok( ComLibrary {
            name: crate_name.to_owned(),
            coclasses: attr.args().into_iter().cloned().collect(),
            libid,
        } )
    }

    /// Library name.
    pub fn name( &self ) -> &str { &self.name }

    /// Library LIBID.
    pub fn libid( &self ) -> &GUID { &self.libid }

    /// CoClasses exposed by the library.
    pub fn coclasses( &self ) -> &[Path] { &self.coclasses }

    /// Adds a coclass.
    pub fn add_coclass( &mut self, clsid : Path ) { self.coclasses.push( clsid ) }
}

#[cfg(test)]
mod test
{
    use super::*;

    #[test]
    fn parse_com_library() {

        let lib = ComLibrary::parse(
            "library_name".into(),
            quote!( libid = "12345678-1234-1234-1234-567890ABCDEF",
                    Foo, Bar ) )
                .expect( "com_library attribute parsing failed" );

        assert_eq!( lib.name(), "library_name" );
        assert_eq!( lib.libid(), &GUID {
            data1: 0x12345678,
            data2: 0x1234,
            data3: 0x1234,
            data4: [ 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF ]
        } );
        assert_eq!( lib.coclasses().len(), 2 );
        assert_eq!( lib.coclasses()[0], parse_quote!( Foo ) );
        assert_eq!( lib.coclasses()[1], parse_quote!( Bar ) );
    }

    #[test]
    fn parse_com_library_with_auto_guid() {

        // This test derives the GUID from the library name.
        //
        // What the final GUID is isn't important, what _is_ important however
        // is that the final GUID will not change ever as long as the library
        // name stays the same.
        let lib = ComLibrary::parse(
            "another_library".into(),
            quote!( One, Two ) )
                .expect( "com_library attribute parsing failed" );

        assert_eq!( lib.name(), "another_library" );
        assert_eq!(
                lib.libid(),
                &GUID::parse( "696B2FAE-AC56-3E08-7C2C-ABAA8DB8F6E3" ).unwrap() );
        assert_eq!( lib.coclasses().len(), 2 );
        assert_eq!( lib.coclasses()[0], parse_quote!( One ) );
        assert_eq!( lib.coclasses()[1], parse_quote!( Two ) );
    }

    #[test]
    fn parse_com_library_with_empty_parameters() {

        let lib = ComLibrary::parse( "lib".into(), quote!() ).unwrap();
        assert_eq!( lib.coclasses().len(), 0 );
        assert_eq!(
                lib.libid(),
                &GUID::parse( "22EC0095-CD17-3AFD-6C4F-531464178911" ).unwrap() );
    }
}