Rewrite the categories TOML format and parser

Author: shepmaster

src/categories.rs

@@ -7,71 +7,76 @@ use env;
 use util::errors::{CargoResult, ChainError, internal};
 
 struct Category {
-    name: String,
     slug: String,
+    name: String,
     description: String,
 }
 
 impl Category {
-    fn concat(&self, child: &Category) -> Category {
-        Category {
-            name: format!("{}::{}", self.name, child.name),
-            slug: format!("{}::{}", self.slug, child.slug),
-            description: child.description.clone(),
+    fn from_parent(slug: &str, name: &str, description: &str, parent: Option<&Category>)
+                   -> Category {
+        match parent {
+            Some(parent) => {
+                Category {
+                    slug: format!("{}::{}", parent.slug, slug),
+                    name: format!("{}::{}", parent.name, name),
+                    description: description.into(),
+                }
+            }
+            None => {
+                Category {
+                    slug: slug.into(),
+                    name: name.into(),
+                    description: description.into(),
+                }
+            }
         }
     }
 }
 
-fn concat_parent_and_child(parent: Option<&Category>, child: Category)
-                           -> Category {
-    parent.map(|p| p.concat(&child)).unwrap_or(child)
-}
-
-fn required_string_from_toml(toml: &toml::Table, key: &str)
-                             -> CargoResult<String> {
+fn required_string_from_toml<'a>(toml: &'a toml::Table, key: &str) -> CargoResult<&'a str> {
     toml.get(key)
         .and_then(toml::Value::as_str)
-        .map(str::to_string)
         .chain_error(|| {
-            internal("Expected Category toml attribute to be a String")
+            internal(format!("Expected category TOML attribute '{}' to be a String", key))
         })
 }
 
-fn optional_string_from_toml(toml: &toml::Table, key: &str)
-                             -> String {
+fn optional_string_from_toml<'a>(toml: &'a toml::Table, key: &str) -> &'a str {
     toml.get(key)
         .and_then(toml::Value::as_str)
         .unwrap_or("")
-        .to_string()
 }
 
-fn category_from_toml(toml: &toml::Value, parent: Option<&Category>)
-                      -> CargoResult<Vec<Category>> {
-    let toml = toml.as_table().chain_error(|| {
-        internal("Category isn't a toml Table")
-    })?;
-
-    let category = Category {
-        slug: required_string_from_toml(&toml, "slug")?,
-        name: required_string_from_toml(&toml, "name")?,
-        description: optional_string_from_toml(&toml, "description"),
-    };
-
-    let category = concat_parent_and_child(parent, category);
-
-    let mut children: Vec<_> = toml.get("categories")
-        .and_then(toml::Value::as_slice)
-        .map(|children| {
-            children.iter()
-                .flat_map(|ref child| {
-                    category_from_toml(child, Some(&category))
-                        .expect("Could not create child from toml")
-                }).collect()
-        }).unwrap_or(Vec::new());
-
-    children.push(category);
-
-    Ok(children)
+fn categories_from_toml(categories: &toml::Table, parent: Option<&Category>) -> CargoResult<Vec<Category>> {
+    let mut result = vec![];
+
+    for (slug, details) in categories {
+        let details = details.as_table().chain_error(|| {
+            internal(format!("category {} was not a TOML table", slug))
+        })?;
+
+        let category = Category::from_parent(
+            slug,
+            required_string_from_toml(&details, "name")?,
+            optional_string_from_toml(&details, "description"),
+            parent,
+        );
+
+        if let Some(categories) = details.get("categories") {
+            let categories = categories.as_table().chain_error(|| {
+                internal(format!("child categories of {} were not a table", slug))
+            })?;
+
+            result.extend(
+                categories_from_toml(categories, Some(&category))?
+            );
+        }
+
+        result.push(category)
+    }
+
+    Ok(result)
 }
 
 pub fn sync() -> CargoResult<()> {
@@ -84,17 +89,9 @@ pub fn sync() -> CargoResult<()> {
         "Could not parse categories.toml"
     );
 
-    let categories = toml.get("categories")
-                         .expect("No categories key found")
-                         .as_slice()
-                         .expect("Categories isn't a toml::Array");
-
-    let categories: Vec<_> = categories
-        .iter()
-        .flat_map(|c| {
-            category_from_toml(c, None)
-                .expect("Categories from toml failed")
-        }).collect();
+    let categories = categories_from_toml(&toml, None).expect(
+        "Could not convert categories from TOML"
+    );
 
     for category in categories.iter() {
         tx.execute("\

src/categories.toml

@@ -1,32 +1,27 @@
-[[categories]]
-slug = "development-tools"
+[development-tools]
 name = "Development Tools"
 description = "Ways to make developing in Rust better"
 
-[[categories.categories]]
-  slug = "testing"
+  [development-tools.categories.testing]
   name = "Testing"
   description = "Additions to automated testing features"
 
-  [[categories.categories.categories]]
-    slug = "mocking"
+    [development-tools.categories.testing.categories.mocking]
     name = "Mocking"
+    description = "Mocks are not the same as stubs!"
 
-[[categories]]
-slug = "libraries"
+[libraries]
 name = "Libraries"
+description = "Libraries are reusable pieces of code"
 
-[[categories.categories]]
-  slug = "async"
+  [libraries.categories.async]
   name = "Async"
   description = "Code that can take time to run but won't block"
 
-[[categories.categories]]
-  slug = "date-and-time"
+  [libraries.categories.date-and-time]
   name = "Date and Time"
   description = "Date and time math"
 
-[[categories]]
-slug = "games"
+[games]
 name = "Games"
 description = "Share fun things"