refactor: host

Author: ahabhgk

src/channel.rs

@@ -7,8 +7,7 @@ use crate::{
   compiler::Compiler,
   connection::{ConnectedGuard, Connection},
   dispatcher::Dispatcher,
-  importer_registry::ImporterRegistry,
-  logger_registry::LoggerRegistry,
+  host::Host,
 };
 
 #[derive(Debug)]
@@ -25,23 +24,13 @@ impl Channel {
     Self { path, dispatcher }
   }
 
-  pub fn connect(
-    &mut self,
-    logger_registry: Option<LoggerRegistry>,
-    importer_registry: Option<ImporterRegistry>,
-  ) -> ConnectedGuard {
+  pub fn connect(&mut self, host: Host) -> ConnectedGuard {
     let conn = Connection::new(Arc::clone(&self.dispatcher));
-    match self
-      .dispatcher
-      .subscribe(conn, logger_registry, importer_registry)
-    {
-      Err((conn, logger_registry, importer_registry)) => {
+    match self.dispatcher.subscribe(conn, host) {
+      Err((conn, host)) => {
         let compiler = Compiler::new(&self.path);
         self.dispatcher = Dispatcher::new(compiler);
-        self
-          .dispatcher
-          .subscribe(conn, logger_registry, importer_registry)
-          .unwrap()
+        self.dispatcher.subscribe(conn, host).unwrap()
       }
       Ok(conn) => conn,
     }

src/connection.rs

@@ -4,8 +4,7 @@ use crossbeam_channel::{Receiver, Sender};
 
 use crate::{
   dispatcher::Dispatcher,
-  importer_registry::ImporterRegistry,
-  logger_registry::LoggerRegistry,
+  host::Host,
   protocol::{
     inbound_message::{self, CompileRequest, VersionRequest},
     outbound_message::{
@@ -28,6 +27,7 @@ pub struct Connected {
   id: u32,
   tx: Sender<Response>,
   rx: Receiver<Response>,
+  host: Host,
 }
 
 #[derive(Debug)]
@@ -36,8 +36,6 @@ pub struct Unconnected;
 pub struct Connection<S: Debug> {
   state: S,
   dispatcher: Arc<Dispatcher>,
-  logger_registry: Option<LoggerRegistry>,
-  importer_registry: Option<ImporterRegistry>,
 }
 
 impl<S: Debug> Debug for Connection<S> {
@@ -67,23 +65,14 @@ impl Connection<Unconnected> {
     Self {
       state: Unconnected,
       dispatcher,
-      logger_registry: None,
-      importer_registry: None,
     }
   }
 
-  pub fn connect(
-    self,
-    id: u32,
-    logger_registry: Option<LoggerRegistry>,
-    importer_registry: Option<ImporterRegistry>,
-  ) -> ConnectedGuard {
+  pub fn connect(self, id: u32, host: Host) -> ConnectedGuard {
     let (tx, rx) = crossbeam_channel::bounded(1);
     ConnectedGuard(Arc::new(Connection {
-      state: Connected { id, tx, rx },
+      state: Connected { id, tx, rx, host },
       dispatcher: self.dispatcher,
-      logger_registry,
-      importer_registry,
     }))
   }
 }
@@ -110,39 +99,31 @@ impl Connection<Connected> {
   }
 
   pub fn log_event(&self, e: LogEvent) {
-    if let Some(logger_registry) = &self.logger_registry {
-      logger_registry.log(e)
-    }
+    self.state.host.log(e);
   }
 
   pub fn canonicalize_request(&self, e: CanonicalizeRequest) {
-    if let Some(importer_registry) = &self.importer_registry {
-      self.send_message(InboundMessage {
-        message: Some(inbound_message::Message::CanonicalizeResponse(
-          importer_registry.canonicalize(&e),
-        )),
-      });
-    }
+    self.send_message(InboundMessage {
+      message: Some(inbound_message::Message::CanonicalizeResponse(
+        self.state.host.canonicalize(&e),
+      )),
+    });
   }
 
   pub fn import_request(&self, e: ImportRequest) {
-    if let Some(importer_registry) = &self.importer_registry {
-      self.send_message(InboundMessage {
-        message: Some(inbound_message::Message::ImportResponse(
-          importer_registry.import(&e),
-        )),
-      });
-    }
+    self.send_message(InboundMessage {
+      message: Some(inbound_message::Message::ImportResponse(
+        self.state.host.import(&e),
+      )),
+    });
   }
 
   pub fn file_import_request(&self, e: FileImportRequest) {
-    if let Some(importer_registry) = &self.importer_registry {
-      self.send_message(InboundMessage {
-        message: Some(inbound_message::Message::FileImportResponse(
-          importer_registry.file_import(&e),
-        )),
-      });
-    }
+    self.send_message(InboundMessage {
+      message: Some(inbound_message::Message::FileImportResponse(
+        self.state.host.file_import(&e),
+      )),
+    });
   }
 
   pub fn compile_request(

src/dispatcher.rs

@@ -5,8 +5,7 @@ use std::sync::Arc;
 use crate::{
   compiler::Compiler,
   connection::{Connected, ConnectedGuard, Connection, Unconnected},
-  importer_registry::ImporterRegistry,
-  logger_registry::LoggerRegistry,
+  host::{Host},
   protocol::{outbound_message, InboundMessage, OutboundMessage},
 };
 
@@ -39,21 +38,13 @@ impl Dispatcher {
   pub fn subscribe(
     &self,
     observer: Connection<Unconnected>,
-    logger_registry: Option<LoggerRegistry>,
-    importer_registry: Option<ImporterRegistry>,
-  ) -> Result<
-    ConnectedGuard,
-    (
-      Connection<Unconnected>,
-      Option<LoggerRegistry>,
-      Option<ImporterRegistry>,
-    ),
-  > {
+    host: Host,
+  ) -> Result<ConnectedGuard, (Connection<Unconnected>, Host)> {
     let mut id = self.id.lock();
     if *id == Self::PROTOCOL_ERROR_ID {
-      return Err((observer, logger_registry, importer_registry));
+      return Err((observer, host));
     }
-    let observer = observer.connect(*id, logger_registry, importer_registry);
+    let observer = observer.connect(*id, host);
     self.observers.insert(*id, Arc::clone(&observer.0));
     *id += 1;
     Ok(observer)

src/embedded.rs

@@ -2,16 +2,19 @@ use std::ffi::OsStr;
 
 use crate::{
   channel::Channel,
-  importer_registry::ImporterRegistry,
-  logger_registry::LoggerRegistry,
+  host::ImporterRegistry,
+  host::{Host, LoggerRegistry},
   protocol::{
-    inbound_message::{compile_request::Input, CompileRequest},
+    inbound_message::{
+      compile_request::{Input, StringInput},
+      CompileRequest,
+    },
     outbound_message::{
       compile_response::{self, CompileSuccess},
       CompileResponse,
     },
   },
-  Exception, Options, Result,
+  Exception, Options, Result, StringOptions,
 };
 
 #[derive(Debug)]
@@ -29,13 +32,17 @@ impl Embedded {
   pub fn compile(
     &mut self,
     path: impl Into<String>,
-    mut options: Options,
+    options: Options,
   ) -> Result<CompileResult> {
-    let logger_registry = LoggerRegistry::new(options.logger.take());
-    let importer_registry = ImporterRegistry::new(
-      options.importers.take(),
-      options.load_paths.take(),
-    );
+    let mut logger_registry = LoggerRegistry::default();
+    let mut importer_registry = ImporterRegistry::default();
+    let importers = importer_registry
+      .register_all(
+        options.importers.unwrap_or_default(),
+        options.load_paths.unwrap_or_default(),
+      )
+      .collect();
+    options.logger.map(|l| logger_registry.register(l));
 
     let request = CompileRequest {
       style: options.style as i32,
@@ -46,20 +53,66 @@ impl Embedded {
       quiet_deps: options.quiet_deps,
       source_map_include_sources: options.source_map_include_sources,
       charset: options.charset,
-      importers: importer_registry.importers(),
+      importers,
       input: Some(Input::Path(path.into())),
+      // id: set in compile_request
+      // global_functions: not implemented
+      ..Default::default()
+    };
+
+    let host = Host::new(importer_registry, logger_registry);
+    let conn = self.channel.connect(host);
+    let response = conn.compile_request(request)?;
+    Ok(CompileResult::try_from(response)?)
+  }
+
+  pub fn compile_string(
+    &mut self,
+    source: impl Into<String>,
+    options: StringOptions,
+  ) -> Result<CompileResult> {
+    let mut logger_registry = LoggerRegistry::default();
+    let mut importer_registry = ImporterRegistry::default();
+    let importers = importer_registry
+      .register_all(
+        options.common.importers.unwrap_or_default(),
+        options.common.load_paths.unwrap_or_default(),
+      )
+      .collect();
+    options.common.logger.map(|l| logger_registry.register(l));
+
+    let request = CompileRequest {
+      style: options.common.style as i32,
+      source_map: options.common.source_map,
+      alert_color: options.common.alert_color,
+      alert_ascii: options.common.alert_ascii,
+      verbose: options.common.verbose,
+      quiet_deps: options.common.quiet_deps,
+      source_map_include_sources: options.common.source_map_include_sources,
+      charset: options.common.charset,
+      importers,
+      input: Some(Input::String(StringInput {
+        source: source.into(),
+        url: options.url.map(|url| url.to_string()).unwrap_or_default(),
+        syntax: options.syntax as i32,
+        importer: options.importer.map(|i| importer_registry.register(i)),
+      })),
+      // id: set in compile_request
+      // global_functions: not implemented
       ..Default::default()
     };
 
-    let conn = self
-      .channel
-      .connect(Some(logger_registry), Some(importer_registry));
+    let host = Host::new(importer_registry, logger_registry);
+    let conn = self.channel.connect(host);
     let response = conn.compile_request(request)?;
     Ok(CompileResult::try_from(response)?)
   }
 
   pub fn info(&mut self) -> Result<String> {
-    let conn = self.channel.connect(None, None);
+    let logger_registry = LoggerRegistry::default();
+    let importer_registry = ImporterRegistry::default();
+    let host = Host::new(importer_registry, logger_registry);
+    let conn = self.channel.connect(host);
     let response = conn.version_request()?;
     Ok(format!(
       "sass-embedded\t#{}",

src/host.rs

@@ -0,0 +1,43 @@
+mod importer_registry;
+mod logger_registry;
+
+pub use importer_registry::ImporterRegistry;
+pub use logger_registry::LoggerRegistry;
+
+use crate::protocol::{
+  inbound_message::{CanonicalizeResponse, FileImportResponse, ImportResponse},
+  outbound_message::{
+    CanonicalizeRequest, FileImportRequest, ImportRequest, LogEvent,
+  },
+};
+
+#[derive(Debug, Default)]
+pub struct Host {
+  importer: ImporterRegistry,
+  logger: LoggerRegistry,
+}
+
+impl Host {
+  pub fn new(importer: ImporterRegistry, logger: LoggerRegistry) -> Self {
+    Self { importer, logger }
+  }
+
+  pub fn canonicalize(
+    &self,
+    request: &CanonicalizeRequest,
+  ) -> CanonicalizeResponse {
+    self.importer.canonicalize(request)
+  }
+
+  pub fn import(&self, request: &ImportRequest) -> ImportResponse {
+    self.importer.import(request)
+  }
+
+  pub fn file_import(&self, request: &FileImportRequest) -> FileImportResponse {
+    self.importer.file_import(request)
+  }
+
+  pub fn log(&self, event: LogEvent) {
+    self.logger.log(event);
+  }
+}