feat(sickle): add granular feature flags and serde serialization (#44)

## Summary

- Add granular feature flags for fine-grained control over sickle
functionality
- Implement serde `Serialize` support (`to_string`) to complement
existing `Deserialize`

### Feature Dependency Graph

```
serde ─┬─> serde-deserialize ──> hierarchy ──> parse
       └─> serde-serialize ───> printer ────> hierarchy ──> parse

intern (independent)
```

### Features

| Feature | Description | Dependencies |
|---------|-------------|--------------|
| `parse` | Core parsing | - |
| `hierarchy` | Build hierarchical model | `parse` |
| `printer` | CCL printer | `hierarchy` |
| `serde-deserialize` | Serde Deserialize | `hierarchy` |
| `serde-serialize` | Serde Serialize (NEW) | `printer` |
| `serde` | Both ser/de | `serde-deserialize`, `serde-serialize` |
| `full` | Everything | all |

## Test plan

- [x] All existing tests pass
- [x] New serialization tests pass
- [x] Feature combinations compile correctly
- [x] Downstream crates (santa-data, santa) still work

Author: tylerbutler

Cargo.lock

@@ -13,18 +13,39 @@ categories = ["config", "parser-implementations"]
 readme = "README.md"
 
 [features]
-# Default features
-default = ["serde"]
+# Default features - includes only essential functionality
+# Users opt-in to additional features as needed
+default = []
 
-# Core parsing features
-serde = ["dep:serde", "dep:serde_derive"]
+# Core parsing - parse CCL to flat key-value entries
+parse = []
+
+# Hierarchy building - build hierarchical CclObject from entries (includes parse)
+hierarchy = ["parse"]
+
+# Serde deserialization: CCL string -> Rust types (includes hierarchy)
+serde-deserialize = ["hierarchy", "dep:serde", "dep:serde_derive"]
+
+# CCL printer - serialize CclObject back to canonical CCL text (includes hierarchy)
+printer = ["hierarchy"]
+
+# Serde serialization: Rust types -> CCL string (includes printer)
+serde-serialize = ["printer", "dep:serde", "dep:serde_derive"]
+
+# Both serde serialization and deserialization
+serde = ["serde-deserialize", "serde-serialize"]
+
+# String interning for memory efficiency with large configs
 intern = ["dep:string-interner"]
 
 # Reference implementation compatibility (opt-in for compatibility testing)
 # Note: Reverses duplicate-key list order to match reference implementation
 # Most users should NOT enable this - use insertion-order behavior (default)
 reference_compliant = []
 
+# All features enabled
+full = ["serde", "printer", "intern"]
+
 # Advanced parsing features (future)
 # section-headers = []      # Support == Section == style headers
 # typed-access = []         # Convenience methods: get_string, get_int, get_bool
@@ -43,8 +64,13 @@ string-interner = { version = "0.17", optional = true }
 
 [dev-dependencies]
 # Testing framework
+serde.workspace = true
 serde_json.workspace = true
-serde_test = "1.0.177"
+
+# Enable all features for tests
+[dev-dependencies.sickle]
+path = "."
+features = ["full"]
 
 [[example]]
 name = "basic_parsing"

crates/sickle/Cargo.toml

@@ -50,26 +50,43 @@
 //!
 //! ## Cargo Features
 //!
-//! - `serde` (default): Serde serialization/deserialization support
+//! By default, sickle includes only the core types (`CclObject`, `Entry`, `Error`).
+//! Enable features to add functionality:
+//!
+//! - `parse`: Core parsing (`parse`, `parse_indented`) - returns flat key-value entries
+//! - `hierarchy`: Build hierarchical model (`build_hierarchy`, `load`) - includes `parse`
+//! - `printer`: CCL printer for serializing back to canonical CCL text - includes `hierarchy`
+//! - `serde-deserialize`: Serde deserialization (`from_str`) - includes `hierarchy`
+//! - `serde-serialize`: Serde serialization (`to_string`) - includes `printer`
+//! - `serde`: Both serialization and deserialization
 //! - `intern`: String interning for memory efficiency with large configs
+//! - `full`: Enable all features
 //!
 //! ### Future Features (Planned)
 //!
 //! - `section-headers`: Support `== Section ==` style headers
-//! - `duplicate-key-lists`: Auto-create lists from duplicate keys
 //! - `typed-access`: Convenience methods like `get_string()`, `get_int()`
 //! - `list-indexing`: Advanced list operations and indexing
 
 pub mod error;
 pub mod model;
+
+#[cfg(feature = "parse")]
 mod parser;
+
+#[cfg(feature = "printer")]
 pub mod printer;
 
-#[cfg(feature = "serde")]
+#[cfg(feature = "serde-deserialize")]
 pub mod de;
 
+#[cfg(feature = "serde-serialize")]
+pub mod ser;
+
 pub use error::{Error, Result};
 pub use model::{CclObject, Entry};
+
+#[cfg(feature = "printer")]
 pub use printer::{CclPrinter, PrinterConfig};
 
 /// Parse a CCL string into a flat list of entries
@@ -78,6 +95,8 @@ pub use printer::{CclPrinter, PrinterConfig};
 /// without building the hierarchical structure. Use `build_hierarchy()` to
 /// construct the hierarchical model from these entries.
 ///
+/// Requires the `parse` feature.
+///
 /// # Examples
 ///
 /// ```rust
@@ -93,6 +112,7 @@ pub use printer::{CclPrinter, PrinterConfig};
 /// assert_eq!(entries[0].key, "name");
 /// assert_eq!(entries[0].value, "MyApp");
 /// ```
+#[cfg(feature = "parse")]
 pub fn parse(input: &str) -> Result<Vec<Entry>> {
     let map = parser::parse_to_map(input)?;
 
@@ -112,6 +132,8 @@ pub fn parse(input: &str) -> Result<Vec<Entry>> {
 /// This is the second step of CCL processing, taking the entries from `parse()`
 /// and constructing a hierarchical structure with proper nesting and type inference.
 ///
+/// Requires the `hierarchy` feature.
+///
 /// # Examples
 ///
 /// ```rust
@@ -126,6 +148,7 @@ pub fn parse(input: &str) -> Result<Vec<Entry>> {
 /// let model = build_hierarchy(&entries).unwrap();
 /// assert_eq!(model.get_string("name").unwrap(), "MyApp");
 /// ```
+#[cfg(feature = "hierarchy")]
 pub fn build_hierarchy(entries: &[Entry]) -> Result<CclObject> {
     // Group entries by key (preserving order with IndexMap)
     let mut map: indexmap::IndexMap<String, Vec<String>> = indexmap::IndexMap::new();
@@ -141,6 +164,7 @@ pub fn build_hierarchy(entries: &[Entry]) -> Result<CclObject> {
 
 /// Check if a string looks like a valid CCL key
 /// Valid keys: alphanumeric, underscores, dots, hyphens (not leading), slashes for comments
+#[cfg(feature = "hierarchy")]
 fn is_valid_ccl_key(key: &str) -> bool {
     if key.is_empty() {
         return true; // Empty keys are valid (for lists)
@@ -168,6 +192,7 @@ fn is_valid_ccl_key(key: &str) -> bool {
 /// - `key =` (empty value) becomes `{"key": {"": {}}}`
 /// - Multiple values become multiple nested keys
 /// - Nested CCL is recursively parsed
+#[cfg(feature = "hierarchy")]
 fn build_model(map: indexmap::IndexMap<String, Vec<String>>) -> Result<CclObject> {
     let mut result = indexmap::IndexMap::new();
 
@@ -238,6 +263,8 @@ fn build_model(map: indexmap::IndexMap<String, Vec<String>>) -> Result<CclObject
 /// This is used for parsing nested CCL values where the entire block may be
 /// indented in the parent context.
 ///
+/// Requires the `parse` feature.
+///
 /// # Examples
 ///
 /// ```rust
@@ -247,6 +274,7 @@ fn build_model(map: indexmap::IndexMap<String, Vec<String>>) -> Result<CclObject
 /// let entries = parse_indented(nested).unwrap();
 /// assert_eq!(entries.len(), 3);
 /// ```
+#[cfg(feature = "parse")]
 pub fn parse_indented(input: &str) -> Result<Vec<Entry>> {
     // Find the minimum indentation level (common prefix)
     let min_indent = input
@@ -293,6 +321,7 @@ pub fn parse_indented(input: &str) -> Result<Vec<Entry>> {
 }
 
 /// Parse all key=value pairs from input as flat entries, ignoring indentation hierarchy
+#[cfg(feature = "parse")]
 fn parse_flat_entries(input: &str) -> Result<Vec<Entry>> {
     let mut entries = Vec::new();
 
@@ -319,6 +348,7 @@ fn parse_flat_entries(input: &str) -> Result<Vec<Entry>> {
 }
 
 /// Parse input as a single entry, preserving the raw value including indentation
+#[cfg(feature = "parse")]
 fn parse_single_entry_with_raw_value(input: &str) -> Result<Vec<Entry>> {
     // Find the first line with '='
     let mut lines = input.lines();
@@ -358,6 +388,8 @@ fn parse_single_entry_with_raw_value(input: &str) -> Result<Vec<Entry>> {
 /// This is a convenience function that combines `parse()` and `build_hierarchy()`.
 /// Equivalent to: `build_hierarchy(&parse(input)?)`
 ///
+/// Requires the `hierarchy` feature.
+///
 /// # Examples
 ///
 /// ```rust
@@ -371,14 +403,18 @@ fn parse_single_entry_with_raw_value(input: &str) -> Result<Vec<Entry>> {
 /// let model = load(ccl).unwrap();
 /// assert_eq!(model.get_string("name").unwrap(), "MyApp");
 /// ```
+#[cfg(feature = "hierarchy")]
 pub fn load(input: &str) -> Result<CclObject> {
     let entries = parse(input)?;
     build_hierarchy(&entries)
 }
 
-#[cfg(feature = "serde")]
+#[cfg(feature = "serde-deserialize")]
 pub use de::from_str;
 
+#[cfg(feature = "serde-serialize")]
+pub use ser::to_string;
+
 // Unit tests removed - all functionality is covered by data-driven tests in:
 // - api_core_ccl_parsing.json (basic parsing, multiline values, equals in values)
 // - api_core_ccl_hierarchy.json (build_hierarchy, nested structures, duplicate keys to lists)

crates/sickle/src/lib.rs

@@ -97,6 +97,7 @@ impl CclObject {
 
     /// Create a Model from an IndexMap
     /// This is internal-only for crate operations
+    #[cfg(feature = "hierarchy")]
     pub(crate) fn from_map(map: IndexMap<String, CclObject>) -> Self {
         CclObject(map)
     }
@@ -124,6 +125,7 @@ impl CclObject {
     }
 
     /// Get the concrete IndexMap iterator for internal use (Serde)
+    #[cfg(feature = "serde-deserialize")]
     pub(crate) fn iter_map(&self) -> indexmap::map::Iter<'_, String, CclObject> {
         self.0.iter()
     }
@@ -358,6 +360,7 @@ impl CclObject {
     ///
     /// Creates the representation `{string: {}}`
     /// This is internal-only for Serde support
+    #[cfg(feature = "serde-deserialize")]
     pub(crate) fn from_string(s: impl Into<String>) -> Self {
         let mut map = IndexMap::new();
         map.insert(s.into(), CclObject::new());
@@ -366,9 +369,36 @@ impl CclObject {
 
     /// Extract the inner IndexMap, consuming the Model
     /// This is internal-only for crate operations
+    #[cfg(feature = "hierarchy")]
     pub(crate) fn into_inner(self) -> IndexMap<String, CclObject> {
         self.0
     }
+
+    /// Insert a string value at the given key
+    /// Creates the CCL representation: `{key: {value: {}}}`
+    #[cfg(feature = "serde-serialize")]
+    pub(crate) fn insert_string(&mut self, key: &str, value: String) {
+        let mut inner = IndexMap::new();
+        inner.insert(value, CclObject::new());
+        self.0.insert(key.to_string(), CclObject(inner));
+    }
+
+    /// Insert a list of string values at the given key
+    /// Creates the CCL representation: `{key: {item1: {}, item2: {}, ...}}`
+    #[cfg(feature = "serde-serialize")]
+    pub(crate) fn insert_list(&mut self, key: &str, values: Vec<String>) {
+        let mut inner = IndexMap::new();
+        for value in values {
+            inner.insert(value, CclObject::new());
+        }
+        self.0.insert(key.to_string(), CclObject(inner));
+    }
+
+    /// Insert a nested object at the given key
+    #[cfg(feature = "serde-serialize")]
+    pub(crate) fn insert_object(&mut self, key: &str, obj: CclObject) {
+        self.0.insert(key.to_string(), obj);
+    }
 }
 
 impl Default for CclObject {