Support selecting rules

Author: benwebber

src/cli.rs

@@ -23,7 +23,8 @@ pub fn main() -> IoResult<()> {
                         .long("output-format")
                         .value_parser(["full", "json", "jsonl", "short"])
                         .default_value("short"),
-                ),
+                )
+                .arg(Arg::new("select").long("select").value_delimiter(',')),
         )
         .subcommand(
             Command::new("rule")

src/cli/commands.rs

@@ -24,7 +24,13 @@ pub fn check(matches: &ArgMatches) -> Result<()> {
         "full" => OutputFormat::Full,
         _ => unreachable!(),
     };
-    let profile = Profile::default();
+    let profile = match matches.get_many::<&str>("select") {
+        Some(values) => {
+            let codes: Vec<String> = values.into_iter().map(|s| s.to_uppercase()).collect();
+            Profile::try_from(codes).expect("invalid code")
+        }
+        None => Profile::default(),
+    };
     let (_, diagnostics) = parse_and_lint_file(&path, &profile).unwrap();
     if diagnostics.is_empty() {
         Ok(())

src/profile.rs

@@ -1,20 +1,24 @@
-use std::collections::HashSet;
+use std::collections::HashMap;
 
 use crate::rule::Rule;
 
 pub struct Profile {
-    rules: HashSet<Rule>,
+    pub rules: HashMap<String, Rule>,
 }
 
 impl Profile {
     pub fn new(rules: &[Rule]) -> Self {
+        let mut rules_by_code = HashMap::new();
+        for rule in rules {
+            rules_by_code.insert(rule.code().to_string(), *rule);
+        }
         Self {
-            rules: rules.iter().copied().collect(),
+            rules: rules_by_code,
         }
     }
 
     pub fn is_enabled(&self, rule: Rule) -> bool {
-        self.rules.contains(&rule)
+        self.rules.contains_key(rule.code())
     }
 }
 
@@ -23,3 +27,20 @@ impl Default for Profile {
         Self::new(&Rule::ALL)
     }
 }
+
+impl TryFrom<Vec<String>> for Profile {
+    type Error = String;
+
+    fn try_from(codes: Vec<String>) -> Result<Self, Self::Error> {
+        let default = Profile::default();
+        let mut rules = Vec::new();
+        for code in codes.iter() {
+            if let Some(rule) = default.rules.get(code) {
+                rules.push(*rule)
+            } else {
+                return Err(format!("Invalid rule code '{}'", &code));
+            }
+        }
+        Ok(Self::new(rules.as_slice()))
+    }
+}