Understanding and Parsing Cargo.toml in Rust

Rust's package manager, Cargo, relies on the Cargo.toml file to define project metadata, dependencies, and build configurations. This challenge focuses on understanding and programmatically parsing the structure of a Cargo.toml file in Rust, enabling you to extract essential information about a Rust project. This is a fundamental skill for anyone building tools that interact with the Rust ecosystem.

Problem Description

Your task is to implement a Rust program that can parse a simplified Cargo.toml file and extract key information. You will need to represent the parsed data using Rust structs and handle different data types found within the Cargo.toml file, such as strings, booleans, and arrays of strings.

The Cargo.toml file follows a TOML (Tom's Obvious, Minimal Language) format. For this challenge, we'll focus on parsing the following sections and keys:

• [package] section:
  • name: String (required)
  • version: String (required)
  • edition: String (optional, defaults to "2018" if not present)
  • authors: Array of Strings (optional)
• [dependencies] section:
  • This section contains key-value pairs where keys are dependency names (Strings) and values can be:
    • A simple version string (e.g., "1.0").
    • A more complex structure (which we'll simplify for this challenge to just a version string for now).

Requirements:

1. Define Rust structs to represent the parsed data from Cargo.toml. You should at least have a struct for the overall Cargo.toml and one for the [package] section.
2. Implement a function that takes a string representing the content of a Cargo.toml file as input.
3. This function should return a structured representation (your defined Rust structs) of the parsed Cargo.toml content.
4. Handle the optional edition field, providing a default value if it's missing.
5. Handle the optional authors field.
6. Parse the [dependencies] section as a map where keys are dependency names and values are their version strings.

Expected Behavior:

The parser should accurately extract the specified information. If an optional field is missing, it should either be None or have its default value.

Examples

Example 1:

Input:

[package]
name = "my_awesome_project"
version = "0.1.0"
authors = ["Alice <alice@example.com>", "Bob <bob@example.com>"]
edition = "2021"

[dependencies]
rand = "0.8.5"
serde = { version = "1.0.197", features = ["derive"] }

Output: (Represented conceptually, actual output would be Rust structs)

{
    package: {
        name: "my_awesome_project",
        version: "0.1.0",
        authors: Some(["Alice <alice@example.com>", "Bob <bob@example.com>"]),
        edition: Some("2021")
    },
    dependencies: {
        "rand": "0.8.5",
        "serde": "1.0.197" // Note: We're simplifying dependency parsing to just the version string.
    }
}

Explanation: The input is a standard Cargo.toml with a package section containing all specified fields and a dependencies section with two entries. The parser correctly extracts all fields, including the authors array and the edition. For serde, only the version is extracted as per the simplified requirement.

Example 2:

Input:

[package]
name = "another_crate"
version = "1.2.3"

[dependencies]
tokio = "1.37.0"

Output: (Represented conceptually)

{
    package: {
        name: "another_crate",
        version: "1.2.3",
        authors: None,
        edition: Some("2018") // Default edition is used
    },
    dependencies: {
        "tokio": "1.37.0"
    }
}

Explanation: This Cargo.toml is missing the authors and edition fields in the [package] section. The parser correctly assigns None to authors and the default value "2018" to edition.

Example 3:

Input:

[package]
name = "minimal_project"
version = "0.0.1"

[dependencies]
anyhow = "1.0.82"

Output: (Represented conceptually)

{
    package: {
        name: "minimal_project",
        version: "0.0.1",
        authors: None,
        edition: Some("2018")
    },
    dependencies: {
        "anyhow": "1.0.82"
    }
}

Explanation: This is a minimal valid Cargo.toml for the purpose of this challenge. It demonstrates handling of missing optional fields.

Constraints

• The input Cargo.toml content will be provided as a single String.
• The TOML structure will be valid according to the simplified format described. You do not need to handle arbitrary TOML syntax errors.
• Dependency values in [dependencies] will be either a simple string representing the version, or a table with at least a version key. For this challenge, you should only extract the version string.
• Performance is not a primary concern for this challenge, but the solution should be reasonably efficient for typical Cargo.toml sizes.

Notes

• You will likely want to use a TOML parsing library for Rust. toml is the de facto standard and is highly recommended.
• Consider how to map TOML data types to Rust types (e.g., TOML arrays to Vec<String>, TOML strings to String or Option<String>, TOML tables to HashMap or custom structs).
• Think about how to handle the edition defaulting.
• The [dependencies] section can be quite varied in real Cargo.toml files. For this challenge, focus on extracting just the version string from the dependency values. If the value is a simple string, that's the version. If it's a table like { version = "x.y.z", ... }, extract "x.y.z". You don't need to parse other keys within dependency tables (like features).