Merge pull request #6 from RobDWaller/0.2.0-beta

0.2.0 beta

Author: RobDWaller

.cargo/config

@@ -0,0 +1,3 @@
+[alias]
+lint = "fmt -- --check"
+analyse = "clippy --all-targets --all-features -- -D warnings"

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "csp_generator"
 description = "Consume a JSON formatted list of domains and CSP directives and output a correctly formatted Content Security Policy string."
-version = "0.1.0-rc.1"
+version = "0.2.0-beta"
 authors = ["Rob Waller <rdwaller1984@gmail.com>"]
 edition = "2018"
 keywords = ["csp", "json", "content-security", "csp-generator", "security"]

src/directives/line.rs

@@ -1,6 +1,6 @@
-use crate::domains;
+use crate::domains::{Collection, Item};
 
-fn domains_to_directive(directive: String, domains: Vec<domains::Item>) -> String {
+fn domains_to_directive(directive: String, domains: Vec<Item>) -> String {
     let mut directive_line = directive.clone();
 
     for domain in domains {
@@ -27,8 +27,8 @@ fn create_check(mut directive: String) -> String {
     directive
 }
 
-pub fn build(directive: String, domains: domains::Collection) -> String {
-    let directive_line = domains_to_directive(directive.clone(), domains.domains);
+pub fn build(directive: String, domains: Collection) -> String {
+    let directive_line = domains_to_directive(directive.clone(), domains);
 
     check_line(directive_line, create_check(directive))
 }
@@ -38,25 +38,21 @@ pub fn build(directive: String, domains: domains::Collection) -> String {
 // -----
 #[cfg(test)]
 mod lines_test {
-    use crate::domains;
+    use crate::domains::{Collection, Item};
 
     #[test]
     fn test_build() {
         let directives: Vec<String> = vec![String::from("connect-src"), String::from("script-src")];
 
-        let item = domains::Item {
+        let item = Item {
             domain: String::from("*.example.com"),
             directive: directives,
         };
 
-        let mut domain_list: Vec<domains::Item> = Vec::new();
+        let mut domain_list: Collection = Vec::new();
         domain_list.push(item);
 
-        let json = domains::Collection {
-            domains: domain_list,
-        };
-
-        let connect_src: String = super::build(String::from("connect-src"), json);
+        let connect_src: String = super::build(String::from("connect-src"), domain_list);
 
         assert_eq!(connect_src, String::from("connect-src *.example.com; "));
     }
@@ -65,19 +61,15 @@ mod lines_test {
     fn test_build_line_no_directive() {
         let directives: Vec<String> = vec![String::from("connect-src"), String::from("script-src")];
 
-        let item = domains::Item {
+        let item = Item {
             domain: String::from("*.example.com"),
             directive: directives,
         };
 
-        let mut domain_list: Vec<domains::Item> = Vec::new();
+        let mut domain_list: Collection = Vec::new();
         domain_list.push(item);
 
-        let json = domains::Collection {
-            domains: domain_list,
-        };
-
-        let default_src: String = super::build(String::from("default-src"), json);
+        let default_src: String = super::build(String::from("default-src"), domain_list);
 
         assert_eq!(default_src, String::from(""));
     }

src/directives/mod.rs

@@ -42,12 +42,10 @@ mod directives_test {
     #[test]
     fn test_build_directives() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "directive": ["connect-src"]},
-                    {"domain": "test.com", "directive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "directive": ["connect-src"]},
+                {"domain": "test.com", "directive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         let csp: Result<String, error::Error> = super::build(config::get_directives(), json);

src/directives/threads.rs

@@ -1,16 +1,13 @@
 use crate::directives::line;
-use crate::domains;
+use crate::domains::Collection;
 use std::thread;
 use std::thread::JoinHandle;
 
-fn create(directive: String, domains: domains::Collection) -> JoinHandle<String> {
+fn create(directive: String, domains: Collection) -> JoinHandle<String> {
     thread::spawn(move || line::build(directive, domains.clone()))
 }
 
-pub fn build_lines(
-    directives: Vec<String>,
-    domains: domains::Collection,
-) -> Vec<JoinHandle<String>> {
+pub fn build_lines(directives: Vec<String>, domains: Collection) -> Vec<JoinHandle<String>> {
     let mut threads: Vec<JoinHandle<String>> = vec![];
 
     for directive in directives {
@@ -25,20 +22,19 @@ pub fn build_lines(
 // -----
 #[cfg(test)]
 mod threads_test {
-    use crate::domains;
+    use crate::domains::{Collection, Item};
 
     #[test]
     fn test_create() {
         let domain = String::from("*.google.com");
         let directive = vec![String::from("connect-src")];
 
-        let domain = domains::Item { domain, directive };
-        let domains = vec![domain];
-        let collection = domains::Collection { domains };
+        let domain = Item { domain, directive };
+        let domains: Collection = vec![domain];
 
         let directive_check = String::from("connect-src");
 
-        let result = super::create(directive_check, collection);
+        let result = super::create(directive_check, domains);
 
         assert_eq!(
             result.join().unwrap().as_str(),

src/domains.rs

@@ -4,10 +4,7 @@ pub struct Item {
     pub directive: Vec<String>,
 }
 
-#[derive(Serialize, Deserialize, Clone)]
-pub struct Collection {
-    pub domains: Vec<Item>,
-}
+pub type Collection = Vec<Item>;
 
 // -----
 // Tests
@@ -36,12 +33,10 @@ mod item_test {
             directive: directives,
         };
 
-        let mut domains: Vec<super::Item> = vec![];
+        let mut domains: super::Collection = vec![];
         domains.push(item);
 
-        let collection = super::Collection { domains };
-
-        assert_eq!(collection.domains[0].domain, "*.example.com");
-        assert_eq!(collection.domains[0].directive[1], "script-src");
+        assert_eq!(domains[0].domain, "*.example.com");
+        assert_eq!(domains[0].directive[1], "script-src");
     }
 }

src/parse.rs

@@ -1,12 +1,12 @@
-use crate::domains;
+use crate::domains::Collection;
 use serde_json::error;
 
-pub fn json(json: &str) -> Result<domains::Collection, error::Error> {
+pub fn json(json: &str) -> Result<Collection, error::Error> {
     let result = serde_json::from_str(json);
 
     match result {
         Ok(result) => {
-            let parsed: domains::Collection = result;
+            let parsed: Collection = result;
             Ok(parsed)
         }
         Err(e) => Err(e),
@@ -21,19 +21,17 @@ mod parse_json_test {
     #[test]
     fn test_parse_json() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "directive": ["connect-src", "script-src"]},
-                    {"domain": "test.com", "directive": ["script-src", "img-src", "style-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "directive": ["connect-src", "script-src"]},
+                {"domain": "test.com", "directive": ["script-src", "img-src", "style-src"]}
+            ]
         "#;
 
         let domains = super::json(json).unwrap();
 
-        assert_eq!(domains.domains[0].domain, "example.com");
-        assert_eq!(domains.domains[1].domain, "test.com");
-        assert_eq!(domains.domains[1].directive[1], "img-src");
+        assert_eq!(domains[0].domain, "example.com");
+        assert_eq!(domains[1].domain, "test.com");
+        assert_eq!(domains[1].directive[1], "img-src");
     }
 
     #[test]
@@ -48,11 +46,9 @@ mod parse_json_test {
     #[test]
     fn test_parse_json_bad() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "diroctive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "diroctive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         let domains = super::json(json);

tests/csp_generator_test.rs

@@ -6,12 +6,10 @@ mod csp_generator_test {
     #[test]
     fn test_enforce() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "directive": ["connect-src"]},
-                    {"domain": "test.com", "directive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "directive": ["connect-src"]},
+                {"domain": "test.com", "directive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         let csp: csp_generator::Csp = csp_generator::enforce(config::get_directives(), json);
@@ -35,12 +33,10 @@ mod csp_generator_test {
     #[should_panic(expected = "Could not parse JSON: missing field")]
     fn test_enforce_format_fail() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "diroctive": ["connect-src"]},
-                    {"domain": "test.com", "directive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "diroctive": ["connect-src"]},
+                {"domain": "test.com", "directive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         csp_generator::enforce(config::get_directives(), json);
@@ -49,12 +45,10 @@ mod csp_generator_test {
     #[test]
     fn test_report_only() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "directive": ["connect-src"]},
-                    {"domain": "test.com", "directive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "directive": ["connect-src"]},
+                {"domain": "test.com", "directive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         let csp: csp_generator::Csp = csp_generator::report_only(config::get_directives(), json);
@@ -81,12 +75,10 @@ mod csp_generator_test {
     #[should_panic(expected = "Could not parse JSON: missing field")]
     fn test_report_only_format_fail() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "directive": ["connect-src"]},
-                    {"directive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "directive": ["connect-src"]},
+                {"directive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         csp_generator::report_only(config::get_directives(), json);
@@ -95,12 +87,10 @@ mod csp_generator_test {
     #[test]
     fn test_csp_only() {
         let json = r#"
-            {
-                "domains": [
-                    {"domain": "example.com", "directive": ["connect-src"]},
-                    {"domain": "test.com", "directive": ["connect-src", "script-src"]}
-                ]
-            }
+            [
+                {"domain": "example.com", "directive": ["connect-src"]},
+                {"domain": "test.com", "directive": ["connect-src", "script-src"]}
+            ]
         "#;
 
         let csp: String = csp_generator::csp_only(config::get_directives(), json);