lesspub 1.0.2

CLI tool for downloading Sequences from LessWrong and exporting them as EPUB format ebooks
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 anyhow::anyhow;
use clap::Parser;
use reqwest::Url;
use std::{error::Error, path::PathBuf, str::FromStr};

/// Download and parse Lesswrong posts and sequences into epub files.
#[derive(Debug, Parser)]
pub enum Command {
    /// Download a specific post
    Post {
        #[command(flatten)]
        id_options: IdOptions,
        #[command(flatten)]
        options: CliOptions,
    },
    /// Download a specific sequence
    Sequence {
        #[command(flatten)]
        id_options: IdOptions,
        #[command(flatten)]
        options: CliOptions,
    },
    /// Download all sequences
    All {
        #[command(flatten)]
        options: CliOptions,
    },
}
impl Command {
    pub fn options(&self) -> CliOptions {
        match self {
            Command::Post { options, .. }
            | Command::Sequence { options, .. }
            | Command::All { options } => options.clone(),
        }
    }
}

#[derive(Debug, Clone, Parser)]
pub struct IdOptions {
    /// The URL at which the desired sequence or post can be found
    #[clap(long, short = 'u')]
    url: Option<String>,
    /// The ID of the desired sequence or post
    #[clap(long)]
    id: Option<String>,
}
#[derive(Debug, Clone)]
pub enum IdOrUrl {
    Url { url: String },
    Id { id: String },
}
impl From<IdOptions> for IdOrUrl {
    fn from(value: IdOptions) -> IdOrUrl {
        if let Some(id) = value.id {
            IdOrUrl::Id { id }
        } else {
            IdOrUrl::Url {
                url: value
                    .url
                    .ok_or(anyhow!("No ID or URL was specified"))
                    .unwrap(),
            }
        }
    }
}
impl IdOrUrl {
    pub fn get_id(self) -> Result<String, Box<dyn Error>> {
        Ok(match self {
            IdOrUrl::Id { id } => id,
            IdOrUrl::Url { url } => {
                let url = Url::from_str(&url)?;
                url.path_segments()
                    .ok_or(anyhow!("Failed to parse URL segments"))?
                    .nth(1)
                    .ok_or(anyhow!("Failed to find ID in URL"))?
                    .to_string()
            }
        })
    }
}

#[derive(Debug, Clone, Parser)]
pub struct CliOptions {
    /// Don't use the cache during this usage
    #[clap(long, short = 'i')]
    pub ignore_cache: bool,

    /// Delete the application's cache after use
    #[clap(long, short = 'd')]
    pub delete_cache: bool,

    /// The directory in which to output the resulting ebook file(s)
    #[clap(long, default_value = "./", short = 'o')]
    pub output_dir: PathBuf,

    /// The directory in which to store cached data for reuse
    #[clap(long, short = 'c')]
    pub cache_dir: Option<PathBuf>,
}
#[derive(Debug, Clone)]
pub struct ParsedCliOptions {
    pub ignore_cache: bool,
    pub delete_cache: bool,
    pub output_dir: PathBuf,
    pub cache_dir: PathBuf,
}
impl From<CliOptions> for ParsedCliOptions {
    fn from(value: CliOptions) -> Self {
        Self {
            ignore_cache: value.ignore_cache,
            delete_cache: value.delete_cache,
            output_dir: value.output_dir,
            cache_dir: value.cache_dir.unwrap_or(
                dirs::cache_dir()
                    .unwrap_or(PathBuf::from_str("./cache").unwrap())
                    .join("lesspub"),
            ),
        }
    }
}

pub struct CacheOptions {
    pub ignore_cache: bool,
    pub cache_dir: PathBuf,
}