>
Looking for the Typescript Version? It's been moved here...
apt-parser is a library for parsing APT list files.
An APT repository normally consists of a Release file, Packages file, and compressed binary packages.
The library is able to parse these files and return them as serde serialized structs.
Make sure you have a modern version of Rust (1.56+) using rustup.
Then, add the following to your Cargo.toml:
```toml [dependencies]
apt-parser = "1.0.0" ```
Release files are the main entry point for an APT repository.
The Release struct has strict types for all documented fields in the Release file.
If you need to access a field that isn't defined, you can use the get method.
Here's a simple example:
```rust use apt_parser::Release; use surf::get;
let data = get("http://archive.ubuntu.com/ubuntu/dists/jammy/Release") .await? .body_string() .await?;
let release = match Release::from(data) { Ok(release) => release, Err(err) => panic!("Failed to parse Release file: {}", err), }
asserteq!(release.origin, "Ubuntu"); asserteq!(release.version, "22.04"); assert_eq!(release.get("InvalidKey"), None); ```
```rust
struct Release {
architectures: Vec
fn from(data: &str) -> Result<Self, APTError>; // => Parse a Release file
fn get(&self, key: &str) -> Option<&str>; // => Retrieve a raw field value
}
// A struct for holding the hash information for a Release file struct ReleaseHash { filename: String, hash: String, size: u64, } ```
Control files are used to describe the contents of a binary package.
The Control struct has strict types for all documented fields in the control file.
If you need to access a field that isn't defined, you can use the get method.
Here's a simple example:
```rust use apt_parser::Control;
let data = " Package: com.amywhile.signalreborn Architecture: iphoneos-arm Description: Visualise your nearby cell towers Depends: firmware (>= 12.2) | org.swift.libswift Maintainer: Amy While support@anamy.gay Section: Applications Version: 2.2.1-2 Installed-Size: 1536 Custom-Key: cool-value ";
let control = match Control::from(data) { Ok(control) => control, Err(err) => panic!("Failed to parse Control file: {}", err), }
asserteq!(control.version, "2.2.1-2"); asserteq!(control.package, "com.amywhile.signalreborn"); asserteq!(control.get("Custom-Key"), Some("cool-value")); asserteq!(control.get("Invalid-Key"), None); ```
```rust
struct Control {
package: String, // => Package
source: Option
fn from(data: &str) -> Result<Self, APTError>; // => Parse a Control file
fn get(&self, key: &str) -> Option<&str>; // => Retrieve a raw field value
} ```
Packages files are used to describe the contents of a repository.
The Packages struct implements an iterator and has methods for accessing the packages.
The Package struct has strict types for all documented fields in the Packages file.
If you need to access a field that isn't defined, you can use the get method.
Here's a simple example:
```rust use apt_parser::Packages; use surf::get;
let data = get("https://repo.chariz.com/Packages") .await? .body_string() .await?;
let packages = match Packages::from(&data) { Ok(packages) => packages, Err(err) => panic!("Failed to parse Packages file: {}", err), }
assert_eq!(packages.len(), 419);
for package in packages { println!("{}: {}", package.package, package.version); } ```
```rust
struct Packages {
packages: Vec
fn from(data: &str) -> Result<Self, APTError>; // => Parse a Packages file
fn len(&self) -> usize; // => Get the number of packages
}
impl Iterator for Packages; impl Index for Packages;
struct Package {
package: String, // => Package
source: Option
fn get(&self, key: &str) -> Option<&str>; // => Retrieve a raw field value
} ```
Copyright (c) 2023 Aarnav Tale