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

//! A small utility library for binary applications.
//!
//! # Examples
//!
//! ```rust
//! extern crate pkg;
//!
//! fn main() {
//!     println!("{} {}\n{}", pkg::name(), pkg::version(), pkg::description());
//! }
//! ```
//!
//! # Cargo features
//!
//! This crate provides one cargo feature:
//!
//! - `nightly`: This uses language features only available on the nightly
//! release channel for more optimal implementations.

#![deny(missing_docs, warnings)]

#[macro_use]
extern crate lazy_static;

#[macro_use]
mod macros;

lazy_static! {
    static ref AUTHORS: Vec<&'static str> = pkg_authors!().split(';').collect();
    static ref BIN_NAME: Option<String> = {
        use std::env;
        use std::path::PathBuf;

        let arg0 = env::args_os().next()?;
        let path = PathBuf::from(arg0);
        let file_name = path.file_stem()?;
        Some(file_name.to_str()?.to_owned())
    };
}

/// Returns the crate name.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!("The crate name is {}", pkg::name());
/// }
/// ```
pub fn name() -> &'static str {
    pkg_name!()
}

/// Returns the crate author.
///
/// # Assumption
///
/// The crate only has the one author, otherwise this will return the list of
/// authors separated by semicolons.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!("The crate author is {}", pkg::author());
/// }
/// ```
pub fn author() -> &'static str {
    pkg_authors!()
}

/// Returns a slice reference of the crate authors.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!("The crate authors are: {}", pkg::authors().join(", "));
/// }
/// ```
pub fn authors() -> &'static [&'static str] {
    &*AUTHORS
}

/// Returns the crate version.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!("The crate version is {}", pkg::version());
/// }
/// ```
pub fn version() -> &'static str {
    pkg_version!()
}

/// Returns the crate description.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!("The crate description is {}", pkg::description());
/// }
/// ```
pub fn description() -> &'static str {
    pkg_description!()
}

/// Returns the crate homepage.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!("The crate homepage is {}", pkg::homepage());
/// }
/// ```
pub fn homepage() -> &'static str {
    pkg_homepage!()
}

/// Returns the name of the binary file.
///
/// # Examples
///
/// ```rust
/// extern crate pkg;
///
/// fn main() {
///     println!(
///         "The binary file name is {}",
///         pkg::bin_name().unwrap_or("unknown")
///     );
/// }
/// ```
pub fn bin_name() -> Option<&'static str> {
    match *BIN_NAME {
        Some(ref name) => Some(name),
        _ => None,
    }
}