feat: compile path

Author: ahabhgk

examples/compile_path.rs

@@ -0,0 +1 @@
+fn main() {}

src/api.rs

@@ -6,8 +6,8 @@ use url::Url;
 pub use crate::{
   error::Result,
   pb::{
-    outbound_message::compile_response::CompileFailure, OutputStyle,
-    SourceSpan, Syntax,
+    outbound_message::compile_response::{CompileFailure, CompileSuccess},
+    OutputStyle, SourceSpan, Syntax,
   },
 };
 
@@ -39,26 +39,14 @@ pub struct Options {
 }
 
 /// https://sass-lang.com/documentation/js-api/modules#StringOptions
-#[derive(Debug)]
 pub enum StringOptions {
-  WithImporter(StringOptionsWithImporter),
-  WithoutImporter(StringOptionsWithoutImporter),
-}
-
-impl StringOptions {
-  pub fn get_options_mut(&mut self) -> &mut Options {
-    match self {
-      StringOptions::WithImporter(o) => &mut o.base.base,
-      StringOptions::WithoutImporter(o) => &mut o.base,
-    }
-  }
+  WithoutImporter(WithoutImporter),
+  WithImporter(WithImporter),
 }
 
 /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithoutImporter
 #[derive(Debug, Default)]
-pub struct StringOptionsWithoutImporter {
-  /// extends [Options]
-  pub base: Options,
+pub struct WithoutImporter {
   /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithoutImporter#syntax
   pub syntax: Syntax,
   /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithoutImporter#url
@@ -67,11 +55,11 @@ pub struct StringOptionsWithoutImporter {
 
 /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithImporter
 #[derive(Debug)]
-pub struct StringOptionsWithImporter {
-  /// extends [StringOptionsWithoutImporter]
-  pub base: StringOptionsWithoutImporter,
+pub struct WithImporter {
   /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithImporter#importer
   pub importer: SassImporter,
+  /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithoutImporter#syntax
+  pub syntax: Syntax,
   /// https://sass-lang.com/documentation/js-api/interfaces/StringOptionsWithImporter#url
   pub url: Url,
 }
@@ -93,7 +81,7 @@ pub trait Importer: Debug {
   ) -> Result<Option<Url>>;
 
   /// https://sass-lang.com/documentation/js-api/interfaces/Importer#load
-  async fn load(&self, canonicalUrl: &Url) -> Result<Option<ImporterResult>>;
+  async fn load(&self, canonical_url: &Url) -> Result<Option<ImporterResult>>;
 }
 
 pub struct ImporterOptions {
@@ -162,6 +150,12 @@ impl Display for Exception {
   }
 }
 
+impl From<CompileFailure> for Exception {
+  fn from(failure: CompileFailure) -> Self {
+    Self::new(failure)
+  }
+}
+
 /// https://sass-lang.com/documentation/js-api/interfaces/ImporterResult
 pub struct ImporterResult {
   /// https://sass-lang.com/documentation/js-api/interfaces/ImporterResult#contents
@@ -183,6 +177,20 @@ pub struct CompileResult {
   pub source_map: Option<String>,
 }
 
+impl From<CompileSuccess> for CompileResult {
+  fn from(s: CompileSuccess) -> Self {
+    Self {
+      css: s.css,
+      loaded_urls: s.loaded_urls,
+      source_map: if s.source_map.is_empty() {
+        None
+      } else {
+        Some(s.source_map)
+      },
+    }
+  }
+}
+
 pub type SassLogger = Box<dyn Logger>;
 
 /// https://sass-lang.com/documentation/js-api/interfaces/Logger

src/compile.rs

@@ -1,37 +1,63 @@
 use crate::{
-  api::{CompileResult, Exception, Result, StringOptions},
+  api::{CompileResult, Exception, Options, Result, StringOptions},
   compiler::Embedded,
   compiler_path,
   importer_registry::ImporterRegistry,
   logger_registry::LoggerRegistry,
   pb::{inbound_message::CompileRequest, outbound_message::compile_response},
+  Error,
 };
 
+pub async fn compile(
+  path: String,
+  mut options: Options,
+) -> Result<CompileResult> {
+  let mut importers =
+    ImporterRegistry::new(options.importers.take(), options.load_paths.take());
+  let logger = LoggerRegistry::new(options.logger.take());
+
+  let request = CompileRequest::with_path(path, &mut importers, &options);
+  let embedded = Embedded::new(compiler_path::compiler_path().unwrap());
+  let response = embedded.compile(request, &importers, &logger).await?;
+
+  let res = response.result.ok_or_else(|| {
+    Error::Compile(
+      "OutboundMessage.CompileResponse.result is not set".to_string(),
+    )
+  })?;
+  match res {
+    compile_response::Result::Success(success) => Ok(success.into()),
+    compile_response::Result::Failure(failure) => {
+      Err(Exception::new(failure).into())
+    }
+  }
+}
+
 pub async fn compile_string(
   source: String,
-  mut options: StringOptions,
+  mut options: Options,
+  string_options: StringOptions,
 ) -> Result<CompileResult> {
-  let base = options.get_options_mut();
   let mut importers =
-    ImporterRegistry::new(base.importers.take(), base.load_paths.take());
-  let logger = LoggerRegistry::new(base.logger.take());
-
-  let request = CompileRequest::with_string(source, &mut importers, options);
-  let mut embedded = Embedded::new(compiler_path::compiler_path().unwrap());
-  let response = embedded
-    .send_compile_request(request, importers, logger)
-    .await?;
-  match response.result.unwrap() {
-    compile_response::Result::Success(success) => {
-      let css = success.css;
-      let source_map = success.source_map;
-      let loaded_urls = success.loaded_urls;
-      Ok(CompileResult {
-        css,
-        source_map: Some(source_map),
-        loaded_urls,
-      })
-    }
+    ImporterRegistry::new(options.importers.take(), options.load_paths.take());
+  let logger = LoggerRegistry::new(options.logger.take());
+
+  let request = CompileRequest::with_string(
+    source,
+    &mut importers,
+    &options,
+    string_options,
+  );
+  let embedded = Embedded::new(compiler_path::compiler_path().unwrap());
+  let response = embedded.compile(request, &importers, &logger).await?;
+
+  let res = response.result.ok_or_else(|| {
+    Error::Compile(
+      "OutboundMessage.CompileResponse.result is not set".to_string(),
+    )
+  })?;
+  match res {
+    compile_response::Result::Success(success) => Ok(success.into()),
     compile_response::Result::Failure(failure) => {
       Err(Exception::new(failure).into())
     }
@@ -40,15 +66,16 @@ pub async fn compile_string(
 
 #[cfg(test)]
 mod tests {
-  use crate::api::StringOptionsWithoutImporter;
+  use crate::api::WithoutImporter;
 
   use super::*;
 
   #[tokio::test]
   async fn test_compile_string() {
     let res = compile_string(
       ".foo {a: b}".to_string(),
-      StringOptions::WithoutImporter(StringOptionsWithoutImporter::default()),
+      Options::default(),
+      StringOptions::WithoutImporter(WithoutImporter::default()),
     )
     .await
     .unwrap();

src/compiler.rs

@@ -1,6 +1,6 @@
 use std::{ffi::OsStr, process::Stdio};
 
-use futures::{future, pin_mut, StreamExt, TryStreamExt};
+use futures::{future, pin_mut, stream, StreamExt, TryStreamExt};
 use prost::Message;
 use tokio::{
   io::BufReader,
@@ -11,48 +11,61 @@ use tokio_util::io::ReaderStream;
 use crate::{
   dispatcher::Dispatcher,
   importer_registry::ImporterRegistry,
+  logger_registry::LoggerRegistry,
+  packet_transformer::PacketTransformer,
   pb::{
     inbound_message::CompileRequest, outbound_message::CompileResponse,
     OutboundMessage,
   },
-  Error, Result, logger_registry::LoggerRegistry,
+  Error, Result,
 };
 
 pub struct Embedded {
-  stdout: Option<ChildStdout>,
-  stdin: Option<ChildStdin>,
+  stdout: ChildStdout,
+  stdin: ChildStdin,
 }
 
 impl Embedded {
   pub fn new(program: impl AsRef<OsStr>) -> Self {
-    let mut child = Command::new(program)
+    let child = Command::new(program)
       .stdin(Stdio::piped())
       .stdout(Stdio::piped())
       .stderr(Stdio::piped())
       .spawn()
       .unwrap();
 
     Self {
-      stdout: child.stdout.take(),
-      stdin: child.stdin.take(),
+      stdout: child.stdout.unwrap(),
+      stdin: child.stdin.unwrap(),
     }
   }
 
-  pub async fn send_compile_request(
-    &mut self,
+  pub async fn compile(
+    self,
     request: CompileRequest,
-    importers: ImporterRegistry,
-    logger: LoggerRegistry,
+    importers: &ImporterRegistry,
+    logger: &LoggerRegistry,
   ) -> Result<CompileResponse> {
-    let stdin = self.stdin.take().unwrap();
-    let mut dispatcher = Dispatcher::new(stdin, importers, logger);
+    let stdin = self.stdin;
+    let mut dispatcher = Dispatcher::new(stdin, &importers, &logger);
     dispatcher.send_compile_request(request).await?;
 
-    let stdout = self.stdout.take().unwrap();
+    let stdout = self.stdout;
+    let mut pt = PacketTransformer::default();
+    // TODO: refactor these shits
     let reader = ReaderStream::new(BufReader::new(stdout))
       .map_err(|io_err| Error::from(io_err))
+      .flat_map(|res| match res {
+        Ok(buf) => stream::iter(
+          pt.decode(buf.to_vec())
+            .into_iter()
+            .map(|b| Ok(b))
+            .collect::<Vec<Result<Vec<u8>>>>(),
+        ),
+        Err(e) => stream::iter(vec![Err(e)]),
+      })
       .and_then(|buf| {
-        let outbound = OutboundMessage::decode_length_delimited(buf).unwrap();
+        let outbound = OutboundMessage::decode(buf.as_ref()).unwrap();
         future::ok(outbound.message.unwrap())
       })
       .try_filter_map(|m| async {