Run cargo fmt

Author: SebastienGllmt

src/cli.rs

@@ -1,4 +1,4 @@
-use clap::{Parser};
+use clap::Parser;
 use once_cell::sync::Lazy;
 // TODO: make non-annotation generate different DeserializeError that is simpler
 //       and works with From<cbor_event:Error> only
@@ -51,4 +51,4 @@ pub struct Cli {
     pub package_json: bool,
 }
 
-pub static CLI_ARGS: Lazy<Cli> = Lazy::new(|| Cli::parse());
+pub static CLI_ARGS: Lazy<Cli> = Lazy::new(|| Cli::parse());

src/comment_ast.rs

@@ -1,7 +1,9 @@
 extern crate nom;
 use nom::{
+    branch::alt,
+    bytes::complete::{tag, take_while, take_while1},
+    multi::many0,
     IResult,
-    bytes::complete::{tag, take_while1, take_while}, branch::alt, multi::many0,
 };
 
 #[derive(Default, Debug, PartialEq)]
@@ -14,9 +16,11 @@ pub struct RuleMetadata {
 pub fn merge_metadata(r1: &RuleMetadata, r2: &RuleMetadata) -> RuleMetadata {
     let merged = RuleMetadata {
         name: match (r1.name.as_ref(), r2.name.as_ref()) {
-            (Some(val1), Some(val2)) => panic!("Key \"name\" specified twice: {:?} {:?}", val1, val2),
-            (val@Some(_), _) => val.cloned(),
-            (_, val) => val.cloned()
+            (Some(val1), Some(val2)) => {
+                panic!("Key \"name\" specified twice: {:?} {:?}", val1, val2)
+            }
+            (val @ Some(_), _) => val.cloned(),
+            (_, val) => val.cloned(),
         },
         is_newtype: r1.is_newtype || r2.is_newtype,
         no_alias: r1.no_alias || r2.no_alias,
@@ -36,14 +40,20 @@ impl RuleMetadata {
         let mut base = RuleMetadata::default();
         for result in results {
             match result {
-                ParseResult::Name(name) => {
-                    match base.name.as_ref() {
-                        Some(old_name) => panic!("Key \"name\" specified twice: {:?} {:?}", old_name, name),
-                        None => { base.name = Some(name.to_string()); }
+                ParseResult::Name(name) => match base.name.as_ref() {
+                    Some(old_name) => {
+                        panic!("Key \"name\" specified twice: {:?} {:?}", old_name, name)
+                    }
+                    None => {
+                        base.name = Some(name.to_string());
                     }
                 },
-                ParseResult::NewType => { base.is_newtype = true; },
-                ParseResult::DontGenAlias => { base.no_alias = true; },
+                ParseResult::NewType => {
+                    base.is_newtype = true;
+                }
+                ParseResult::DontGenAlias => {
+                    base.no_alias = true;
+                }
             }
         }
         base.verify();
@@ -87,17 +97,15 @@ fn whitespace_then_tag(input: &str) -> IResult<&str, ParseResult> {
 
 fn rule_metadata(input: &str) -> IResult<&str, RuleMetadata> {
     let (input, parse_results) = many0(whitespace_then_tag)(input)?;
-    
 
     Ok((input, RuleMetadata::from_parse_results(&parse_results)))
 }
 
-
-impl <'a> From<Option<&'a cddl::ast::Comments<'a>>> for RuleMetadata {
+impl<'a> From<Option<&'a cddl::ast::Comments<'a>>> for RuleMetadata {
     fn from(comments: Option<&'a cddl::ast::Comments<'a>>) -> RuleMetadata {
         match comments {
             None => RuleMetadata::default(),
-            Some(c) => metadata_from_comments(&c.0)
+            Some(c) => metadata_from_comments(&c.0),
         }
     }
 }
@@ -108,53 +116,83 @@ pub fn metadata_from_comments(comments: &[&str]) -> RuleMetadata {
         if let Ok(comment_metadata) = rule_metadata(comment) {
             result = merge_metadata(&result, &comment_metadata.1);
         }
-    };
+    }
     result
 }
 
 #[test]
 fn parse_comment_name() {
-    assert_eq!(rule_metadata("@name foo"), Ok(("", RuleMetadata {
-        name: Some("foo".to_string()),
-        is_newtype: false,
-        no_alias: false,
-    })));
+    assert_eq!(
+        rule_metadata("@name foo"),
+        Ok((
+            "",
+            RuleMetadata {
+                name: Some("foo".to_string()),
+                is_newtype: false,
+                no_alias: false,
+            }
+        ))
+    );
 }
 
 #[test]
 fn parse_comment_newtype() {
-    assert_eq!(rule_metadata("@newtype"), Ok(("", RuleMetadata {
-        name: None,
-        is_newtype: true,
-        no_alias: false,
-    })));
+    assert_eq!(
+        rule_metadata("@newtype"),
+        Ok((
+            "",
+            RuleMetadata {
+                name: None,
+                is_newtype: true,
+                no_alias: false,
+            }
+        ))
+    );
 }
 
 #[test]
 fn parse_comment_newtype_and_name() {
-    assert_eq!(rule_metadata("@newtype @name foo"), Ok(("", RuleMetadata {
-        name: Some("foo".to_string()),
-        is_newtype: true,
-        no_alias: false,
-    })));
+    assert_eq!(
+        rule_metadata("@newtype @name foo"),
+        Ok((
+            "",
+            RuleMetadata {
+                name: Some("foo".to_string()),
+                is_newtype: true,
+                no_alias: false,
+            }
+        ))
+    );
 }
 
 #[test]
 fn parse_comment_newtype_and_name_inverse() {
-    assert_eq!(rule_metadata("@name foo @newtype"), Ok(("", RuleMetadata {
-        name: Some("foo".to_string()),
-        is_newtype: true,
-        no_alias: false,
-    })));
+    assert_eq!(
+        rule_metadata("@name foo @newtype"),
+        Ok((
+            "",
+            RuleMetadata {
+                name: Some("foo".to_string()),
+                is_newtype: true,
+                no_alias: false,
+            }
+        ))
+    );
 }
 
 #[test]
 fn parse_comment_name_noalias() {
-    assert_eq!(rule_metadata("@no_alias @name foo"), Ok(("", RuleMetadata {
-        name: Some("foo".to_string()),
-        is_newtype: false,
-        no_alias: true,
-    })));
+    assert_eq!(
+        rule_metadata("@no_alias @name foo"),
+        Ok((
+            "",
+            RuleMetadata {
+                name: Some("foo".to_string()),
+                is_newtype: false,
+                no_alias: true,
+            }
+        ))
+    );
 }
 
 #[test]

src/dep_graph.rs

@@ -8,11 +8,20 @@ pub fn topological_rule_order<'a>(rules: &'a Vec<&'a Rule<'a>>) -> Vec<&'a Rule<
         let (ident, refs) = find_references(cddl_rule);
         adj_list.insert(ident.ident, (*cddl_rule, refs));
     }
-    let mut unvisited = adj_list.iter().map(|(k, _v)| *k).collect::<BTreeSet<&str>>();
+    let mut unvisited = adj_list
+        .iter()
+        .map(|(k, _v)| *k)
+        .collect::<BTreeSet<&str>>();
     let mut topo_order = Vec::new();
     let mut processing: BTreeSet<&'a str> = BTreeSet::new();
     while let Some(u) = unvisited.iter().next().map(|u| *u) {
-        dfs_visit(&mut topo_order, &mut unvisited, &mut processing, &adj_list, u);
+        dfs_visit(
+            &mut topo_order,
+            &mut unvisited,
+            &mut processing,
+            &adj_list,
+            u,
+        );
     }
     topo_order
 }
@@ -22,7 +31,8 @@ fn dfs_visit<'a>(
     unvisited: &mut BTreeSet<&'a str>,
     processing: &mut BTreeSet<&'a str>,
     adj_list: &BTreeMap<&'a str, (&'a cddl::ast::Rule<'a>, Vec<&'a Identifier<'a>>)>,
-    u: &'a str) {
+    u: &'a str,
+) {
     processing.insert(u);
     let (rule, neighbors) = adj_list.get(u).unwrap();
     for v in neighbors.iter() {
@@ -42,41 +52,68 @@ fn dfs_visit<'a>(
 fn find_references<'a>(cddl_rule: &'a Rule<'a>) -> (&'a Identifier, Vec<&'a Identifier<'a>>) {
     let mut refs = Vec::new();
     let ident = match cddl_rule {
-        Rule::Type{ rule, .. } => {
-            rule.value.type_choices.iter().for_each(|tc| find_refs_type1(&mut refs, &tc.type1));
+        Rule::Type { rule, .. } => {
+            rule.value
+                .type_choices
+                .iter()
+                .for_each(|tc| find_refs_type1(&mut refs, &tc.type1));
             &rule.name
-        },
-        Rule::Group{ rule, .. } => {
-            assert_eq!(rule.generic_params, None, "{}: Generics not supported on plain groups", rule.name);
+        }
+        Rule::Group { rule, .. } => {
+            assert_eq!(
+                rule.generic_params, None,
+                "{}: Generics not supported on plain groups",
+                rule.name
+            );
             match &rule.entry {
-                cddl::ast::GroupEntry::InlineGroup{ group, .. } => find_refs_group(&mut refs, group),
+                cddl::ast::GroupEntry::InlineGroup { group, .. } => {
+                    find_refs_group(&mut refs, group)
+                }
                 x => panic!("Group rule with non-inline group? {:?}", x),
             }
             &rule.name
-        },
+        }
     };
     (ident, refs)
 }
 
 fn find_refs_type1<'a>(refs: &mut Vec<&'a Identifier<'a>>, type1: &'a Type1<'a>) {
     match &type1.type2 {
-        Type2::Typename{ ident, generic_args, .. } => {
+        Type2::Typename {
+            ident,
+            generic_args,
+            ..
+        } => {
             refs.push(ident);
             find_refs_generic_args(refs, generic_args);
-        },
-        Type2::ParenthesizedType{ pt, .. } => pt.type_choices.iter().for_each(|tc| find_refs_type1(refs, &tc.type1)),
-        Type2::Map{ group, .. } => find_refs_group(refs, group),
-        Type2::Array{ group, .. } => find_refs_group(refs, group),
-        Type2::Unwrap{ ident, generic_args, .. } => {
+        }
+        Type2::ParenthesizedType { pt, .. } => pt
+            .type_choices
+            .iter()
+            .for_each(|tc| find_refs_type1(refs, &tc.type1)),
+        Type2::Map { group, .. } => find_refs_group(refs, group),
+        Type2::Array { group, .. } => find_refs_group(refs, group),
+        Type2::Unwrap {
+            ident,
+            generic_args,
+            ..
+        } => {
             refs.push(ident);
             find_refs_generic_args(refs, generic_args);
-        },
-        Type2::ChoiceFromInlineGroup{ group, .. } => find_refs_group(refs, group),
-        Type2::ChoiceFromGroup{ ident, generic_args, .. } => {
+        }
+        Type2::ChoiceFromInlineGroup { group, .. } => find_refs_group(refs, group),
+        Type2::ChoiceFromGroup {
+            ident,
+            generic_args,
+            ..
+        } => {
             refs.push(ident);
             find_refs_generic_args(refs, generic_args);
-        },
-        Type2::TaggedData{ t, .. } => t.type_choices.iter().for_each(|tc| find_refs_type1(refs, &tc.type1)),
+        }
+        Type2::TaggedData { t, .. } => t
+            .type_choices
+            .iter()
+            .for_each(|tc| find_refs_type1(refs, &tc.type1)),
         _ => (),
     }
 }
@@ -85,26 +122,36 @@ fn find_refs_group<'a>(refs: &mut Vec<&'a Identifier<'a>>, group: &'a Group<'a>)
     for group_choice in group.group_choices.iter() {
         for (group_entry, _) in group_choice.group_entries.iter() {
             match group_entry {
-                GroupEntry::InlineGroup{ group, .. } => find_refs_group(refs, group),
-                GroupEntry::TypeGroupname{ ge, .. } => {
+                GroupEntry::InlineGroup { group, .. } => find_refs_group(refs, group),
+                GroupEntry::TypeGroupname { ge, .. } => {
                     refs.push(&ge.name);
                     find_refs_generic_args(refs, &ge.generic_args);
-                },
-                GroupEntry::ValueMemberKey{ ge, .. } => {
-                    ge.entry_type.type_choices.iter().for_each(|tc| find_refs_type1(refs, &tc.type1));
+                }
+                GroupEntry::ValueMemberKey { ge, .. } => {
+                    ge.entry_type
+                        .type_choices
+                        .iter()
+                        .for_each(|tc| find_refs_type1(refs, &tc.type1));
                     match &ge.member_key {
-                        Some(MemberKey::Type1{ t1, .. }) => find_refs_type1(refs, t1),
-                        Some(MemberKey::NonMemberKey{ .. }) => unimplemented!("Please open a github issue with repro steps"),
+                        Some(MemberKey::Type1 { t1, .. }) => find_refs_type1(refs, t1),
+                        Some(MemberKey::NonMemberKey { .. }) => {
+                            unimplemented!("Please open a github issue with repro steps")
+                        }
                         _ => (),
                     }
-                },
+                }
             }
         }
     }
 }
 
-fn find_refs_generic_args<'a>(refs: &mut Vec<&'a Identifier<'a>>, generic_arg: &'a Option<GenericArgs<'a>>) {
+fn find_refs_generic_args<'a>(
+    refs: &mut Vec<&'a Identifier<'a>>,
+    generic_arg: &'a Option<GenericArgs<'a>>,
+) {
     if let Some(arg) = generic_arg {
-        arg.args.iter().for_each(|arg| find_refs_type1(refs, arg.arg.as_ref()));
+        arg.args
+            .iter()
+            .for_each(|arg| find_refs_type1(refs, arg.arg.as_ref()));
     }
-}
+}