synthzip 0.1.0

constructs synthetic Central Directories when missing from otherwise-valid ZIP data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# synthzip [![Latest Version]][crates.io]

[Latest Version]: https://img.shields.io/crates/v/synthzip.svg
[crates.io]: https://crates.io/crates/synthzip

## What is it?

A rust library for constructing a synthetic Central Directory when you have ZIP
data that has a Local File Header (LFH), but no Central Directory File Header (CDFH),
or End of Central Directory (EOCD) data.

This is a somewhat niche library. You probably won't need it (directly), unless
you happen to be doing something unusual. But if you are, it may be **exactly**
what you need to do that one weird thing.

## How do I obtain this majestic tool?

Run the following Cargo command in your project directory (assuming you have [cargo-edit](https://github.com/killercup/cargo-edit) installed):

```fish
cargo add synthzip
```

Or add the following line to your `Cargo.toml` (in the `[dependencies]` array):

```toml
synthzip = "^ 0.1"
```

## How do I use it?

```rust
fn main() {
  // This can be any source that implements Read + Seek, and reads a valid ZIP
  // Local File Header, compressed data, and (optional) trailing Data Descriptor.
  let mut input = std::io::Cursor::new(Vec::new());

  // read the data into an entry.
  let entry = synthzip::Entry::read(&mut input).expect("failed to read zip entry from input");

  // create a new (empty) CentralDirectory
  let mut index = synthzip::CentralDirectory::new();

  // add the Entry to the CentralDirectory. This will create a corresponding ZIP
  // Central Directory File Header and update the End of Central Directory appropriately.
  index.add(&entry)

  // this can be any destination that implements Write + Seek.
  let mut output = std::fs::File::create("/path/for/output.zip").expect("failed to create output file");

  // write the entry to the output destination.
  entry.write(&mut output).expect("failed to write zip entry to output");

  // write the Central Directory after the entry data.
  index.write(&mut output).expect("failed to write central directory to output");

  /// flush the output, if you're so inclined.
  output.flush().unwrap();
}
```

## License

`synthzip` is available under the MIT License. See `LICENSE.txt` for the full text.

While the license is short, it's still written in fancy lawyer-speak. If you
prefer more down-to-earth language, consider the following:

- tl;drLegal has a simple visual summary available [here](https://www.tldrlegal.com/license/mit-license).
- FOSSA has a more in-depth overview available [here](https://fossa.com/blog/open-source-licenses-101-mit-license/).