clippy_lints/src/utils/conf.rs

   1 //! Read configurations files.
   2
   3 #![deny(clippy::missing_docs_in_private_items)]
   4
   5 use lazy_static::lazy_static;
   6 use std::default::Default;
   7 use std::io::Read;
   8 use std::sync::Mutex;
   9 use std::{env, fmt, fs, io, path};
  10 use syntax::{ast, source_map};
  11 use toml;
  12
  13 /// Get the configuration file from arguments.
  14 pub fn file_from_args(
  15     args: &[source_map::Spanned<ast::NestedMetaItemKind>],
  16 ) -> Result<Option<path::PathBuf>, (&'static str, source_map::Span)> {
  17     for arg in args.iter().filter_map(syntax::source_map::Spanned::meta_item) {
  18         if arg.name() == "conf_file" {
  19             return match arg.node {
  20                 ast::MetaItemKind::Word | ast::MetaItemKind::List(_) => {
  21                     Err(("`conf_file` must be a named value", arg.span))
  22                 },
  23                 ast::MetaItemKind::NameValue(ref value) => {
  24                     if let ast::LitKind::Str(ref file, _) = value.node {
  25                         Ok(Some(file.to_string().into()))
  26                     } else {
  27                         Err(("`conf_file` value must be a string", value.span))
  28                     }
  29                 },
  30             };
  31         }
  32     }
  33
  34     Ok(None)
  35 }
  36
  37 /// Error from reading a configuration file.
  38 #[derive(Debug)]
  39 pub enum Error {
  40     /// An I/O error.
  41     Io(io::Error),
  42     /// Not valid toml or doesn't fit the expected conf format
  43     Toml(String),
  44 }
  45
  46 impl fmt::Display for Error {
  47     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  48         match *self {
  49             Error::Io(ref err) => err.fmt(f),
  50             Error::Toml(ref err) => err.fmt(f),
  51         }
  52     }
  53 }
  54
  55 impl From<io::Error> for Error {
  56     fn from(e: io::Error) -> Self {
  57         Error::Io(e)
  58     }
  59 }
  60
  61 lazy_static! {
  62     static ref ERRORS: Mutex<Vec<Error>> = Mutex::new(Vec::new());
  63 }
  64
  65 macro_rules! define_Conf {
  66     ($(#[$doc: meta] ($rust_name: ident, $rust_name_str: expr, $default: expr => $($ty: tt)+),)+) => {
  67         pub use self::helpers::Conf;
  68         mod helpers {
  69             use serde_derive::Deserialize;
  70             /// Type used to store lint configuration.
  71             #[derive(Deserialize)]
  72             #[serde(rename_all="kebab-case", deny_unknown_fields)]
  73             pub struct Conf {
  74                 $(#[$doc] #[serde(default=$rust_name_str)] #[serde(with=$rust_name_str)]
  75                           pub $rust_name: define_Conf!(TY $($ty)+),)+
  76                 #[allow(dead_code)]
  77                 #[serde(default)]
  78                 third_party: Option<::toml::Value>,
  79             }
  80             $(
  81                 mod $rust_name {
  82                     use serde;
  83                     use serde::Deserialize;
  84                     crate fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D)
  85                     -> Result<define_Conf!(TY $($ty)+), D::Error> {
  86                         type T = define_Conf!(TY $($ty)+);
  87                         Ok(T::deserialize(deserializer).unwrap_or_else(|e| {
  88                             crate::utils::conf::ERRORS.lock().expect("no threading here")
  89                                                         .push(crate::utils::conf::Error::Toml(e.to_string()));
  90                             super::$rust_name()
  91                         }))
  92                     }
  93                 }
  94
  95                 fn $rust_name() -> define_Conf!(TY $($ty)+) {
  96                     define_Conf!(DEFAULT $($ty)+, $default)
  97                 }
  98             )+
  99         }
 100     };
 101
 102     // hack to convert tts
 103     (TY $ty: ty) => { $ty };
 104
 105     // provide a nicer syntax to declare the default value of `Vec<String>` variables
 106     (DEFAULT Vec<String>, $e: expr) => { $e.iter().map(|&e| e.to_owned()).collect() };
 107     (DEFAULT $ty: ty, $e: expr) => { $e };
 108 }
 109
 110 define_Conf! {
 111     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about
 112     (blacklisted_names, "blacklisted_names", ["foo", "bar", "baz", "quux"] => Vec<String>),
 113     /// Lint: CYCLOMATIC_COMPLEXITY. The maximum cyclomatic complexity a function can have
 114     (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold", 25 => u64),
 115     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
 116     (doc_valid_idents, "doc_valid_idents", [
 117         "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
 118         "DirectX",
 119         "ECMAScript",
 120         "GPLv2", "GPLv3",
 121         "GitHub", "GitLab",
 122         "IPv4", "IPv6",
 123         "JavaScript",
 124         "NaN", "NaNs",
 125         "OAuth",
 126         "OpenGL", "OpenSSH", "OpenSSL", "OpenStreetMap",
 127         "TrueType",
 128         "iOS", "macOS",
 129         "TeX", "LaTeX", "BibTeX", "BibLaTeX",
 130         "MinGW",
 131         "CamelCase",
 132     ] => Vec<String>),
 133     /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
 134     (too_many_arguments_threshold, "too_many_arguments_threshold", 7 => u64),
 135     /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
 136     (type_complexity_threshold, "type_complexity_threshold", 250 => u64),
 137     /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
 138     (single_char_binding_names_threshold, "single_char_binding_names_threshold", 5 => u64),
 139     /// Lint: BOXED_LOCAL. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
 140     (too_large_for_stack, "too_large_for_stack", 200 => u64),
 141     /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
 142     (enum_variant_name_threshold, "enum_variant_name_threshold", 3 => u64),
 143     /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
 144     (enum_variant_size_threshold, "enum_variant_size_threshold", 200 => u64),
 145     /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
 146     (verbose_bit_mask_threshold, "verbose_bit_mask_threshold", 1 => u64),
 147     /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
 148     (literal_representation_threshold, "literal_representation_threshold", 16384 => u64),
 149     /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
 150     (trivial_copy_size_limit, "trivial_copy_size_limit", None => Option<u64>),
 151     /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
 152     (too_many_lines_threshold, "too_many_lines_threshold", 100 => u64),
 153 }
 154
 155 impl Default for Conf {
 156     fn default() -> Self {
 157         toml::from_str("").expect("we never error on empty config files")
 158     }
 159 }
 160
 161 /// Search for the configuration file.
 162 pub fn lookup_conf_file() -> io::Result<Option<path::PathBuf>> {
 163     /// Possible filename to search for.
 164     const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
 165
 166     // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
 167     // If neither of those exist, use ".".
 168     let mut current = path::PathBuf::from(
 169         env::var("CLIPPY_CONF_DIR")
 170             .or_else(|_| env::var("CARGO_MANIFEST_DIR"))
 171             .unwrap_or_else(|_| ".".to_string()),
 172     );
 173     loop {
 174         for config_file_name in &CONFIG_FILE_NAMES {
 175             let config_file = current.join(config_file_name);
 176             match fs::metadata(&config_file) {
 177                 // Only return if it's a file to handle the unlikely situation of a directory named
 178                 // `clippy.toml`.
 179                 Ok(ref md) if md.is_file() => return Ok(Some(config_file)),
 180                 // Return the error if it's something other than `NotFound`; otherwise we didn't
 181                 // find the project file yet, and continue searching.
 182                 Err(e) => {
 183                     if e.kind() != io::ErrorKind::NotFound {
 184                         return Err(e);
 185                     }
 186                 },
 187                 _ => (),
 188             }
 189         }
 190
 191         // If the current directory has no parent, we're done searching.
 192         if !current.pop() {
 193             return Ok(None);
 194         }
 195     }
 196 }
 197
 198 /// Produces a `Conf` filled with the default values and forwards the errors
 199 ///
 200 /// Used internally for convenience
 201 fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
 202     (Conf::default(), errors)
 203 }
 204
 205 /// Read the `toml` configuration file.
 206 ///
 207 /// In case of error, the function tries to continue as much as possible.
 208 pub fn read(path: Option<&path::Path>) -> (Conf, Vec<Error>) {
 209     let path = if let Some(path) = path {
 210         path
 211     } else {
 212         return default(Vec::new());
 213     };
 214
 215     let file = match fs::File::open(path) {
 216         Ok(mut file) => {
 217             let mut buf = String::new();
 218
 219             if let Err(err) = file.read_to_string(&mut buf) {
 220                 return default(vec![err.into()]);
 221             }
 222
 223             buf
 224         },
 225         Err(err) => return default(vec![err.into()]),
 226     };
 227
 228     assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
 229     match toml::from_str(&file) {
 230         Ok(toml) => (
 231             toml,
 232             ERRORS.lock().expect("no threading -> mutex always safe").split_off(0),
 233         ),
 234         Err(e) => {
 235             let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
 236             errors.push(Error::Toml(e.to_string()));
 237             default(errors)
 238         },
 239     }
 240 }