bulk 0.4.9

A simple tool for making deb packages, repositories, and update version numbers. 
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
71
72
73
74
75

use std::io;
use std::io::{Write, Seek, SeekFrom};


pub const SIZE_AUTO: u64 = 9999999999;


pub struct ArArchive<T:Write+Seek>(T);

pub struct ArMember<'a, T:Write+Seek+'a> {
    position: u64,
    current_size: u64,
    defined_size: u64,
    archive: &'a mut ArArchive<T>,
}

impl<'a, T:Write+Seek+'a> Write for ArMember<'a, T> {
    fn write(&mut self, data: &[u8]) -> Result<usize, io::Error> {
        match self.archive.0.write(data) {
            Ok(x) => {
                self.current_size += x as u64;
                Ok(x)
            }
            Err(e) => Err(e),
        }
    }
    fn flush(&mut self) -> Result<(), io::Error> {
        self.archive.0.flush()
    }
}

impl<'a, T:Write+Seek+'a> Drop for ArMember<'a, T> {
    fn drop(&mut self) {
        if self.current_size != self.defined_size {
            // Since we had already written there, we assume that we can't
            // fail. Anyway crashing is probably okay in this case
            let cur_pos = self.archive.0.seek(SeekFrom::Current(0)).unwrap();
            self.archive.0.seek(SeekFrom::Start(self.position + 48)).unwrap();
            write!(self.archive.0,
                "{size:<10}", size=self.current_size).unwrap();
            self.archive.0.seek(SeekFrom::Start(cur_pos)).unwrap();
        }
        if self.current_size % 2 != 0 {
            self.archive.0.write(b"\n").unwrap();
        }
    }
}

impl<T:Write+Seek> ArArchive<T> {
    pub fn new(mut file: T) -> Result<ArArchive<T>, io::Error> {
        try!(file.write_all(b"!<arch>\n"));
        Ok(ArArchive(file))
    }
    pub fn add<'x>(&'x mut self, filename: &str,
        filemtime: u32, uid: u32, gid: u32,
        mode: u32, size: u64) -> Result<ArMember<'x, T>, io::Error>
    {
        assert!(filename.len() <= 16);
        assert!(uid <= 999999);
        assert!(gid <= 999999);
        assert!(mode <= 99999999);
        assert!(size <= 9999999999);
        let pos = try!(self.0.seek(SeekFrom::Current(0)));
        try!(write!(&mut self.0,
            "{name:<16}{mtime:<12}{uid:<6}{gid:<6}{mode:<8o}{size:<10}`\n",
            name=filename, mtime=filemtime, uid=uid, gid=gid, mode=mode,
            size=size));
        Ok(ArMember {
            position: pos,
            current_size: 0,
            defined_size: size,
            archive: self,
        })
    }
}