add initial json5 support

Author: mcandre

Cargo.toml

@@ -15,6 +15,7 @@ json-schema-validator-core = "1.0.0"
 lazy_static = "1.5.0"
 regex = "1.12.2"
 serde_json = "1.0.145"
+serde_json5 = "0.2.1"
 tinyrick = { version = "0.0.17", optional = true }
 tinyrick_extras = { version = "0.0.11", optional = true }
 walkdir = "2.5.0"

README.md

@@ -4,8 +4,9 @@
 
 kirill scans projects large and small for JSON correctness:
 
-* Basic JSON syntactical validity
-* Optionally, enforce [JSON Schema](https://json-schema.org/)
+* Check for basic JSON(5) syntactical validity
+* Identify JSON(5) files recursively in large project directories
+* Verify compliance with a [JSON Schema](https://json-schema.org/)
 
 # EXAMPLES
 
@@ -21,6 +22,12 @@ error: settings.json: expected value at line 1 column 1
 
 $ kirill --schema species.json zoo
 error: zoo/bad-bear.json: Missing required property 'species'
+
+$ kirill books.json5
+error: books.json5: expected value at line 9 column 9
+
+$ kirill --json5 books.json5
+$
 ```
 
 See `kirill -h` for more options.

examples/books.json5

@@ -0,0 +1,16 @@
+{
+    "books": [
+        "The Hobbit",
+        "The Fellowship of the Ring",
+        "The Two Towers",
+        "The Return of the King",
+        "The Silmarillion",
+        "Unfinished Tales of Númenor and Middle-earth",
+        // Nonfiction
+        "The History of Middle-earth",
+        "The Children of Húrin",
+        "Beren and Lúthien",
+        "The Fall of Gondolin",
+        "The Fall of Númenor",
+    ]
+}

src/kirill.rs

@@ -12,11 +12,12 @@ use std::process;
 /// CLI entrypoint
 fn main() {
     let brief: String = format!(
-        "Usage: {} [OPTIONS] <path> [<path> [<path> ...]]",
+        "usage: {} [OPTIONS] <path> [<path> [<path> ...]]",
         env!("CARGO_PKG_NAME")
     );
 
     let mut opts: getopts::Options = getopts::Options::new();
+    opts.optflag("5", "json5", "parse according to JSON5");
     opts.optflag("l", "list", "list JSON files");
     opts.optopt(
         "s",
@@ -39,8 +40,15 @@ fn main() {
         die!(0; format!("{} {}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION")));
     }
 
+    let parse_json5: bool = optmatches.opt_present("5");
     let list_documents: bool = optmatches.opt_present("l");
     let validate_schema: bool = optmatches.opt_present("s");
+
+    if parse_json5 && validate_schema {
+        eprintln!("error: JSON5 incompatible with JSON Schema");
+        die!(usage);
+    }
+
     let schema_option: Option<String> = optmatches.opt_str("s");
 
     if validate_schema && schema_option.is_none() {
@@ -54,7 +62,8 @@ fn main() {
     }
 
     let roots: Vec<&path::Path> = rest_args.iter().map(path::Path::new).collect();
-    let json_documents_result = kirill::find_json_documents_sorted(roots);
+
+    let json_documents_result = kirill::find_json_documents_sorted(roots, parse_json5);
 
     if let Err(e) = json_documents_result {
         die!(e);
@@ -91,7 +100,7 @@ fn main() {
         let mut found_invalid: bool = false;
 
         for json_document in json_documents {
-            if let Some(e) = kirill::validate_json_file_basic(&json_document) {
+            if let Some(e) = kirill::validate_json_file_basic(&json_document, parse_json5) {
                 found_invalid = true;
                 eprintln!("error: {}: {}", json_document, e);
             }

src/lib.rs

@@ -5,6 +5,7 @@ extern crate json_schema_validator_core;
 extern crate lazy_static;
 extern crate regex;
 extern crate serde_json;
+extern crate serde_json5;
 extern crate walkdir;
 
 use std::fmt;
@@ -13,24 +14,58 @@ use std::path;
 use std::process;
 
 lazy_static::lazy_static! {
-    /// DEFAULT_JSON_FILE_PATTERNS collects patterns for identifying JSON files.
-    pub static ref DEFAULT_JSON_FILE_PATTERNS: regex::Regex = regex::Regex::new(
-        &[
-            // eslint
-            r".*\.eslintrc",
+    /// JSON_FILE_EXTENSIONS collects common JSON file extensions.
+    pub static ref JSON_FILE_EXTENSIONS: Vec<String> = vec![
+        // eslint
+        "eslintrc".to_string(),
 
-            // jsfmt
-            r".*\.jsfmtrc",
+        // jsfmt
+        "jsfmtrc".to_string(),
 
-            // jslint
-            r".*\.jslintrc",
+        // jslint
+        "jslintrc".to_string(),
 
-            // jshint
-            r".*\.jshintrc",
+        // jshint
+        "jshintrc".to_string(),
 
-            // JSON
-            r".*\.json",
-        ].join("|")
+        // JSON
+        "json".to_string(),
+    ];
+
+    /// JSON5_FILE_EXTENSIONS collects common JSON5 file extensions.
+    pub static ref JSON5_FILE_EXTENSIONS: Vec<String> = JSON_FILE_EXTENSIONS
+        .iter()
+        .chain(
+            &[
+                // JSON5
+                "json5".to_string(),
+            ]
+        ).cloned()
+        .collect();
+
+    /// DEFAULT_JSON_FILE_PATTERNS collects patterns for identifying JSON files.
+    pub static ref DEFAULT_JSON_FILE_PATTERNS: regex::Regex = regex::Regex::new(
+        &format!(
+            "({})$",
+            JSON_FILE_EXTENSIONS
+                .iter()
+                .map(|e| format!(r".*\.{}", e))
+                .collect::<Vec<String>>()
+                .join("|")
+        )
+    )
+    .unwrap();
+
+    /// DEFAULT_JSON5_FILE_PATTERNS collects patterns for identifying JSON files.
+    pub static ref DEFAULT_JSON5_FILE_PATTERNS: regex::Regex = regex::Regex::new(
+        &format!(
+            "({})$",
+            JSON5_FILE_EXTENSIONS
+                .iter()
+                .map(|e| format!(r".*\.{}", e))
+                .collect::<Vec<String>>()
+                .join("|")
+        )
     )
     .unwrap();
 
@@ -68,6 +103,7 @@ pub enum KirillError {
     UnsupportedPathError(String),
     PathRenderError(String),
     JSONParseError(serde_json::Error),
+    JSON5ParseError(serde_json5::Error),
     JSONSchemaError(String),
 }
 
@@ -79,6 +115,7 @@ impl fmt::Display for KirillError {
             KirillError::UnsupportedPathError(e) => write!(f, "{}", e),
             KirillError::PathRenderError(e) => write!(f, "{}", e),
             KirillError::JSONParseError(e) => write!(f, "{}", e),
+            KirillError::JSON5ParseError(e) => write!(f, "{}", e),
             KirillError::JSONSchemaError(e) => write!(f, "{}", e),
         }
     }
@@ -94,7 +131,10 @@ impl die::PrintExit for KirillError {
 /// find_json_documents recursively searches
 /// the given directories and/or file root paths
 /// for JSON documents.
-pub fn find_json_documents(roots: Vec<&path::Path>) -> Result<Vec<String>, KirillError> {
+pub fn find_json_documents(
+    roots: Vec<&path::Path>,
+    parse_json5: bool,
+) -> Result<Vec<String>, KirillError> {
     let mut pth_bufs = Vec::<path::PathBuf>::new();
 
     for root in roots {
@@ -146,7 +186,13 @@ pub fn find_json_documents(roots: Vec<&path::Path>) -> Result<Vec<String>, Kiril
             continue;
         }
 
-        if DEFAULT_JSON_FILE_PATTERNS.is_match(pth_abs_str) {
+        let pattern = if parse_json5 {
+            &*DEFAULT_JSON5_FILE_PATTERNS
+        } else {
+            &*DEFAULT_JSON_FILE_PATTERNS
+        };
+
+        if pattern.is_match(pth_abs_str) {
             let pth_clean_buf = clean_path::clean(pth);
             let pth_clean = pth_clean_buf.as_path();
             let pth_clean_str = pth_clean
@@ -163,8 +209,11 @@ pub fn find_json_documents(roots: Vec<&path::Path>) -> Result<Vec<String>, Kiril
 }
 
 /// find_json_documents_sorted lexicographically sorts any JSON document results.
-pub fn find_json_documents_sorted(roots: Vec<&path::Path>) -> Result<Vec<String>, KirillError> {
-    let mut json_documents = find_json_documents(roots)?;
+pub fn find_json_documents_sorted(
+    roots: Vec<&path::Path>,
+    parse_json5: bool,
+) -> Result<Vec<String>, KirillError> {
+    let mut json_documents = find_json_documents(roots, parse_json5)?;
     json_documents.sort();
     Ok(json_documents)
 }
@@ -173,7 +222,7 @@ pub fn find_json_documents_sorted(roots: Vec<&path::Path>) -> Result<Vec<String>
 ///
 /// Returns Some(error) on error.
 /// Otherwise, returns None.
-pub fn validate_json_file_basic(s: &str) -> Option<KirillError> {
+pub fn validate_json_file_basic(s: &str, parse_json5: bool) -> Option<KirillError> {
     let pth = path::Path::new(s);
 
     match fs::read_to_string(pth) {
@@ -182,9 +231,17 @@ pub fn validate_json_file_basic(s: &str) -> Option<KirillError> {
             pth.display()
         ))),
 
-        Ok(contents) => serde_json::from_str::<serde_json::Value>(&contents)
-            .map_err(KirillError::JSONParseError)
-            .err(),
+        Ok(contents) => {
+            if parse_json5 {
+                serde_json5::from_str::<serde_json::Value>(&contents)
+                    .map_err(KirillError::JSON5ParseError)
+                    .err()
+            } else {
+                serde_json::from_str::<serde_json::Value>(&contents)
+                    .map_err(KirillError::JSONParseError)
+                    .err()
+            }
+        }
     }
 }