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(|a| a.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     let mut current = path::PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set"));
 167
 168     loop {
 169         for config_file_name in &CONFIG_FILE_NAMES {
 170             let config_file = current.join(config_file_name);
 171             match fs::metadata(&config_file) {
 172                 // Only return if it's a file to handle the unlikely situation of a directory named
 173                 // `clippy.toml`.
 174                 Ok(ref md) if md.is_file() => return Ok(Some(config_file)),
 175                 // Return the error if it's something other than `NotFound`; otherwise we didn't
 176                 // find the project file yet, and continue searching.
 177                 Err(e) => {
 178                     if e.kind() != io::ErrorKind::NotFound {
 179                         return Err(e);
 180                     }
 181                 },
 182                 _ => (),
 183             }
 184         }
 185
 186         // If the current directory has no parent, we're done searching.
 187         if !current.pop() {
 188             return Ok(None);
 189         }
 190     }
 191 }
 192
 193 /// Produces a `Conf` filled with the default values and forwards the errors
 194 ///
 195 /// Used internally for convenience
 196 fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
 197     (Conf::default(), errors)
 198 }
 199
 200 /// Read the `toml` configuration file.
 201 ///
 202 /// In case of error, the function tries to continue as much as possible.
 203 pub fn read(path: Option<&path::Path>) -> (Conf, Vec<Error>) {
 204     let path = if let Some(path) = path {
 205         path
 206     } else {
 207         return default(Vec::new());
 208     };
 209
 210     let file = match fs::File::open(path) {
 211         Ok(mut file) => {
 212             let mut buf = String::new();
 213
 214             if let Err(err) = file.read_to_string(&mut buf) {
 215                 return default(vec![err.into()]);
 216             }
 217
 218             buf
 219         },
 220         Err(err) => return default(vec![err.into()]),
 221     };
 222
 223     assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
 224     match toml::from_str(&file) {
 225         Ok(toml) => (
 226             toml,
 227             ERRORS.lock().expect("no threading -> mutex always safe").split_off(0),
 228         ),
 229         Err(e) => {
 230             let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
 231             errors.push(Error::Toml(e.to_string()));
 232             default(errors)
 233         },
 234     }
 235 }