CandyCorvid/gemini - Change WGRFJRTEXOKY7PV536O62WUE32T24VQEHFQP67GEZZ67AE37ZWUAC

Add tests, rename Status to Header, implement redirect and proper input handling

Created by CandyCorvid on July 13, 2023

WGRFJRTEXOKY7PV536O62WUE32T24VQEHFQP67GEZZ67AE37ZWUAC

Dependencies

In channels

main

Change contents

Replacement in src/response.rs at line 3 [3.1605]
B:BD[3.1650] → [3.1650:1668]
```
pub enum Status {
```
[3.1650]
[3.1668]
```
pub enum Header {
```
Deletion in src/response.rs at line 5 [3.1605]
B:BD[3.1698] → [3.1698:1726]
```
    /// has a response body
```
Replacement in src/response.rs at line 143 [3.1605]
B:BD[3.5532] → [3.5532:5571]
```
impl TryFrom<raw::Header> for Status {
```
[3.5532]
[3.5571]
```
impl TryFrom<raw::Header> for Header {
```

Replacement in src/response.rs at line 150 [3.1605]

B:BD[3.5779] → [3.5779:6145]

            1 => Some(Status::Input((sub, meta).into())),
            2 => Some(Status::Success((sub, meta).into())),
            3 => Some(Status::Redirect((sub, meta).into())),
            4 => Some(Status::FailTemp((sub, meta).into())),
            5 => Some(Status::FailPerm((sub, meta).into())),
            6 => Some(Status::CertRequired((sub, meta).into())),

[3.5779]

[3.6145]

            1 => Some(Header::Input((sub, meta).into())),
            2 => Some(Header::Success((sub, meta).into())),
            3 => Some(Header::Redirect((sub, meta).into())),
            4 => Some(Header::FailTemp((sub, meta).into())),
            5 => Some(Header::FailPerm((sub, meta).into())),
            6 => Some(Header::CertRequired((sub, meta).into())),

File addition: media.rs (----------)

[4.15]

use std::str::pattern::Pattern;
use url::Url;
#[derive(Clone, Debug)]
pub enum Media<'a> {
    Gemini(Gemini<'a>),
    Text(&'a str),
}
impl<'a> Media<'a> {
    pub fn display(&self) {
        match self {
            Media::Gemini(g) => println!("{g:#?}"), // TODO
            Media::Text(s) => println!("{s}"),
        }
    }
}
#[derive(Clone, Debug)]
pub struct Gemini<'a> {
    // TODO include lang component
    lines: Vec<Line<'a>>,
}
#[derive(Clone, Debug)]
enum RawLine<'a> {
    Toggle { alt: TextLine<'a> },
    Line(Line<'a>),
}
#[derive(Clone, Debug)]
pub enum Line<'a> {
    Heading {
        level: u8,
        title: TextLine<'a>,
    },
    Link {
        url: TextLine<'a>,
        description: Option<TextLine<'a>>,
    },
    Text(TextLine<'a>),
    Preformatted(Preformat<'a>),
    ListItem(TextLine<'a>),
    Quote(TextLine<'a>),
}
#[derive(Clone, Debug)]
pub struct Preformat<'a> {
    alt: TextLine<'a>,
    lines: Vec<TextLine<'a>>,
}
fn split_trim_maybe_once<'a, P: Pattern<'a> + Copy>(
    s: &'a str,
    p: P,
) -> (&'a str, Option<&'a str>) {
    match s.split_once(p) {
        Some((s, rem)) => (s, Some(rem.trim_start_matches(p))),
        None => (s, None),
    }
}
fn string_to_preformat(string: TextLine<'_>) -> Option<TextLine<'_>> {
    let line = string.0;
    if line.starts_with("```") {
        // ignore anything after the lead chars on preformat lines
        return None;
    } else {
        // ignore any other formatting between preformat toggle lines
        return Some(string);
    }
}
fn string_to_line(string: TextLine<'_>) -> RawLine {
    let line = string.0;
    RawLine::Line({
        if line.starts_with("```") {
            // ignore anything after the lead chars on preformat lines
            return RawLine::Toggle {
                alt: TextLine(&line[3..]),
            };
        } else if line.starts_with("=> ") {
            let line = &line[3..];
            match line.split_once(' ') {
                Some((url, desc)) => {
                    let url = url.trim_start_matches(' ');
                    Line::Link {
                        url: TextLine(url),
                        description: Some(TextLine(desc)),
                    }
                }
                None => Line::Link {
                    url: TextLine(line),
                    description: None,
                },
            }
        } else if line.starts_with("* ") {
            Line::ListItem(TextLine(&line[2..]))
        } else if line.starts_with("# ") {
            Line::Heading {
                level: 1,
                title: TextLine(&line[2..]),
            }
        } else if line.starts_with("## ") {
            Line::Heading {
                level: 2,
                title: TextLine(&line[3..]),
            }
        } else if line.starts_with("### ") {
            Line::Heading {
                level: 3,
                title: TextLine(&line[4..]),
            }
        } else if line.starts_with(">") {
            Line::Quote(TextLine(&line[1..]))
        } else {
            Line::Text(string)
        }
    })
}
fn string_to_lines(value: &str) -> Vec<Line> {
    {
        let mut outer = vec![];
        let mut preformat_block: Option<Preformat> = None;
        let lines = value.lines().map(TextLine);
        for line in lines {
            if preformat_block.is_some() {
                match string_to_preformat(line) {
                    // if we hit a toggle line, switch preformatting mode
                    None => {
                        let Some(i) = preformat_block.take()
                            else {unreachable!("This is within the is_some arm of the if")};
                        outer.push(Line::Preformatted(i));
                    }
                    Some(p) => preformat_block.as_mut().unwrap().lines.push(p),
                }
            } else {
                match string_to_line(line) {
                    // if we hit a toggle line, switch preformatting mode
                    RawLine::Toggle { alt } => {
                        preformat_block = Some(Preformat { alt, lines: vec![] });
                    }
                    RawLine::Line(l) => outer.push(l),
                }
            }
        }
        outer
    }
}
// guaranteed to be only a single line
#[derive(Copy, Clone, Debug)]
pub struct TextLine<'a>(&'a str);
impl<'a> From<&'a str> for Gemini<'a> {
    fn from(value: &'a str) -> Self {
        Gemini {
            lines: string_to_lines(value),
        }
    }
}

Replacement in src/main.rs at line 9 [4.3665]

B:BD[4.3767] → [5.32:80]

    io::{BufReader, Result as ioResult, Write},

[4.3767]

[4.3807]

    io::{BufReader, Read, Result as ioResult, Write},

Insertion in src/main.rs at line 16 [4.3665]
[6.127]
[6.179]
```
mod media;
```
Deletion in src/main.rs at line 27 [4.3665]
∅:D[6.321] → [4.3859:3860]
B:BD[4.3859] → [4.3859:3860]

Insertion in src/main.rs at line 28 [4.3665]

[4.3924]


// TODO make tests using a fake connection to a local buffer

Replacement in src/main.rs at line 36 [4.3665]

B:BD[4.4103] → [4.4103:4121]

    run_url(url);

[4.4103]

[4.4121]

    let mut url: Url = url.parse().expect("Not a valid URL");
    while let Some(new_url) = run_url(url) {
        url = new_url;
    }

Replacement in src/main.rs at line 42 [4.3665]

B:BD[4.4124] → [3.6916:7019]

fn run_url(url: String) -> Option<Url> {
    let mut url: Url = url.parse().expect("Not a valid URL");

[4.4124]

[6.322]

fn run_url(url: Url) -> Option<Url> {
    // must make a new connection per request

Insertion in src/main.rs at line 50 [4.3665]
[4.4396]
[4.4396]
```
    handle_response_header(head, url, stream)
}
```

Insertion in src/main.rs at line 54 [4.3665]

[4.4397]

[3.7091]

fn handle_response_header(
    head: response::Header,
    mut url: Url,
    mut stream: impl Read,
) -> Option<Url> {

Replacement in src/main.rs at line 60 [4.3665]

B:BD[3.7108] → [3.7108:7148]

        response::Status::Input(s) => {

[3.7108]

[3.7148]

        response::Header::Input(s) => {

Replacement in src/main.rs at line 63 [4.3665]

B:BD[3.7231] → [3.7231:7408]

            let input = match sensitive {
                Some(true) => rpassword::read_password(),
                _ => std::io::stdin().lines().next().expect("End of input"),

[3.7231]

[3.7408]

            let input = if let Some(true) = sensitive {
                // Read sensitive input
                rpassword::read_password()
            } else {
                // Read plain input
                std::io::stdin().lines().next().expect("End of input")

Replacement in src/main.rs at line 75 [4.3665]

B:BD[3.7593] → [3.7593:7635]

        response::Status::Success(s) => {

[3.7593]

[3.7635]

        response::Header::Success(s) => {

Replacement in src/main.rs at line 78 [4.3665]
∅:D[5.156] → [3.7761:7803]
B:BD[3.7761] → [3.7761:7803]
```
            // TODO use mime for anything
```
[5.156]
[3.7803]
```
            //TODO remove this debug output
```

Replacement in src/main.rs at line 85 [4.3665]

B:BD[3.7915] → [3.7915:7958]

        response::Status::Redirect(s) => {

[3.7915]

[3.7958]

        response::Header::Redirect(s) => {

Replacement in src/main.rs at line 95 [4.3665]

B:BD[3.8338] → [3.8338:8381]

        response::Status::FailTemp(s) => {

[3.8338]

[3.8381]

        response::Header::FailTemp(s) => {

Replacement in src/main.rs at line 101 [4.3665]

B:BD[3.8570] → [3.8570:8613]

        response::Status::FailPerm(s) => {

[3.8570]

[3.8613]

        response::Header::FailPerm(s) => {

Replacement in src/main.rs at line 107 [4.3665]

B:BD[3.8784] → [3.8784:8831]

        response::Status::CertRequired(s) => {

[3.8784]

[3.8831]

        response::Header::CertRequired(s) => {

Deletion in src/main.rs at line 125 [4.3665]

∅:D[7.512] → [4.4501:4504]

∅:D[3.9015] → [4.4501:4504]

B:BD[4.4501] → [4.4501:4504]

B:BD[4.4504] → [8.212:1018]

B:BD[8.1018] → [2.48:79]

∅:D[2.79] → [8.1040:1126]

B:BD[8.1040] → [8.1040:1126]

B:BD[8.1126] → [2.80:117]

∅:D[2.117] → [8.1162:1223]

B:BD[8.1162] → [8.1162:1223]

B:BD[8.1223] → [2.118:244]

∅:D[2.244] → [7.663:669]

∅:D[8.1223] → [7.663:669]

B:BD[7.663] → [7.663:669]

B:BD[7.669] → [8.1224:1484]

∅:D[8.1484] → [7.825:835]

B:BD[7.825] → [7.825:835]

B:BD[7.835] → [8.1485:1491]

B:BD[8.1491] → [2.245:679]

∅:D[2.679] → [8.1565:1618]

B:BD[8.1565] → [8.1565:1618]

B:BD[8.1618] → [2.680:721]

∅:D[2.721] → [8.1643:1718]

B:BD[8.1643] → [8.1643:1718]

B:BD[8.1718] → [2.722:1215]

∅:D[2.1215] → [8.2469:2495]

B:BD[8.2469] → [8.2469:2495]

B:BD[8.2688] → [8.2688:2710]

B:BD[8.2710] → [2.1216:1368]

∅:D[2.1368] → [8.2710:2728]

B:BD[8.2710] → [8.2710:2728]

B:BD[8.2728] → [2.1369:1548]

∅:D[2.1548] → [8.2830:2909]

B:BD[8.2830] → [8.2830:2909]

B:BD[8.2909] → [2.1549:1647]

∅:D[2.1647] → [8.2969:3048]

B:BD[8.2969] → [8.2969:3048]

B:BD[8.3048] → [2.1648:1747]

∅:D[2.1747] → [8.3109:3188]

B:BD[8.3109] → [8.3109:3188]

B:BD[8.3188] → [2.1748:1918]

∅:D[2.1918] → [8.3307:3389]

B:BD[8.3307] → [8.3307:3389]

B:BD[8.3389] → [2.1919:3059]

∅:D[2.3059] → [8.3806:3828]

B:BD[8.3806] → [8.3806:3828]

B:BD[8.3926] → [8.3926:3944]

B:BD[8.3944] → [2.3060:3102]

∅:D[2.3102] → [8.3982:4282]

B:BD[8.3982] → [8.3982:4282]

∅:D[8.4282] → [7.851:857]

B:BD[7.851] → [7.851:857]

}
mod media {
    use std::str::pattern::Pattern;
    use url::Url;
    #[derive(Clone, Debug)]
    pub enum Media<'a> {
        Gemini(Gemini<'a>),
        Text(&'a str),
    }
    impl<'a> Media<'a> {
        pub fn display(&self) {
            match self {
                Media::Gemini(g) => println!("{g:#?}"), // TODO
                Media::Text(s) => println!("{s}"),
            }
        }
    }
    #[derive(Clone, Debug)]
    pub struct Gemini<'a> {
        // TODO include lang component
        lines: Vec<Line<'a>>,
    }
    #[derive(Clone, Debug)]
    enum RawLine<'a> {
        Toggle { alt: TextLine<'a> },
        Line(Line<'a>),
    }
    #[derive(Clone, Debug)]
    pub enum Line<'a> {
        Heading {
            level: u8,
            title: TextLine<'a>,
        },
        Link {
            url: TextLine<'a>,
            description: Option<TextLine<'a>>,
        },
        Text(TextLine<'a>),
        Preformatted(Preformat<'a>),
        ListItem(TextLine<'a>),
        Quote(TextLine<'a>),
    }
    #[derive(Clone, Debug)]
    pub struct Preformat<'a> {
        alt: TextLine<'a>,
        lines: Vec<TextLine<'a>>,
    }
    fn split_trim_maybe_once<'a, P: Pattern<'a> + Copy>(
        s: &'a str,
        p: P,
    ) -> (&'a str, Option<&'a str>) {
        match s.split_once(p) {
            Some((s, rem)) => (s, Some(rem.trim_start_matches(p))),
            None => (s, None),
        }
    }
    fn string_to_preformat(string: TextLine<'_>) -> Option<TextLine<'_>> {
        let line = string.0;
        if line.starts_with("```") {
            // ignore anything after the lead chars on preformat lines
            return None;
        } else {
            // ignore any other formatting between preformat toggle lines
            return Some(string);
        }
    }
    fn string_to_line(string: TextLine<'_>) -> RawLine {
        let line = string.0;
        RawLine::Line({
            if line.starts_with("```") {
                // ignore anything after the lead chars on preformat lines
                return RawLine::Toggle {
                    alt: TextLine(&line[3..]),
                };
            } else if line.starts_with("=> ") {
                let line = &line[3..];
                match line.split_once(' ') {
                    Some((url, desc)) => {
                        let url = url.trim_start_matches(' ');
                        Line::Link {
                            url: TextLine(url),
                            description: Some(TextLine(desc)),
                        }
                    }
                    None => Line::Link {
                        url: TextLine(line),
                        description: None,
                    },
                }
            } else if line.starts_with("* ") {
                Line::ListItem(TextLine(&line[2..]))
            } else if line.starts_with("# ") {
                Line::Heading {
                    level: 1,
                    title: TextLine(&line[2..]),
                }
            } else if line.starts_with("## ") {
                Line::Heading {
                    level: 2,
                    title: TextLine(&line[3..]),
                }
            } else if line.starts_with("### ") {
                Line::Heading {
                    level: 3,
                    title: TextLine(&line[4..]),
                }
            } else if line.starts_with(">") {
                Line::Quote(TextLine(&line[1..]))
            } else {
                Line::Text(string)
            }
        })
    }
    fn string_to_lines(value: &str) -> Vec<Line> {
        {
            let mut outer = vec![];
            let mut preformat_block: Option<Preformat> = None;
            let lines = value.lines().map(TextLine);
            for line in lines {
                if preformat_block.is_some() {
                    match string_to_preformat(line) {
                        // if we hit a toggle line, switch preformatting mode
                        None => {
                            let Some(i) = preformat_block.take()
                                else {unreachable!("This is within the is_some arm of the if")};
                            outer.push(Line::Preformatted(i));
                        }
                        Some(p) => preformat_block.as_mut().unwrap().lines.push(p),
                    }
                } else {
                    match string_to_line(line) {
                        // if we hit a toggle line, switch preformatting mode
                        RawLine::Toggle { alt } => {
                            preformat_block = Some(Preformat { alt, lines: vec![] });
                        }
                        RawLine::Line(l) => outer.push(l),
                    }
                }
            }
            outer
        }
    }
    // guaranteed to be only a single line
    #[derive(Copy, Clone, Debug)]
    pub struct TextLine<'a>(&'a str);
    impl<'a> From<&'a str> for Gemini<'a> {
        fn from(value: &'a str) -> Self {
            Gemini {
                lines: string_to_lines(value),
            }
        }
    }

Replacement in src/main.rs at line 127 [4.3665]

∅:D[7.860] → [6.448:525]

B:BD[6.448] → [6.448:525]

fn read_response_header(stream: &mut Stream) -> ioResult<response::Status> {

[7.860]

[5.157]

fn read_response_header(stream: &mut Stream) -> ioResult<response::Header> {

Insertion in src/main.rs at line 159 [4.3665]

[4.5853]


#[cfg(test)]
mod tests {
    use url::Url;
    use super::{
        handle_response_header,
        response::{header, Header},
    };
    #[test]
    fn handle_redirect_none() {
        handle_redirect("http://url.com".parse().unwrap(), None);
    }
    #[test]
    fn handle_redirect_perm() {
        handle_redirect("http://url.com".parse().unwrap(), Some(false));
    }
    #[test]
    fn handle_redirect_temp() {
        handle_redirect("http://url.com".parse().unwrap(), Some(true));
    }
    fn handle_redirect(expect_url: Url, temp: Option<bool>) {
        let head = Header::Redirect(header::Redirect {
            url: expect_url.clone(),
            temporary: temp,
        });
        let url = "gopher://abc.de".parse().unwrap();
        let mut stream: &[u8] = b"";
        let Some(url) = handle_response_header(head, url, &mut stream)
        else {panic!("expected redirect handling to return a url")};
        assert_eq!(url, expect_url);
    }
}