@browsersync/bslive 0.0.5 → 0.0.9

package/crates/bsnext_input/src/route.rs

@@ -0,0 +1,185 @@
+use std::fmt::{Display, Formatter};
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+
+use typeshare::typeshare;
+
+#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
+pub struct Route {
+    pub path: String,
+    #[serde(flatten)]
+    pub cors_opts: Option<CorsOpts>,
+    #[serde(flatten)]
+    pub delay_opts: Option<DelayOpts>,
+    #[serde(rename = "watch")]
+    #[serde(default)]
+    pub watch_opts: WatchOpts,
+    #[serde(flatten)]
+    pub kind: RouteKind,
+}
+
+impl Default for Route {
+    fn default() -> Self {
+        Self {
+            path: "/".to_string(),
+            kind: RouteKind::Html {
+                html: "default".into(),
+            },
+            delay_opts: None,
+            cors_opts: None,
+            watch_opts: Default::default(),
+        }
+    }
+}
+
+impl AsRef<Route> for Route {
+    fn as_ref(&self) -> &Route {
+        self
+    }
+}
+
+impl Route {
+    pub fn path(&self) -> &str {
+        self.path.as_str()
+    }
+}
+
+#[derive(Debug, Hash, PartialEq, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(untagged)]
+pub enum RouteKind {
+    Html { html: String },
+    Json { json: JsonWrapper },
+    Raw { raw: String },
+    Sse { sse: String },
+    Proxy(ProxyRoute),
+    Dir(DirRoute),
+}
+
+#[derive(Debug, PartialEq, Clone, serde::Deserialize, serde::Serialize)]
+pub struct JsonWrapper(serde_json::Value);
+
+impl Display for JsonWrapper {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", serde_json::to_string(&self.0).expect("serde_json"))
+    }
+}
+
+impl Deref for JsonWrapper {
+    type Target = serde_json::Value;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Hash for JsonWrapper {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        //todo: implement hashing for serde_value
+        if let Ok(as_str) = serde_json::to_string(&self.0) {
+            state.write(as_str.as_bytes());
+        } else {
+            todo!("handle error here?")
+        }
+    }
+}
+
+#[typeshare]
+impl RouteKind {
+    #[allow(dead_code)]
+    pub fn html(s: &str) -> Self {
+        Self::Html { html: s.into() }
+    }
+}
+
+#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
+pub struct DirRoute {
+    pub dir: String,
+}
+
+#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
+pub struct ProxyRoute {
+    pub proxy: String,
+}
+
+#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
+pub enum CorsOpts {
+    #[serde(rename = "cors")]
+    Cors(bool),
+}
+
+#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
+pub enum DelayOpts {
+    #[serde(rename = "delay")]
+    Delay(DelayKind),
+}
+
+#[derive(
+    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub enum DelayKind {
+    #[serde(rename = "ms")]
+    Ms(u64),
+}
+
+#[derive(
+    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub enum DebounceDuration {
+    #[serde(rename = "ms")]
+    Ms(u64),
+}
+
+#[derive(
+    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+#[serde(untagged)]
+pub enum FilterKind {
+    StringGlob(String),
+    Extension { ext: String },
+    Glob { glob: String },
+}
+
+#[derive(
+    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub struct Spec {
+    #[serde(flatten)]
+    pub opts: Option<SpecOpts>,
+}
+
+#[derive(
+    Debug, Ord, PartialOrd, PartialEq, Eq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub struct SpecOpts {
+    pub debounce: Option<DebounceDuration>,
+    pub filter: Option<FilterKind>,
+}
+
+#[derive(Debug, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(untagged)]
+pub enum WatchOpts {
+    Bool(bool),
+    InlineGlob(String),
+    Spec(Spec),
+}
+
+impl Default for WatchOpts {
+    fn default() -> Self {
+        Self::Bool(true)
+    }
+}
+
+impl WatchOpts {
+    pub fn is_enabled(&self) -> bool {
+        !matches!(self, WatchOpts::Bool(false))
+    }
+}
+
+#[derive(
+    Debug, PartialOrd, Ord, Eq, PartialEq, Hash, Clone, serde::Deserialize, serde::Serialize,
+)]
+pub struct Watcher {
+    pub dir: String,
+    pub debounce_ms: Option<u64>,
+    pub filter: Option<FilterKind>,
+}

package/crates/bsnext_input/src/route_manifest.rs

@@ -0,0 +1,186 @@
+use crate::route::{Route, RouteKind};
+use std::collections::{HashMap, HashSet};
+use std::hash::{DefaultHasher, Hash, Hasher};
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct RoutesManifest {
+    inner: HashMap<RouteIdentity, u64>,
+}
+
+impl RoutesManifest {
+    pub fn changeset_for(&self, other: &Self) -> RouteChangeSet {
+        let prev = self.inner.keys().collect::<HashSet<_>>();
+        let next = other.inner.keys().collect::<HashSet<_>>();
+        let changed_only = prev
+            .intersection(&next)
+            .filter_map(|id| {
+                let old = self.inner.get(*id);
+                let new = other.inner.get(*id);
+                match (old, new) {
+                    (Some(old), Some(new)) if old != new => Some((*id).to_owned()),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<_>>();
+        RouteChangeSet {
+            added: next.difference(&prev).map(|x| (*x).to_owned()).collect(),
+            removed: prev.difference(&next).map(|x| (*x).to_owned()).collect(),
+            changed: changed_only,
+        }
+    }
+    pub fn new<A: AsRef<Route>>(routes: &[A]) -> Self {
+        Self {
+            inner: routes
+                .iter()
+                .map(|a| {
+                    let route = a.as_ref();
+                    let mut hasher = DefaultHasher::new();
+                    route.hash(&mut hasher);
+                    let r2_hash = hasher.finish();
+                    let id: RouteIdentity = a.as_ref().into();
+                    (id, r2_hash)
+                })
+                .collect::<HashMap<RouteIdentity, u64>>(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Hash, Eq, Clone)]
+pub struct RouteIdentity {
+    pub path: String,
+    pub kind_str: String,
+}
+
+impl From<&Route> for RouteIdentity {
+    fn from(value: &Route) -> Self {
+        Self {
+            path: value.path.clone(),
+            kind_str: match value.kind {
+                RouteKind::Html { .. } => "RouteKind::Html",
+                RouteKind::Json { .. } => "RouteKind::Json",
+                RouteKind::Raw { .. } => "RouteKind::Raw",
+                RouteKind::Sse { .. } => "RouteKind::Sse",
+                RouteKind::Proxy(_) => "RouteKind::Proxy",
+                RouteKind::Dir(_) => "RouteKind::Dir",
+            }
+            .to_string(),
+        }
+    }
+}
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct RouteChangeSet {
+    pub added: Vec<RouteIdentity>,
+    pub removed: Vec<RouteIdentity>,
+    pub changed: Vec<RouteIdentity>,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use std::hash::DefaultHasher;
+    #[test]
+    fn test_route_hash() -> anyhow::Result<()> {
+        let r1 = Route {
+            path: "/".to_string(),
+            kind: RouteKind::Html {
+                html: String::from("hello world!"),
+            },
+            ..Default::default()
+        };
+        let r2 = r#"
+path: /
+html: hello world!
+        "#;
+        let r2: Route = serde_yaml::from_str(&r2).expect("test");
+
+        let mut hasher = DefaultHasher::new();
+        r1.hash(&mut hasher);
+        let r1_hash = hasher.finish();
+
+        let mut hasher = DefaultHasher::new();
+        r2.hash(&mut hasher);
+        let r2_hash = hasher.finish();
+
+        assert_eq!(r1_hash, r2_hash);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_route_hash_2() -> anyhow::Result<()> {
+        let r1 = r#"
+path: /
+html: hello world!
+        "#;
+        let r2 = r#"
+path: /api
+html: hello world!
+        "#;
+        let r2_edited = r#"
+path: /api
+html: hello world
+        "#;
+
+        let r1: Route = serde_yaml::from_str(&r1).expect("test");
+        let r2: Route = serde_yaml::from_str(&r2).expect("test");
+        let r2_edited: Route = serde_yaml::from_str(&r2_edited).expect("test");
+
+        let routes_orig = RoutesManifest::new(&[&r1, &r2]);
+        let routes_next = RoutesManifest::new(&[&r1]);
+        let routes_next_dup = RoutesManifest::new(&[&r1, &r2]);
+        let routes_next_3 = RoutesManifest::new(&[&r1, &r2_edited]);
+
+        let changeset_1 = routes_orig.changeset_for(&routes_next);
+        let changeset_2 = routes_orig.changeset_for(&routes_next_dup);
+        let changeset_3 = routes_orig.changeset_for(&routes_next_3);
+
+        assert_eq!(
+            changeset_1,
+            RouteChangeSet {
+                added: vec![],
+                removed: vec![RouteIdentity {
+                    path: "/api".to_string(),
+                    kind_str: "RouteKind::Html".to_string()
+                }],
+                changed: vec![],
+            }
+        );
+
+        assert_eq!(
+            changeset_1,
+            RouteChangeSet {
+                added: vec![],
+                removed: vec![RouteIdentity {
+                    path: "/api".to_string(),
+                    kind_str: "RouteKind::Html".to_string()
+                }],
+                changed: vec![],
+            }
+        );
+
+        // dbg!(changeset_1);
+        assert_eq!(
+            changeset_2,
+            RouteChangeSet {
+                added: vec![],
+                removed: vec![],
+                changed: vec![],
+            }
+        );
+
+        assert_eq!(
+            changeset_3,
+            RouteChangeSet {
+                added: vec![],
+                removed: vec![],
+                changed: vec![RouteIdentity {
+                    path: "/api".to_string(),
+                    kind_str: "RouteKind::Html".to_string()
+                }],
+            }
+        );
+
+        Ok(())
+    }
+}

package/crates/bsnext_input/src/server_config.rs

@@ -0,0 +1,88 @@
+use crate::route::{Route, Watcher};
+use crate::{rand_word, PortError};
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::net::SocketAddr;
+use std::str::FromStr;
+
+#[derive(Debug, Default, Clone, serde::Deserialize, serde::Serialize)]
+pub struct ServerConfig {
+    #[serde(flatten)]
+    pub identity: Identity,
+    #[serde(default)]
+    pub routes: Vec<Route>,
+    #[serde(default)]
+    pub watchers: Vec<Watcher>,
+}
+
+#[derive(
+    Debug, Ord, PartialOrd, PartialEq, Hash, Eq, Clone, serde::Deserialize, serde::Serialize,
+)]
+#[serde(untagged)]
+pub enum Identity {
+    Both { name: String, bind_address: String },
+    Address { bind_address: String },
+    Named { name: String },
+}
+
+impl Default for Identity {
+    fn default() -> Self {
+        Self::named()
+    }
+}
+
+impl Identity {
+    pub fn named() -> Self {
+        Self::Named { name: rand_word() }
+    }
+    pub fn address<A: AsRef<str>>(a: A) -> Self {
+        Self::Address {
+            bind_address: a.as_ref().to_string(),
+        }
+    }
+    /// if a port was provided, try to use it by validating it first
+    /// otherwise default to a named identity
+    pub fn from_port_or_named(port: Option<u16>) -> Result<Self, PortError> {
+        let result = port.map(|port| {
+            SocketAddr::from_str(&format!("0.0.0.0:{port}"))
+                .map_err(|err| PortError::InvalidPort { port, err })
+        });
+        match result {
+            None => Ok(Identity::named()),
+            Some(Ok(addr)) => Ok(Identity::address(addr.to_string())),
+            Some(Err(err)) => Err(err),
+        }
+    }
+
+    pub fn as_id(&self) -> u64 {
+        let mut hasher = DefaultHasher::new();
+        self.hash(&mut hasher);
+        hasher.finish()
+    }
+}
+
+#[test]
+fn server_config_as_enum() {
+    #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+    struct C {
+        servers: Vec<ServerConfig>,
+    }
+    let input = r#"
+servers:
+    - bind_address: 127.0.0.1:3000
+    - name: server_1
+    - name: server_2
+      bind_address: 127.0.0.1:3001
+      routes:
+        - path: /
+          dir: .
+    "#;
+    let c: C = serde_yaml::from_str(input).unwrap();
+
+    // let baseline = ServerConfigInput::Named { name: "server_1".into() };
+    let baseline = Identity::Address {
+        bind_address: "127.0.0.1x:3000".into(),
+    };
+    for x in &c.servers {
+        assert_eq!(x.identity == baseline, false);
+    }
+}

package/crates/bsnext_input/src/target.rs

@@ -0,0 +1,7 @@
+#[derive(Debug, Clone, Default, clap::ValueEnum)]
+pub enum TargetKind {
+    #[default]
+    Yaml,
+    Toml,
+    Md,
+}

package/crates/bsnext_input/src/watch_opt_test/mod.rs

@@ -0,0 +1,68 @@
+use crate::route::{DebounceDuration, FilterKind, Spec, SpecOpts, WatchOpts};
+
+#[test]
+fn test_watch_opts_debounce() {
+    let input = r#"
+    debounce:
+      ms: 200
+    filter: "**/*.css"
+    "#;
+    let expected = WatchOpts::Spec(Spec {
+        opts: Some(SpecOpts {
+            debounce: Some(DebounceDuration::Ms(200)),
+            filter: Some(FilterKind::StringGlob("**/*.css".into())),
+        }),
+    });
+    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_watch_opts_inline_filter() {
+    let input = r#"
+    filter: "**/*.css"
+    "#;
+    let expected = WatchOpts::Spec(Spec {
+        opts: Some(SpecOpts {
+            debounce: None,
+            filter: Some(FilterKind::StringGlob("**/*.css".into())),
+        }),
+    });
+    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_watch_opts_explicit_filter_ext() {
+    let input = r#"
+    filter:
+      ext: "css"
+    "#;
+    let expected = WatchOpts::Spec(Spec {
+        opts: Some(SpecOpts {
+            debounce: None,
+            filter: Some(FilterKind::Extension {
+                ext: "css".to_string(),
+            }),
+        }),
+    });
+    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
+    assert_eq!(actual, expected);
+}
+#[test]
+fn test_watch_opts_explicit_filter_glob() {
+    let input = r#"
+    filter:
+      glob: "**/*.css"
+    "#;
+    let expected = WatchOpts::Spec(Spec {
+        opts: Some(SpecOpts {
+            debounce: None,
+            filter: Some(FilterKind::Glob {
+                glob: "**/*.css".into(),
+            }),
+        }),
+    });
+    let actual: WatchOpts = serde_yaml::from_str(input).unwrap();
+    assert_eq!(actual, expected);
+}

package/crates/bsnext_input/src/yml.rs

@@ -0,0 +1 @@
+

package/crates/bsnext_output/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "bsnext_output"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bsnext_core = { path = "../bsnext_core" }
+
+ansi_term = { version = "0.12.1" }
+
+anyhow = { workspace = true }
+clap = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }

package/crates/bsnext_output/src/json.rs

@@ -0,0 +1,11 @@
+use crate::OutputWriter;
+use bsnext_core::dto::ExternalEvents;
+use std::io::Write;
+
+pub struct JsonPrint;
+
+impl OutputWriter for JsonPrint {
+    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()> {
+        write!(sink, "{}", serde_json::to_string(&evt)?).map_err(|e| anyhow::anyhow!(e.to_string()))
+    }
+}

package/crates/bsnext_output/src/lib.rs

@@ -0,0 +1,25 @@
+use crate::json::JsonPrint;
+use crate::pretty::PrettyPrint;
+use bsnext_core::dto::ExternalEvents;
+use std::io::Write;
+
+pub mod json;
+pub mod pretty;
+
+pub trait OutputWriter {
+    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()>;
+}
+
+pub enum Writers {
+    Pretty,
+    Json,
+}
+
+impl OutputWriter for Writers {
+    fn handle_event<W: Write>(&self, sink: &mut W, evt: &ExternalEvents) -> anyhow::Result<()> {
+        match self {
+            Writers::Pretty => PrettyPrint.handle_event(sink, evt),
+            Writers::Json => JsonPrint.handle_event(sink, evt),
+        }
+    }
+}