lists3 0.1.1

Light-weight CLI tool to create a file browser for S3 buckets provisioning bucket listing.
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
127
128
129
130

use std::env;
use std::process::exit;

use crate::squire::{constant, settings};

/// Parses and returns the command-line arguments.
///
/// # Returns
///
/// A String notion of the argument, `env_file` if present.
pub fn arguments(
    metadata: &constant::MetaData
) -> settings::Config {
    let args: Vec<String> = env::args().collect();

    let mut version = false;
    let mut bucket = String::new();
    let mut website = String::new();
    let mut region = String::new();
    let mut filter = String::new();
    let mut ignore = String::new();
    let mut object = String::new();
    let mut style = String::new();

    // Loop through the command-line arguments and parse them.
    let mut i = 1; // Start from the second argument (args[0] is the program name).
    while i < args.len() {
        match args[i].as_str() {
            "-h" | "--help" => {
                let options: Vec<_> = [("--bucket | -b", "Bucket name for which listing has to be created"),
                    ("--website | -w", "Website URL that has to be allowed through CORS configuration"),
                    ("--region | -r", "Region name where the bucket is present"),
                    ("--filter | -f", "S3 prefix to filter (eg: '[\"github/\"]')"),
                    ("--ignore | -i", "Objects to be ignored (eg: '[\"github/.DS_Store\"]')"),
                    ("--object | -o", "Object name to upload in s3 (eg: list.html)"),
                    ("--style | -s", "Styling for the UI (eg: vanilla)"),
                    ("--version | -v", "Get the package version.")].to_vec();
                let longest_key = options.iter().map(|(k, _)| k.len()).max().unwrap_or(0);
                let pretext = "\n* ";
                let choices: String = options.iter().map(|(k, v)| {
                    format!("{}{} {}→ {}", pretext, k, "·".repeat(longest_key - k.len() + 8), v)
                }).collect::<Vec<_>>().join("");
                println!("Usage: {} [OPTIONS]\n\nlists3 takes the following arguments\n{}", args[0], choices);
                exit(0)
            }
            "-V" | "-v" | "--version" => {
                version = true;
            }
            "-b" | "--bucket" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    bucket.clone_from(&args[i]);
                } else {
                    eprintln!("--bucket requires a value.");
                    exit(1)
                }
            }
            "-w" | "--website" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    website.clone_from(&args[i]);
                } else {
                    eprintln!("--bucket requires a value.");
                    exit(1)
                }
            }
            "-r" | "--region" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    region.clone_from(&args[i]);
                } else {
                    eprintln!("--region requires a value.");
                    exit(1)
                }
            }
            "-f" | "--filter" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    filter.clone_from(&args[i]);
                } else {
                    eprintln!("--filter requires a value.");
                    exit(1)
                }
            }
            "-i" | "--ignore" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    ignore.clone_from(&args[i]);
                } else {
                    eprintln!("--ignore requires a value.");
                    exit(1)
                }
            }
            "-o" | "--object" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    object.clone_from(&args[i]);
                } else {
                    eprintln!("--object requires a value.");
                    exit(1)
                }
            }
            "-s" | "--style" => {
                i += 1; // Move to the next argument.
                if i < args.len() {
                    style.clone_from(&args[i]);
                } else {
                    eprintln!("--style requires a value.");
                    exit(1)
                }
            }
            _ => {
                eprintln!("Unknown argument: {}", args[i]);
                exit(1)
            }
        }
        i += 1;
    }
    if version {
        println!("{} {}", &metadata.pkg_name, &metadata.pkg_version);
        exit(0)
    }
    if object.is_empty() {
        object = "list".to_string()
    }
    if website.is_empty() {
        website = format!("https://{}", bucket);
    }
    settings::parse_config(bucket, website, region, filter, ignore, object, style)
}