@browsersync/bslive 0.0.7 → 0.0.13

package/crates/bsnext_input/src/lib.rs

@@ -0,0 +1,153 @@
+use crate::target::TargetKind;
+
+use std::fmt::{Display, Formatter};
+use std::fs;
+use std::fs::read_to_string;
+use std::net::AddrParseError;
+use std::path::{Path, PathBuf};
+
+#[cfg(test)]
+pub mod input_test;
+pub mod md;
+pub mod paths;
+pub mod route;
+pub mod route_manifest;
+pub mod server_config;
+pub mod target;
+#[cfg(test)]
+pub mod watch_opt_test;
+pub mod yml;
+
+#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
+pub struct Input {
+    pub servers: Vec<server_config::ServerConfig>,
+}
+
+impl Input {
+    pub fn from_input_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        match path.as_ref().extension().and_then(|x| x.to_str()) {
+            None => Err(anyhow::anyhow!(
+                "paths without extensions are not supported"
+            )),
+            Some("yml") | Some("yaml") => Input::from_yaml_path(path),
+            Some("md") | Some("markdown") => Input::from_md_path(path),
+            _ => Err(anyhow::anyhow!("unsupported extension")),
+        }
+    }
+    fn from_yaml_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        let str = read_to_string(path)?;
+        let output = serde_yaml::from_str::<Self>(str.as_str())?;
+        // todo: don't allow duplicates.
+        Ok(output)
+    }
+    fn from_md_path<P: AsRef<Path>>(path: P) -> Result<Self, anyhow::Error> {
+        let str = read_to_string(path)?;
+        let input = md::md_to_input(&str)?;
+        // todo: don't allow duplicates.
+        Ok(input)
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum InputError {
+    #[error("no suitable inputs could be found")]
+    MissingInputs,
+    #[error("could not read input, error: {0}")]
+    InvalidInput(String),
+    #[error("Could not find the input file: {0}")]
+    NotFound(PathBuf),
+    #[error("InputWriteError prevented startup {0}")]
+    InputWriteError(#[from] InputWriteError),
+    #[error("Input path error prevented startup {0}")]
+    PathError(#[from] PathError),
+    #[error("Input port error prevented startup {0}")]
+    PortError(#[from] PortError),
+    #[error("Input directory error prevented startup {0}")]
+    DirError(#[from] DirError),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum WatchError {
+    #[error("don't add `.` before the extension.")]
+    InvalidExtensionFilter,
+    #[error("empty")]
+    EmptyExtensionFilter,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum InputWriteError {
+    #[error("couldn't write input to {path}")]
+    FailedWrite { path: PathBuf },
+}
+
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+pub enum PathError {
+    #[error("path(s) not found \n{paths}")]
+    MissingPaths { paths: PathDefs },
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub enum PortError {
+    #[error("could not use that port: {port} {err}")]
+    InvalidPort { port: u16, err: AddrParseError },
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub enum DirError {
+    #[error("could not create that dir: {path}")]
+    CannotCreate { path: PathBuf },
+    #[error("could not change the process CWD to: {path}")]
+    CannotMove { path: PathBuf },
+}
+
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+pub struct PathDefs(Vec<PathDefinition>);
+
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+struct PathDefinition {
+    pub input: String,
+    pub cwd: PathBuf,
+    pub absolute: PathBuf,
+}
+
+impl Display for PathDefs {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        for pd in self.0.iter() {
+            writeln!(f, "  cwd:   {}", pd.cwd.display())?;
+            writeln!(f, "  input: {}", pd.input)?;
+        }
+        Ok(())
+    }
+}
+impl Display for PathDefinition {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PathDefinition").finish()
+    }
+}
+
+pub fn rand_word() -> String {
+    random_word::gen(random_word::Lang::En).to_string()
+}
+
+pub fn fs_write_input(
+    cwd: &Path,
+    input: &Input,
+    target_kind: TargetKind,
+) -> Result<PathBuf, InputWriteError> {
+    let string = match target_kind {
+        TargetKind::Yaml => serde_yaml::to_string(&input).expect("create yaml?"),
+        TargetKind::Toml => toml::to_string_pretty(&input).expect("create toml?"),
+        TargetKind::Md => md::input_to_str(input),
+    };
+    let name = match target_kind {
+        TargetKind::Yaml => "input.yml",
+        TargetKind::Toml => "input.toml",
+        TargetKind::Md => "input.md",
+    };
+    let next_path = cwd.join(name);
+    fs::write(&next_path, string)
+        .map(|()| next_path.clone())
+        .map_err(|_e| InputWriteError::FailedWrite { path: next_path })
+}

package/crates/bsnext_input/src/md.rs

@@ -0,0 +1,541 @@
+use crate::route::{Route, RouteKind};
+use crate::server_config::ServerConfig;
+use crate::Input;
+
+use markdown::mdast::Node;
+use markdown::{Constructs, ParseOptions};
+use mime_guess::get_mime_extensions_str;
+use nom::branch::alt;
+use nom::combinator::map;
+use nom::multi::many0;
+use nom::sequence::separated_pair;
+use nom::{error::ParseError, IResult};
+use serde_json::json;
+use std::cmp::PartialEq;
+
+fn parser_for(k: BsLiveKinds) -> impl Fn(&[Node]) -> IResult<&[Node], &Node> {
+    move |input: &[Node]| {
+        if input.is_empty() || input[0].kind() != k {
+            Err(nom::Err::Error(ParseError::from_error_kind(
+                input,
+                nom::error::ErrorKind::Tag,
+            )))
+        } else {
+            Ok((&input[1..], &input[0]))
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, PartialOrd)]
+pub enum BsLiveKinds {
+    Input,
+    Route,
+    Body,
+    Ignored,
+}
+
+trait BsLive {
+    fn kind(&self) -> BsLiveKinds;
+    fn is_input(&self) -> bool;
+    fn is_route(&self) -> bool;
+    fn is_body(&self) -> bool;
+    fn raw_value(&self) -> Option<String>;
+}
+
+impl TryInto<Input> for &Node {
+    type Error = anyhow::Error;
+
+    fn try_into(self) -> Result<Input, Self::Error> {
+        if !self.is_input() {
+            return Err(anyhow::anyhow!("not an input type"));
+        }
+        match self {
+            Node::Code(code) => {
+                let config: Input = serde_yaml::from_str(&code.value)?;
+                Ok(config)
+            }
+            Node::Yaml(yaml) => {
+                let config: Input = serde_yaml::from_str(&yaml.value)?;
+                Ok(config)
+            }
+            _ => Err(anyhow::anyhow!("unreachable")),
+        }
+    }
+}
+
+impl TryInto<Input> for Vec<Node> {
+    type Error = anyhow::Error;
+    fn try_into(self) -> Result<Input, Self::Error> {
+        nodes_to_input(&self)
+    }
+}
+
+impl TryInto<Route> for (&Node, &Node) {
+    type Error = anyhow::Error;
+
+    fn try_into(self) -> Result<Route, Self::Error> {
+        match (self.0.is_route(), self.1.is_body()) {
+            (true, true) => match self.0 {
+                Node::Code(code)
+                    if code
+                        .lang
+                        .as_ref()
+                        .is_some_and(|l| l == "yaml" || l == "yml") =>
+                {
+                    #[derive(serde::Deserialize)]
+                    struct PathOnly {
+                        path: String,
+                    }
+                    let r: PathOnly = serde_yaml::from_str(&code.value)?;
+                    let route_kind = route_kind_from_body_node(self.1)?;
+                    let route = Route {
+                        path: r.path,
+                        kind: route_kind,
+                        ..Default::default()
+                    };
+                    Ok(route)
+                }
+                _ => Err(anyhow::anyhow!("unreachlable")),
+            },
+            _ => Err(anyhow::anyhow!("cannot create")),
+        }
+    }
+}
+
+fn route_kind_from_body_node(node: &Node) -> anyhow::Result<RouteKind> {
+    match node {
+        Node::Code(code) => {
+            let value = code.value.clone();
+            let rk = match code.lang.as_deref() {
+                Some("html") => RouteKind::Html { html: value },
+                Some("json") => RouteKind::Json {
+                    json: serde_json::from_str(&value)?,
+                },
+                Some("sse") => RouteKind::Sse { sse: value },
+                Some(..) | None => RouteKind::Raw { raw: value },
+            };
+            Ok(rk)
+        }
+        _ => Err(anyhow::anyhow!("unsupported route kind")),
+    }
+}
+
+impl BsLive for Node {
+    fn kind(&self) -> BsLiveKinds {
+        if self.is_input() {
+            return BsLiveKinds::Input;
+        }
+        if self.is_route() {
+            return BsLiveKinds::Route;
+        }
+        if self.is_body() {
+            return BsLiveKinds::Body;
+        }
+        BsLiveKinds::Ignored
+    }
+    fn is_input(&self) -> bool {
+        match self {
+            // this is from front matter
+            Node::Yaml(_yaml) => true,
+            // code block with annotations
+            Node::Code(code) => code
+                .meta
+                .as_ref()
+                .is_some_and(|v| v.contains("bslive_input")),
+            _ => false,
+        }
+    }
+
+    fn is_route(&self) -> bool {
+        match self {
+            Node::Code(code) => code
+                .meta
+                .as_ref()
+                .is_some_and(|v| v.contains("bslive_route")),
+            _ => false,
+        }
+    }
+
+    fn is_body(&self) -> bool {
+        if self.is_input() || self.is_route() {
+            return false;
+        }
+        matches!(self, Node::Code(..))
+    }
+
+    fn raw_value(&self) -> Option<String> {
+        if self.is_body() {
+            let Node::Code(code) = self else {
+                unreachable!("shouldnt get here");
+            };
+            Some(code.value.clone())
+        } else {
+            None
+        }
+    }
+}
+
+enum Convert {
+    None,
+    Input(Input),
+    Route(Route),
+}
+
+pub fn nodes_to_input(nodes: &[Node]) -> Result<Input, anyhow::Error> {
+    let mut routes = vec![];
+    let mut server_config: Option<Input> = None;
+    let mut parser = many0(alt((
+        map(parser_for(BsLiveKinds::Ignored), |_v| Convert::None),
+        map(parser_for(BsLiveKinds::Input), |v: &Node| {
+            let as_config: Result<Input, _> = v.try_into();
+            match as_config {
+                Ok(config) => Convert::Input(config),
+                Err(e) => unreachable!("? creating server config {:?}", e),
+            }
+        }),
+        map(
+            separated_pair(
+                parser_for(BsLiveKinds::Route),
+                many0(parser_for(BsLiveKinds::Ignored)),
+                parser_for(BsLiveKinds::Body),
+            ),
+            |pair| {
+                let as_route: Result<Route, _> = pair.try_into();
+                match as_route {
+                    Ok(route) => Convert::Route(route),
+                    Err(e) => unreachable!("? {:?}", e),
+                }
+            },
+        ),
+    )));
+
+    let results = parser(nodes);
+
+    match results {
+        Ok((_rest, matched)) => {
+            for item in matched {
+                match item {
+                    Convert::None => {}
+                    Convert::Input(input_from_md) => {
+                        // todo: handle server config
+                        if server_config.is_none() {
+                            server_config = Some(input_from_md)
+                        } else {
+                            unreachable!("todo: support multiple 'input' blocks")
+                        }
+                    }
+                    Convert::Route(route) => {
+                        routes.push(route);
+                    }
+                }
+            }
+        }
+        Err(e) => return Err(anyhow::anyhow!(e.to_string())),
+    }
+
+    match server_config.take() {
+        // config was not set, use default
+        None => {
+            let mut input = Input::default();
+            let server = ServerConfig {
+                routes,
+                ..Default::default()
+            };
+            input.servers.push(server);
+            Ok(input)
+        }
+        // got some server config, use it.
+        Some(mut input) => {
+            if let Some(server) = input.servers.first_mut() {
+                server.routes.extend(routes)
+            }
+            Ok(input)
+        }
+    }
+}
+
+pub fn str_to_nodes(input: &str) -> Result<Vec<Node>, anyhow::Error> {
+    let opts = ParseOptions {
+        constructs: Constructs {
+            frontmatter: true,
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let root = markdown::to_mdast(input, &opts).map_err(|e| anyhow::anyhow!(e))?;
+    match root {
+        Node::Root(root) => Ok(root.children),
+        _ => {
+            unreachable!("?");
+        }
+    }
+}
+
+pub fn md_to_input(input: &str) -> Result<Input, anyhow::Error> {
+    let root = str_to_nodes(input)?;
+    nodes_to_input(&root)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::server_config::Identity;
+
+    #[test]
+    fn test_single() -> anyhow::Result<()> {
+        // let input = include_str!("../../examples/md-single/md-single.md");
+        let input = r#"
+
+# Demo 2
+
+```yaml bslive_route
+path: /app.css
+```
+
+```css
+body {
+    background: blue
+}
+```
+        "#;
+        let config = md_to_input(&input).expect("unwrap");
+        let server_1 = config.servers.first().unwrap();
+        assert_eq!(
+            server_1.routes[0],
+            Route {
+                path: "/app.css".into(),
+                kind: RouteKind::Raw {
+                    raw: "body {\n    background: blue\n}".into(),
+                },
+                ..Default::default()
+            }
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_2_consecutive() -> anyhow::Result<()> {
+        // let input = include_str!("../../examples/md-single/md-single.md");
+        let input = r#"
+
+```yaml bslive_route
+path: /app.css
+```
+
+```css
+body {
+    background: blue
+}
+```
+
+Some other text
+
+```yaml bslive_route
+path: /app2.css
+```
+
+```css
+body {
+    background: blue
+}
+```
+        "#;
+        let config = md_to_input(&input).expect("unwrap");
+        let server_1 = config.servers.first().unwrap();
+        assert_eq!(
+            server_1.routes[0],
+            Route {
+                path: "/app.css".into(),
+                kind: RouteKind::Raw {
+                    raw: "body {\n    background: blue\n}".into(),
+                },
+                ..Default::default()
+            }
+        );
+        assert_eq!(
+            server_1.routes[1],
+            Route {
+                path: "/app2.css".into(),
+                kind: RouteKind::Raw {
+                    raw: "body {\n    background: blue\n}".into(),
+                },
+                ..Default::default()
+            }
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_parse_with_elements_in_gaps() -> anyhow::Result<()> {
+        let input = r#"
+# Before
+
+```yaml bslive_input
+servers:
+  - bind_address: 0.0.0.0:3001
+    routes:
+        - path: /health
+          raw: OK
+```
+
+```yaml bslive_route
+path: /
+```
+
+in between?
+
+```html
+<p>hello world</p>
+```
+
+```yaml bslive_route
+path: /abc
+```
+```html
+<p>hello world 2</p>
+```
+
+# Before
+        "#;
+        let config = md_to_input(&input).expect("unwrap");
+        let server_1 = config.servers.first().unwrap();
+        let expected_id = Identity::Address {
+            bind_address: "0.0.0.0:3001".into(),
+        };
+        assert_eq!(server_1.identity, expected_id);
+        assert_eq!(server_1.routes.len(), 3);
+        assert_eq!(
+            server_1.routes[0],
+            Route {
+                path: "/health".into(),
+                kind: RouteKind::Raw { raw: "OK".into() },
+                ..Default::default()
+            }
+        );
+        assert_eq!(
+            server_1.routes[1],
+            Route {
+                path: "/".into(),
+                kind: RouteKind::Html {
+                    html: "<p>hello world</p>".into(),
+                },
+                ..Default::default()
+            }
+        );
+        assert_eq!(
+            server_1.routes[2],
+            Route {
+                path: "/abc".into(),
+                kind: RouteKind::Html {
+                    html: "<p>hello world 2</p>".into(),
+                },
+                ..Default::default()
+            }
+        );
+        Ok(())
+    }
+
+    fn default_md_assertions(input: &str) -> anyhow::Result<()> {
+        let input = md_to_input(&input).expect("unwrap");
+        let server_1 = input.servers.first().unwrap();
+        let expected_id = Identity::Address {
+            bind_address: "0.0.0.0:5001".into(),
+        };
+        assert_eq!(server_1.identity, expected_id);
+        assert_eq!(server_1.routes.len(), 2);
+        let paths = server_1
+            .routes
+            .iter()
+            .map(|r| r.path.as_str())
+            .collect::<Vec<&str>>();
+
+        assert_eq!(paths, vec!["/app.css", "/"]);
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_example_str() -> anyhow::Result<()> {
+        let input_str = include_str!("../../../examples/md-single/md-single.md");
+        default_md_assertions(input_str)
+    }
+
+    #[test]
+    fn test_from_example_str_frontmatter() -> anyhow::Result<()> {
+        let input_str = include_str!("../../../examples/md-single/frontmatter.md");
+        default_md_assertions(input_str)
+    }
+}
+
+pub fn input_to_str(input: &Input) -> String {
+    let mut chunks = vec![];
+    if let Some(server_config) = input.servers.first() {
+        let without_routes = Input {
+            servers: vec![ServerConfig {
+                identity: server_config.identity.clone(),
+                routes: vec![],
+                ..Default::default()
+            }],
+        };
+        let yml = serde_yaml::to_string(&without_routes).expect("never fail here");
+
+        chunks.push(fenced_input(&yml));
+
+        for route in &server_config.routes {
+            let path_only = json!({"path": route.path});
+            let route_yaml = serde_yaml::to_string(&path_only).expect("never fail here on route?");
+            chunks.push(fenced_route(&route_yaml));
+            chunks.push(route_to_markdown(&route.kind, &route.path));
+        }
+    }
+    for _x in input.servers.iter().skip(1) {
+        todo!("not supported yet!")
+    }
+    chunks.join("\n")
+}
+
+fn route_to_markdown(kind: &RouteKind, path: &str) -> String {
+    match kind {
+        RouteKind::Html { html } => fenced_body("html", html),
+        RouteKind::Json { .. } => todo!("unsupported json"),
+        RouteKind::Raw { raw } => {
+            let mime = mime_guess::from_path(path);
+            let as_str = mime.first_or_text_plain();
+            let as_str = get_mime_extensions_str(as_str.as_ref());
+            if let Some(v) = as_str.and_then(|x| x.first()) {
+                fenced_body(v, raw)
+            } else {
+                fenced_body("", raw)
+            }
+        }
+        RouteKind::Sse { .. } => todo!("unsupported"),
+        RouteKind::Proxy(_) => todo!("unsupported"),
+        RouteKind::Dir(_) => todo!("unsupported"),
+    }
+}
+
+fn fenced_input(code: &str) -> String {
+    format!("```yaml bslive_input\n{}```", code)
+}
+
+fn fenced_route(code: &str) -> String {
+    format!("```yaml bslive_route\n{}```", code)
+}
+
+fn fenced_body(lang: &str, code: &str) -> String {
+    format!("```{lang}\n{code}\n```")
+}
+
+#[cfg(test)]
+mod test_serialize {
+    use super::*;
+    #[test]
+    fn test_input_to_str() -> anyhow::Result<()> {
+        let input_str = include_str!("../../../examples/md-single/md-single.md");
+        let input = md_to_input(&input_str).expect("unwrap");
+        let _output = input_to_str(&input);
+        let input = md_to_input(&input_str).expect("unwrapped 2");
+        assert_eq!(input.servers.len(), 1);
+        assert_eq!(input.servers.first().unwrap().routes.len(), 2);
+        Ok(())
+    }
+}