core-utils 0.1.2

A reimplementation of the GNU core utils in the Rust programming language
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// Copyright (C) 2015, Alberto Corona <ac@albertocorona.com>
// All rights reserved. This file is part of core-utils, distributed under the
// GPL v3 license. For full terms please see the LICENSE file.

#![crate_type = "bin"]
#![crate_name = "cat"]

static UTIL: Prog = Prog { name: "cat", vers: "0.1.0", yr: "2015" };
static SM_BUFF_SIZE: usize = 256;
static LRG_BUFF_SIZE: usize = 64 * 1024;

extern crate pgetopts;
extern crate rpf;

use pgetopts::{Options};
use rpf::{Status,Styled,Prog};

use std::env;
use std::iter;
use std::io::{self,Read, Write};
use std::path::{Path};
use std::fs::{File};

fn write_bytes(mut file: File) {
    let mut out = &mut io::stdout();
    let buffer = &mut vec![0; SM_BUFF_SIZE];
    loop {
        let read = match file.read(buffer) {
            Ok(c) => { c },
            Err(e) => {
                Status::Error.err(UTIL.name, e.to_string());
                panic!();
            }
        };
        if read == 0 {
            break;
        }
        match out.write_all(&buffer[..read]) {
            Ok(w) => { w },
            Err(e) => {
                Status::Error.err(UTIL.name, e.to_string());
                panic!();
            }
        };
        if read == buffer.len() && read < LRG_BUFF_SIZE {
            buffer.extend(iter::repeat(0).take(read));
        }
    }
}

fn read_files<P: AsRef<Path>>(files: Vec<P>) {
    for item in files {
        let file = match File::open(&item) {
            Ok(f) => { f },
            Err(e) => {
                Status::Error.err(UTIL.name, e.to_string());
                panic!();
            }
        };
        write_bytes(file);
    }
}

fn print_usage(opts: Options) {
    print!("{}: {} {}... {}...\n\
    Concatenate FILE(s) to standard output", "Usage".bold(), UTIL.name.bold(),
    "[OPTION]".underline(), "FILE".underline());
    println!("{}", opts.options());
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let mut opts = Options::new();

    opts.optflag("h", "help", "Print help information");
    opts.optflag("", "version", "Print version information");

    let matches = match opts.parse(&args[1..]) {
        Ok(m) => { m }
        Err(f) => {
            Status::Error.err(UTIL.name, f.to_string());
            panic!(f)
        }
    };
    if matches.opt_present("h") {
        print_usage(opts);
    } else if matches.opt_present("version") {
        UTIL.copyright("Copyright (C) 2015 core-utils developers\n\
                       License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.\n\
                       This is free software: you are free to change and redistribute it.\n\
                       There is NO WARRANTY, to the extent permitted by law.\n\n",
                       vec!["Alberto Corona"]);
    } else {
        read_files(matches.free);
    }
}