oneio 0.7.2

OneIO is a Rust library that provides unified simple IO interface for reading and writing to and from data files from different sources and compressions.
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
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::io::{BufRead, BufReader};
use std::path::PathBuf;
use clap::Parser;
use std::io::Write;

#[derive(Parser)]
#[clap(author, version, about, long_about = None)]
#[clap(propagate_version = true)]
struct Cli {
    /// file to open, remote or local
    #[clap(name = "FILE")]
    file: PathBuf,

    /// download the file to current directory, similar to run `wget`
    #[clap(short, long)]
    download: bool,

    /// output file path
    #[clap(short, long)]
    outfile: Option<PathBuf>,

    /// cache reading to specified directory
    #[clap(long)]
    cache_dir: Option<String>,

    /// force re-caching if local cache already exists
    #[clap(long)]
    cache_force: bool,

    /// specify cache file name
    #[clap(long)]
    cache_file: Option<String>,

    /// read through file and only print out stats
    #[clap(short, long)]
    stats: bool,
}

fn main() {
    let cli = Cli::parse();
    let path: &str = cli.file.to_str().unwrap();
    let outfile: Option<PathBuf> = cli.outfile;
    if cli.download {
        let out_path = match outfile {
            None => {
                // infer file path and download to current directory
                if !path.starts_with("http") {
                    eprintln!("{} is not a remote file, skip downloading", path);
                    return
                }
                path.split('/').last().unwrap().to_string()
            }
            Some(p) => {
                p.to_str().unwrap().to_string()
            }
        };

        match oneio::download(path, out_path.as_str(), None) {
            Ok(_) => {
                println!("file successfully downloaded to {}", out_path.as_str());
            }
            Err(e) => {
                eprintln!("file download error: {}", e);
            }
        }

        return
    }

    let reader = Box::new(
        BufReader::new(
            match cli.cache_dir {
                Some(dir) => {
                    match oneio::get_cache_reader(path, dir.as_str(), cli.cache_file, cli.cache_force) {
                        Ok(reader) => {reader}
                        Err(e) => {
                            eprintln!("cannot open {}: {}", path, e);
                            return
                        }
                    }
                }
                None => {
                    match oneio::get_reader(path) {
                        Ok(reader) => {reader}
                        Err(e) => {
                            eprintln!("cannot open {}: {}", path, e);
                            return
                        }
                    }
                }
            }
        )
    );


    let mut stdout = std::io::stdout();

    let mut count_lines = 0;
    let mut count_chars = 0;

    for line in reader.lines() {
        let line = match line {
            Ok(l) => {l}
            Err(e) => {
                eprintln!("cannot read line from {}: {}", path, e);
                return;
            }
        };
        if !cli.stats {
            if let Err(e) = writeln!(stdout, "{}", line) {
                if e.kind() != std::io::ErrorKind::BrokenPipe {
                    eprintln!("{}", e);
                    std::process::exit(1);
                }
                std::process::exit(0);
            }
        }
        count_chars += line.chars().count();
        count_lines += 1;
    }

    if cli.stats {
        println!("lines: \t {}", count_lines);
        println!("chars: \t {}", count_chars);
    }
}