feat: poor version sync compile

Author: ahabhgk

Cargo.toml

@@ -8,7 +8,13 @@ prost = "0.10"
 url = "2"
 async-trait = "0.1"
 futures = "0.3"
-tokio = { version = "1", features = ["io-util", "process", "macros"] }
+tokio = { version = "1", features = [
+  "io-util",
+  "process",
+  "macros",
+  "rt",
+  "rt-multi-thread",
+] }
 tokio-stream = "0.1"
 tokio-util = { version = "0.7", features = ["io"] }
 supports-color = "1"

src/api.rs

@@ -36,6 +36,9 @@ pub struct Options {
   pub style: OutputStyle,
   /// https://sass-lang.com/documentation/js-api/interfaces/Options#verbose
   pub verbose: Option<bool>,
+
+  // TODO: find a better way??
+  pub exe_path: Option<String>,
 }
 
 /// https://sass-lang.com/documentation/js-api/modules#StringOptions
@@ -74,14 +77,17 @@ pub enum SassImporter {
 #[async_trait]
 pub trait Importer: Debug {
   /// https://sass-lang.com/documentation/js-api/interfaces/Importer#canonicalize
-  async fn canonicalize(
+  async fn canonicalize<'u, 'o>(
     &self,
-    url: &str,
-    options: &ImporterOptions,
+    url: &'u str,
+    options: &'o ImporterOptions,
   ) -> Result<Option<Url>>;
 
   /// https://sass-lang.com/documentation/js-api/interfaces/Importer#load
-  async fn load(&self, canonical_url: &Url) -> Result<Option<ImporterResult>>;
+  async fn load<'u>(
+    &self,
+    canonical_url: &'u Url,
+  ) -> Result<Option<ImporterResult>>;
 }
 
 pub struct ImporterOptions {
@@ -92,10 +98,10 @@ pub struct ImporterOptions {
 #[async_trait]
 pub trait FileImporter: Debug {
   /// https://sass-lang.com/documentation/js-api/interfaces/FileImporter#findFileUrl
-  async fn find_file_url(
+  async fn find_file_url<'u, 'o>(
     &self,
-    url: &str,
-    options: &ImporterOptions,
+    url: &'u str,
+    options: &'o ImporterOptions,
   ) -> Result<Option<Url>>;
 }
 

src/compile.rs

@@ -4,40 +4,81 @@ use crate::{
   compiler_path,
   importer_registry::ImporterRegistry,
   logger_registry::LoggerRegistry,
-  pb::{inbound_message::CompileRequest, outbound_message::compile_response},
+  pb::{
+    inbound_message::CompileRequest,
+    outbound_message::{compile_response, CompileResponse},
+  },
   Error,
 };
 
+pub fn compile_sync(
+  path: String,
+  mut options: Options,
+) -> Result<CompileResult> {
+  let exe = exe_path(&options);
+  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 rt = tokio::runtime::Runtime::new().unwrap();
+  let response = rt.block_on(async {
+    let embedded = Embedded::new(exe);
+    let res = embedded.compile(request, &importers, &logger).await?;
+    Ok::<CompileResponse, Error>(res)
+  })?;
+
+  handle_response(response)
+}
+
+pub fn compile_string_sync(
+  source: String,
+  mut options: Options,
+  string_options: StringOptions,
+) -> Result<CompileResult> {
+  let exe = exe_path(&options);
+  let mut importers =
+    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 rt = tokio::runtime::Runtime::new().unwrap();
+  let response = rt.block_on(async {
+    let embedded = Embedded::new(exe);
+    let res = embedded.compile(request, &importers, &logger).await?;
+    Ok::<CompileResponse, Error>(res)
+  })?;
+
+  handle_response(response)
+}
+
 pub async fn compile(
   path: String,
   mut options: Options,
 ) -> Result<CompileResult> {
+  let exe = exe_path(&options);
   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 embedded = Embedded::new(exe);
   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())
-    }
-  }
+  handle_response(response)
 }
 
 pub async fn compile_string(
   source: String,
   mut options: Options,
   string_options: StringOptions,
 ) -> Result<CompileResult> {
+  let exe = exe_path(&options);
   let mut importers =
     ImporterRegistry::new(options.importers.take(), options.load_paths.take());
   let logger = LoggerRegistry::new(options.logger.take());
@@ -48,9 +89,21 @@ pub async fn compile_string(
     &options,
     string_options,
   );
-  let embedded = Embedded::new(compiler_path::compiler_path().unwrap());
+  let embedded = Embedded::new(exe);
   let response = embedded.compile(request, &importers, &logger).await?;
 
+  handle_response(response)
+}
+
+fn exe_path(options: &Options) -> String {
+  options
+    .exe_path
+    .as_ref()
+    .unwrap_or(&compiler_path::compiler_path().unwrap())
+    .to_string()
+}
+
+fn handle_response(response: CompileResponse) -> Result<CompileResult> {
   let res = response.result.ok_or_else(|| {
     Error::Compile(
       "OutboundMessage.CompileResponse.result is not set".to_string(),
@@ -79,6 +132,17 @@ mod tests {
     )
     .await
     .unwrap();
-    dbg!(res);
+    assert_eq!(res.css, ".foo {\n  a: b;\n}");
+  }
+
+  #[test]
+  fn test_compile_string_sync() {
+    let res = compile_string_sync(
+      ".foo {a: b}".to_string(),
+      Options::default(),
+      StringOptions::WithoutImporter(WithoutImporter::default()),
+    )
+    .unwrap();
+    assert_eq!(res.css, ".foo {\n  a: b;\n}");
   }
 }

src/lib.rs

@@ -11,8 +11,12 @@ mod pb;
 mod request_tracker;
 
 use api::Logger;
-pub use api::Options;
+pub use api::{
+  FileImporter, Importer, ImporterOptions, ImporterResult, Options,
+  SassImporter, SassLogger, StringOptions, WithImporter, WithoutImporter,
+};
 pub use compile::{compile, compile_string};
+pub use compile::{compile_string_sync, compile_sync};
 pub use error::{Error, Result};
 
 #[derive(Debug, Default, Clone)]