version     = "0.0.3"

version     = "0.0.4"

thiserror = "1.0.23"
url       = "2.2.0"

thiserror = "1.0.24"
url       = "2.2.1"

nom   = { version = "6.0.1", optional = true }
paste = { version = "1.0.4", optional = true }

nom   = { version = "6.1.2", optional = true }
paste = { version = "1.0.5", optional = true }

## [0.0.3] - 2020-01-14

## [0.0.4] - 2021-04-15
### Added
- Expose both complete and streaming parsers.
### Changed
- Gemtext parsing doesn't preserve whitespace
## [0.0.3] - 2021-01-14

## [0.0.2] - 2020-01-14

## [0.0.2] - 2021-01-14

- [x] a `gemtext` module for representing `text/gemini` content
- [X] parsers using `nom`
- [ ] streaming response bodies
- [ ] `no_std` support
- [ ] improve doc comments with links n such

 - [X] a `gemtext` module for representing `text/gemini` content
 - [X] parsers using `nom`
 - [ ] streaming response bodies
 - [ ] no_std support
 - [ ] improve doc comments with links n such
 - [ ] lossless `gemtext` representation

    use nom::{bytes::complete::take, combinator::map_res, error::context, IResult};

    use nom::{bytes::streaming::take, combinator::map_res, error::context, IResult};

pub use request_type::{Any, Gemini};

        self.url.scheme() == Self::GEMINI_SCHEME

        self.scheme() == Self::GEMINI_SCHEME

    /// Return the scheme for the underlying url.
    pub fn scheme(&self) -> &str {
        self.url.scheme()
    }
    /// Return a reference to the underlying url.
    pub fn url(&self) -> &Url {
        &self.url
    }

impl GeminiRequest {
    /// Return the hostname associated with the Gemini request.
    pub fn host(&self) -> &str {
        self.url.host_str().unwrap()
    }
    /// Return the path portion of the Gemini request url.
    pub fn path(&self) -> &str {
        self.url.path()
    }
    /// Return the port associated with the Gemini request.
    pub fn port(&self) -> u16 {
        self.url.port().unwrap()
    }
}

        bytes::complete::{tag, take_until},

        bytes::streaming::{tag, take_until},

pub use request::{InvalidRequest, Request, Url};

pub use request::{AnyRequest, GeminiRequest, InvalidRequest, Request, Url};

/// Helper module with parsers for *COMPLETE* streams of bytes. If you want
/// streaming/resumable parsers, use the parser functions in each submodule
/// directly. Gemtext parsers only work with complete input.

mod parse {

pub mod parse {

    pub use nom::Err;

        /// Parse a `Header` from bytes.

        /// Parse a complete `Header` from bytes.

        /// Parse a `Request` from bytes.

        /// Parse a complete `Request` from bytes.

        /// Parse a `Response` from bytes.

        /// Parse a complete `Response` from bytes.

        /// Parse a `Status` from bytes.

        /// Parse a complete `Status` from bytes.

#[cfg(feature = "parsers")]
pub use parse::{parse_gemtext, parse_header, parse_request, parse_response, parse_status};

    /// Construct a new `Header` without checking the validity of the arguments.
    pub fn new_unchecked(status: Status, meta: String) -> Self {
        Header { status, meta }
    }

    pub fn success(mime_type: impl Into<String>) -> Option<Self> {
        Self::new(Status::SUCCESS, mime_type.into())

    pub fn success(mime_type: String) -> Option<Self> {
        Self::new(Status::SUCCESS, mime_type)

        bytes::complete::{tag, take_until},

        bytes::streaming::{tag, take_until},

                Header::success("text/json").unwrap()

                Header::success("text/json".to_string()).unwrap()

//!
//! NB: Parsing gemtext from strings won't necessarily preserve whitespace.

// TODO: track "trivia"? eg spacing between sigils and content, trailing whitespace

#[cfg(test)]
const DOCUMENT: &str = r#"
```logo
 wooo
/^^^^\
|    |
\____/
```

# GAZE INTO THE SPHERE!
critics are raving
> i love the sphere - bort
> the sphere gives me purpose - frelvin
* always
* trust
* the sphere
=> gemini://sphere.gaze gaze more here
"#;

        bytes::complete::{is_not, tag, take_until},
        character::complete::{line_ending, not_line_ending, space0, space1},

        bytes::complete::{tag, take_until},
        character::complete::{line_ending, not_line_ending},

        multi::many1,
        sequence::{pair, preceded, terminated, tuple},

        multi::separated_list0,
        sequence::{delimited, pair, preceded, terminated},

    fn line(input: &str) -> IResult<&str, &str> {
        terminated(not_line_ending, line_ending)(input)
    }

            map(line, |s: &str| {

            map(not_line_ending, |s: &str| {

            map(
                preceded(
                    pair(tag("=>"), space1),
                    terminated(
                        pair(is_not(" \t\r\n"), opt(preceded(space1, not_line_ending))),
                        line_ending,
                    ),
                ),
                |(to, name): (&str, Option<&str>)| Doc::Link {
                    to: to.to_string(),
                    name: name.map(|s| s.to_string()),
                },
            ),

            map(preceded(tag("=>"), not_line_ending), |s: &str| {
                let s = s.trim();
                let idx = s.chars().position(char::is_whitespace);
                let (to, name) = if let Some(idx) = idx {
                    let (to, name) = s.split_at(idx);
                    (to.to_string(), Some(name.trim().to_string()))
                } else {
                    (s.to_string(), None)
                };
                Doc::Link { to, name }
            }),

            value(Level::One, tag("#")),
            value(Level::Two, tag("##")),

            value(Level::Two, tag("##")),
            value(Level::One, tag("#")),

            map(
                terminated(
                    pair(terminated(level, space0), not_line_ending),
                    line_ending,
                ),
                |(lvl, s)| Doc::Heading(lvl, s.to_string()),
            ),

            map(pair(level, not_line_ending), |(lvl, s)| {
                Doc::Heading(lvl, s.trim().to_string())
            }),

            map(
                terminated(preceded(tag("* "), not_line_ending), line_ending),
                |s: &str| Doc::ListItem(s.to_string()),
            ),

            map(preceded(tag("* "), not_line_ending), |s: &str| {
                Doc::ListItem(s.trim().to_string())
            }),

            map(
                terminated(
                    preceded(terminated(tag(">"), space0), not_line_ending),
                    line_ending,
                ),
                |s: &str| Doc::Quote(s.to_string()),
            ),

            map(preceded(tag(">"), not_line_ending), |s: &str| {
                Doc::Quote(s.trim().to_string())
            }),

                        terminated(preceded(tag("```"), opt(not_line_ending)), line_ending),

                        delimited(tag("```"), opt(not_line_ending), line_ending),

                    tuple((line_ending, tag("```"), not_line_ending, line_ending)),

                    pair(line_ending, tag("```")),

                    alt: alt.map(|s| s.to_string()),

                    alt: alt.and_then(|s| {
                        let s = s.trim();
                        if s.is_empty() {
                            None
                        } else {
                            Some(s.to_string())
                        }
                    }),

    /// Parse a utf-8 encoded gemtext document.

    /// Parse a *complete* gemtext document from utf-8 encoded text.

                many1(alt((link, heading, list_item, quote, preformatted, text))),

                terminated(
                    separated_list0(
                        line_ending,
                        alt((link, heading, list_item, quote, preformatted, text)),
                    ),
                    opt(line_ending),
                ),

        trait Is {
            type Item;
            fn is(&self, other: Self::Item) -> bool;
        }
        impl<T: Eq, U, E> Is for Result<(U, T), E> {
            type Item = T;
            fn is(&self, other: Self::Item) -> bool {
                if let Ok((_, inner)) = self {
                    inner == &other
                } else {
                    false
                }
            }
        }
        macro_rules! assert_is {
            ($actual:expr, $expected:expr) => {
                assert!(
                    $actual.is($expected),
                    "\n\nexpected: {:#?}\n\nactual: {:#?}",
                    $expected,
                    $actual
                )
            };
        }
        #[test]
        fn test_text() {
            assert_is!(text("foo"), Doc::Text("foo".to_string()));
            assert_is!(text("\nfoo"), Doc::Blank);
        }

        fn test_link() {
            assert_is!(
                link("=> gemini://foo"),
                Doc::Link {
                    to: "gemini://foo".to_string(),
                    name: None
                }
            );
            assert_is!(
                link("=> gemini://foo bar"),
                Doc::Link {
                    to: "gemini://foo".to_string(),
                    name: Some("bar".to_string()),
                }
            );
            assert_is!(
                link("=>  gemini://foo    bar baz bax"),
                Doc::Link {
                    to: "gemini://foo".to_string(),
                    name: Some("bar baz bax".to_string())
                }
            );
            assert_is!(
                link("=>gemini://foo"),
                Doc::Link {
                    to: "gemini://foo".to_string(),
                    name: None
                }
            )
        }
        #[test]
        fn test_heading() {
            assert_is!(
                heading("# foo"),
                Doc::Heading(Level::One, "foo".to_string())
            );
            assert_is!(
                heading("##  bar"),
                Doc::Heading(Level::Two, "bar".to_string())
            );
            assert_is!(
                heading("###baz   "),
                Doc::Heading(Level::Three, "baz".to_string())
            )
        }
        #[test]
        fn test_list_item() {
            assert_is!(list_item("* foo"), Doc::ListItem("foo".to_string()));
            assert_is!(list_item("*  bar"), Doc::ListItem("bar".to_string()));
            assert!(list_item("*bad").is_err())
        }
        #[test]
        fn test_quote() {
            assert_is!(quote("> foo"), Doc::Quote("foo".to_string()));
            assert_is!(quote(">bar"), Doc::Quote("bar".to_string()));
        }
        #[test]
        fn test_preformatted() {
            assert_is!(
                preformatted("```\nfoo\n```"),
                Doc::Preformatted {
                    alt: None,
                    text: "foo".to_string()
                }
            );
            assert_is!(
                preformatted("```\n\nfoo\n> bar\n=> baz\n```\n"),
                Doc::Preformatted {
                    alt: None,
                    text: "\nfoo\n> bar\n=> baz".to_string()
                }
            );
            assert_is!(
                preformatted("```foo\nbar\n```"),
                Doc::Preformatted {
                    alt: Some("foo".to_string()),
                    text: "bar".to_string()
                }
            );
            assert_is!(
                preformatted("```   foo   \nbar\n```"),
                Doc::Preformatted {
                    alt: Some("foo".to_string()),
                    text: "bar".to_string()
                }
            );
            assert!(preformatted("```\n").is_err());
            assert!(preformatted("```\nfoo```").is_err());
        }
        #[test]

            assert_eq!(
                document(DOCUMENT).unwrap().1,

            assert_is!(
                document(DOCUMENT),

                    }

                    },
                    Doc::Blank

#[cfg(test)]
const DOCUMENT: &'static str = r#"
```logo
 wooo
/^^^^\
|    |
\____/
```
# GAZE INTO THE SPHERE!
critics are raving
> i love the sphere - bort
> the sphere gives me purpose - frelvin
* always
* trust
* the sphere
=> gemini://sphere.gaze gaze more here
"#;