src/tools/tidy/src/unstable_book.rs

   1 use std::collections::BTreeSet;
   2 use std::fs;
   3 use std::path;
   4 use crate::features::{collect_lang_features, collect_lib_features, Features, Status};
   5
   6 pub const PATH_STR: &str = "doc/unstable-book/src";
   7
   8 pub const COMPILER_FLAGS_DIR: &str = "compiler-flags";
   9
  10 pub const LANG_FEATURES_DIR: &str = "language-features";
  11
  12 pub const LIB_FEATURES_DIR: &str = "library-features";
  13
  14 /// Builds the path to the Unstable Book source directory from the Rust 'src' directory.
  15 pub fn unstable_book_path(base_src_path: &path::Path) -> path::PathBuf {
  16     base_src_path.join(PATH_STR)
  17 }
  18
  19 /// Builds the path to the directory where the features are documented within the Unstable Book
  20 /// source directory.
  21 pub fn unstable_book_lang_features_path(base_src_path: &path::Path) -> path::PathBuf {
  22     unstable_book_path(base_src_path).join(LANG_FEATURES_DIR)
  23 }
  24
  25 /// Builds the path to the directory where the features are documented within the Unstable Book
  26 /// source directory.
  27 pub fn unstable_book_lib_features_path(base_src_path: &path::Path) -> path::PathBuf {
  28     unstable_book_path(base_src_path).join(LIB_FEATURES_DIR)
  29 }
  30
  31 /// Tests whether `DirEntry` is a file.
  32 fn dir_entry_is_file(dir_entry: &fs::DirEntry) -> bool {
  33     dir_entry
  34         .file_type()
  35         .expect("could not determine file type of directory entry")
  36         .is_file()
  37 }
  38
  39 /// Retrieves names of all unstable features.
  40 pub fn collect_unstable_feature_names(features: &Features) -> BTreeSet<String> {
  41     features
  42         .iter()
  43         .filter(|&(_, ref f)| f.level == Status::Unstable)
  44         .map(|(name, _)| name.replace('_', "-"))
  45         .collect()
  46 }
  47
  48 pub fn collect_unstable_book_section_file_names(dir: &path::Path) -> BTreeSet<String> {
  49     fs::read_dir(dir)
  50         .expect("could not read directory")
  51         .map(|entry| entry.expect("could not read directory entry"))
  52         .filter(dir_entry_is_file)
  53         .map(|entry| entry.path())
  54         .filter(|path| path.extension().map(|e| e.to_str().unwrap()) == Some("md"))
  55         .map(|path| path.file_stem().unwrap().to_str().unwrap().into())
  56         .collect()
  57 }
  58
  59 /// Retrieves file names of all library feature sections in the Unstable Book with:
  60 ///
  61 /// * hyphens replaced by underscores,
  62 /// * the markdown suffix ('.md') removed.
  63 fn collect_unstable_book_lang_features_section_file_names(base_src_path: &path::Path)
  64                                                           -> BTreeSet<String> {
  65     collect_unstable_book_section_file_names(&unstable_book_lang_features_path(base_src_path))
  66 }
  67
  68 /// Retrieves file names of all language feature sections in the Unstable Book with:
  69 ///
  70 /// * hyphens replaced by underscores,
  71 /// * the markdown suffix ('.md') removed.
  72 fn collect_unstable_book_lib_features_section_file_names(base_src_path: &path::Path)
  73                                                          -> BTreeSet<String> {
  74     collect_unstable_book_section_file_names(&unstable_book_lib_features_path(base_src_path))
  75 }
  76
  77 pub fn check(path: &path::Path, bad: &mut bool) {
  78     // Library features
  79
  80     let lang_features = collect_lang_features(path, bad);
  81     let lib_features = collect_lib_features(path).into_iter().filter(|&(ref name, _)| {
  82         !lang_features.contains_key(name)
  83     }).collect();
  84
  85     // Library features
  86     let unstable_lib_feature_names = collect_unstable_feature_names(&lib_features);
  87     let unstable_book_lib_features_section_file_names =
  88         collect_unstable_book_lib_features_section_file_names(path);
  89
  90     // Language features
  91     let unstable_lang_feature_names = collect_unstable_feature_names(&lang_features);
  92     let unstable_book_lang_features_section_file_names =
  93         collect_unstable_book_lang_features_section_file_names(path);
  94
  95     // Check for Unstable Book sections that don't have a corresponding unstable feature
  96     for feature_name in &unstable_book_lib_features_section_file_names -
  97                         &unstable_lib_feature_names {
  98         if !unstable_lang_feature_names.contains(&feature_name) {
  99             tidy_error!(bad,
 100                         "The Unstable Book has a 'library feature' section '{}' which doesn't \
 101                          correspond to an unstable library feature",
 102                         feature_name);
 103         }
 104     }
 105
 106     // Check for Unstable Book sections that don't have a corresponding unstable feature.
 107     for feature_name in &unstable_book_lang_features_section_file_names -
 108                         &unstable_lang_feature_names {
 109         tidy_error!(bad,
 110                     "The Unstable Book has a 'language feature' section '{}' which doesn't \
 111                      correspond to an unstable language feature",
 112                     feature_name)
 113     }
 114
 115     // List unstable features that don't have Unstable Book sections.
 116     // Remove the comment marker if you want the list printed.
 117     /*
 118     println!("Lib features without unstable book sections:");
 119     for feature_name in &unstable_lang_feature_names -
 120                         &unstable_book_lang_features_section_file_names {
 121         println!("    * {} {:?}", feature_name, lib_features[&feature_name].tracking_issue);
 122     }
 123
 124     println!("Lang features without unstable book sections:");
 125     for feature_name in &unstable_lib_feature_names-
 126                         &unstable_book_lib_features_section_file_names {
 127         println!("    * {} {:?}", feature_name, lang_features[&feature_name].tracking_issue);
 128     }
 129     // */
 130 }