tagref 0.0.3

Tagref helps you refer to other locations in your codebase.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

extern crate clap;
extern crate colored;
extern crate ignore;
extern crate regex;

mod citations;
mod count;
mod duplicates;
mod label;
mod walk;

use colored::Colorize;
use std::collections::HashMap;
use std::process;

// Welcome to Tagref! The fun starts here.
fn main() {
  // Set up the command-line interface.
  let matches = clap::App::new("Tagref")
    .version("0.0.3")
    .author("Stephan Boyer <stephan@stephanboyer.com>")
    .about(
      " \
      Tagref helps you refer to other locations in your codebase. It checks \
      the following:\n\n1. References actually point to tags. \n2. Tags are \
      distinct.\n\nThe syntax for tags is [tag:?label?] and the syntax for \
      references is [ref:?label?]. For more information, visit \
      https://github.com/stepchowfun/tagref. \
      ".replace("?", "").trim() // The '?'s are to avoid tag conflicts.
      )
    .arg(
      clap::Arg::with_name("path")
        .short("p")
        .long("path")
        .value_name("PATH")
        .help("Sets the path of the directory to scan")
        .takes_value(true)
      )
    .arg(
      clap::Arg::with_name("list-tags")
        .short("n")
        .long("list-tags")
        .help("Lists all the tags")
      )
    .arg(
      clap::Arg::with_name("list-references")
        .short("r")
        .long("list-references")
        .help("Lists all the references")
      )
    .get_matches();

  // Fetch the command-line arguments.
  let dir = matches.value_of("path").unwrap_or(".");
  let list_tags = matches.is_present("list-tags");
  let list_references = matches.is_present("list-references");
  let check_references = !list_tags && !list_references;

  // Parse all the tags into a HashMap. The values are vectors to allow for
  // duplicates. We will report duplicates later.
  let mut tags_map = HashMap::new();
  let _ = walk::walk(dir, |path, contents| {
    for tag in label::parse(label::LabelType::Tag, path, contents) {
      tags_map.entry(
        tag.label.clone()
      ).or_insert(
        Vec::new()
      ).push(
        tag.clone()
      );
    }
  });

  // Convert tags_map into a set and check for duplicates.
  match duplicates::check(&tags_map) {
    Ok(tags) => {
      // Handle the --list-tags flag if necessary.
      if list_tags {
        for (_, tag) in &tags {
          println!("{}", tag);
        }
      }

      // Parse all the references.
      let mut references = Vec::new();
      let files_scanned = walk::walk(dir, |path, contents| {
        // We know that the regex is well-formed, so we are justified in
        // unwrapping.
        references.extend(label::parse(label::LabelType::Ref, path, contents));
      });

      // Handle the --list-references flag if necessary.
      if list_references {
        for reference in &references {
          println!("{}", reference);
        }
      }

      // Check the references if necessary.
      if check_references {
        match citations::check(&tags, &references) {
          Some(error) => {
            eprintln!("{}", error.red());
            process::exit(1);
          },
          None => {
            println!(
              "{}",
              format!(
                "{} and {} validated in {}.",
                count::count(tags.len().into(), "tag"),
                count::count(references.len().into(), "reference"),
                count::count(files_scanned, "file")
              ).green()
            );
          },
        };
      }
    },
    Err(error) => {
      eprintln!("{}", error.red());
      process::exit(1);
    },
  };
}