bind-builder 0.1.0-alpha.1

Build dependency to help make crates that rely on native dependencies more portable.
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

//! Build dependency for downloading, building and linking native libraries.
//!
//! This crate expands on `cc` and `cmake` to provide a more streamlined way of distributing crates
//! that depend on both static and shared libraries.
//!

use std::fs;
use std::ops::Add;
use std::path::Path;
use crate::commands::{add_library_search_path, link_shared_library, link_static_library};
use crate::types::local_library::LocalLibrary;
use crate::variables::{platform, Platform, shared_library_extension, static_library_extension, target_directory};

pub mod types;

pub (crate) mod variables;
pub (crate) mod commands;

const LIBRARY_NAME_PREFIX: &str = "lib";

fn get_static_library_name(library_name: &str) -> String {
    // Omit the prefix for Windows since there is no convention for library names.
    if platform() == Platform::Windows {
        return library_name.to_string()
            .add(static_library_extension());
    }

    LIBRARY_NAME_PREFIX.to_string()
        .add(library_name)
        .add(static_library_extension())
}

fn get_shared_library_name(library_name: &str) -> String  {
    // Omit the prefix for Windows since there is no convention for library names.
    if platform() == Platform::Windows {
        return library_name.to_string()
            .add(shared_library_extension());
    }

    LIBRARY_NAME_PREFIX.to_string()
        .add(library_name)
        .add(shared_library_extension())
}

fn copy_shared_object(
    target_directory: &Path,
    library_path: &Path,
) {
    if !target_directory.exists() {
        fs::create_dir_all(target_directory)
            .expect("Could not create target directory.");
    }

    if !library_path.exists() {
        panic!("Could not find shared object: {:?}", library_path);
    }

    fs::copy(
        library_path,
        target_directory.join(library_path.file_name().unwrap())
    ).expect("Could not copy shared object.");
}

/// Trait for integrating a `LocalLibrary` into `cc::Build`.
pub trait BindBuild {

    /// Binds a `LocalLibrary` to the `cc::Build` instance.
    fn bind_library(
        &mut self,
        library: LocalLibrary
    ) -> &mut cc::Build;
}

impl BindBuild for cc::Build {

    fn bind_library(
        &mut self,
        library: LocalLibrary
    ) -> &mut cc::Build {

        // Remove duplicates and invalid entries
        let mut include_directories = library
            .get_include_directories()
            .clone();

        include_directories.dedup();
        include_directories.retain(|x| x.is_dir());

        self.includes(include_directories);

        let mut library_directories = library
            .get_library_directories()
            .clone();

        library_directories.dedup();
        library_directories.retain(|x| x.is_dir());

        for library_directory in library_directories.iter() {
            add_library_search_path(library_directory.as_path())
        }

        let mut link_targets = library
            .get_link_targets()
            .clone();

        link_targets.dedup();

        let target_directory = target_directory();

        // Always prefer static libraries over shared libraries
        for library in link_targets.iter() {
            for library_directory in library_directories.iter() {
                let static_library_path = library_directory
                    .join(get_static_library_name(library));

                let shared_library_path = library_directory
                    .join(get_shared_library_name(library));

                if static_library_path.exists() {
                    link_static_library(library);
                } else if shared_library_path.exists() {
                    // Copy shared object to target directory
                    copy_shared_object(
                        target_directory.as_path(),
                        shared_library_path.as_path()
                    );
                    link_shared_library(library);
                }
            }
        }

        // Link against any system libraries.
        let mut system_link_targets = library
            .get_system_link_targets()
            .clone();

        system_link_targets.dedup();

        for library in system_link_targets.iter() {
            link_shared_library(library);
        }

        self
    }
}