Add 'bundle' subcommand.

Author: kitsonk

cli/compiler.rs

@@ -50,16 +50,22 @@ impl ModuleMetaData {
 type CompilerConfig = Option<(String, Vec<u8>)>;
 
 /// Creates the JSON message send to compiler.ts's onmessage.
-fn req(root_names: Vec<String>, compiler_config: CompilerConfig) -> Buf {
+fn req(
+  root_names: Vec<String>,
+  compiler_config: CompilerConfig,
+  bundle: Option<String>,
+) -> Buf {
   let j = if let Some((config_path, config_data)) = compiler_config {
     json!({
       "rootNames": root_names,
+      "bundle": bundle,
       "configPath": config_path,
       "config": str::from_utf8(&config_data).unwrap(),
     })
   } else {
     json!({
       "rootNames": root_names,
+      "bundle": bundle,
     })
   };
   j.to_string().into_boxed_str().into_boxed_bytes()
@@ -82,6 +88,67 @@ pub fn get_compiler_config(
   }
 }
 
+pub fn bundle_async(
+  state: ThreadSafeState,
+  module_name: String,
+  out_file: String,
+) -> impl Future<Item = (), Error = Diagnostic> {
+  debug!(
+    "Invoking the compiler to bundle. module_name: {}",
+    module_name
+  );
+
+  let root_names = vec![module_name.clone()];
+  let compiler_config = get_compiler_config(&state, "typescript");
+  let req_msg = req(root_names, compiler_config, Some(out_file));
+
+  // Count how many times we start the compiler worker.
+  state.metrics.compiler_starts.fetch_add(1, Ordering::SeqCst);
+
+  let mut worker = Worker::new(
+    "TS".to_string(),
+    startup_data::compiler_isolate_init(),
+    // TODO(ry) Maybe we should use a separate state for the compiler.
+    // as was done previously.
+    state.clone(),
+  );
+  js_check(worker.execute("denoMain()"));
+  js_check(worker.execute("workerMain()"));
+  js_check(worker.execute("compilerMain()"));
+
+  let resource = worker.state.resource.clone();
+  let compiler_rid = resource.rid;
+  let first_msg_fut = resources::post_message_to_worker(compiler_rid, req_msg)
+    .then(move |_| worker)
+    .then(move |result| {
+      if let Err(err) = result {
+        // TODO(ry) Need to forward the error instead of exiting.
+        eprintln!("{}", err.to_string());
+        std::process::exit(1);
+      }
+      debug!("Sent message to worker");
+      let stream_future =
+        resources::get_message_stream_from_worker(compiler_rid).into_future();
+      stream_future.map(|(f, _rest)| f).map_err(|(f, _rest)| f)
+    });
+
+  first_msg_fut.map_err(|_| panic!("not handled")).and_then(
+    move |maybe_msg: Option<Buf>| {
+      debug!("Received message from worker");
+
+      if let Some(msg) = maybe_msg {
+        let json_str = std::str::from_utf8(&msg).unwrap();
+        debug!("Message: {}", json_str);
+        if let Some(diagnostics) = Diagnostic::from_emit_result(json_str) {
+          return Err(diagnostics);
+        }
+      }
+
+      Ok(())
+    },
+  )
+}
+
 pub fn compile_async(
   state: ThreadSafeState,
   module_meta_data: &ModuleMetaData,
@@ -95,7 +162,7 @@ pub fn compile_async(
 
   let root_names = vec![module_name.clone()];
   let compiler_config = get_compiler_config(&state, "typescript");
-  let req_msg = req(root_names, compiler_config);
+  let req_msg = req(root_names, compiler_config, None);
 
   // Count how many times we start the compiler worker.
   state.metrics.compiler_starts.fetch_add(1, Ordering::SeqCst);

cli/flags.rs

@@ -154,6 +154,16 @@ To get help on the another subcommands (run in this case):
 Includes versions of Deno, V8 JavaScript Engine, and the TypeScript
 compiler.",
         ),
+    ).subcommand(
+      SubCommand::with_name("bundle")
+        .setting(AppSettings::DisableVersion)
+        .about("Bundle module and dependnecies into single file")
+        .long_about(
+          "Fetch, compile, and output to a single file a module and its dependencies.
+"
+        )
+          .arg(Arg::with_name("source_file").takes_value(true).required(true))
+          .arg(Arg::with_name("out_file").takes_value(true).required(true)),
     ).subcommand(
       SubCommand::with_name("fetch")
         .setting(AppSettings::DisableVersion)
@@ -436,6 +446,7 @@ const PRETTIER_URL: &str = "https://deno.land/[email protected]/prettier/main.ts";
 /// There is no "Help" subcommand because it's handled by `clap::App` itself.
 #[derive(Debug, PartialEq)]
 pub enum DenoSubcommand {
+  Bundle,
   Eval,
   Fetch,
   Info,
@@ -455,6 +466,13 @@ pub fn flags_from_vec(
   let mut flags = parse_flags(&matches.clone());
 
   let subcommand = match matches.subcommand() {
+    ("bundle", Some(bundle_match)) => {
+      flags.allow_write = true;
+      let source_file: &str = bundle_match.value_of("source_file").unwrap();
+      let out_file: &str = bundle_match.value_of("out_file").unwrap();
+      argv.extend(vec![source_file.to_string(), out_file.to_string()]);
+      DenoSubcommand::Bundle
+    }
     ("eval", Some(eval_match)) => {
       flags.allow_net = true;
       flags.allow_env = true;

cli/main.rs

@@ -41,6 +41,7 @@ mod tokio_write;
 pub mod version;
 pub mod worker;
 
+use crate::compiler::bundle_async;
 use crate::errors::RustOrJsError;
 use crate::progress::Progress;
 use crate::state::ThreadSafeState;
@@ -257,6 +258,25 @@ fn xeval_command(flags: DenoFlags, argv: Vec<String>) {
   tokio_util::run(main_future);
 }
 
+fn bundle_command(flags: DenoFlags, argv: Vec<String>) {
+  let (mut _worker, state) = create_worker_and_state(flags, argv);
+
+  let main_module = state.main_module().unwrap();
+  let main_url = root_specifier_to_url(&main_module).unwrap();
+  let out_file = state.out_file().unwrap();
+  debug!(">>>>> bundle_async START");
+  let bundle_future = bundle_async(state, main_url.to_string(), out_file)
+    .map_err(|e| {
+      debug!("diagnostics returned, exiting!");
+      eprintln!("\n{}", e.to_string());
+      std::process::exit(1);
+    }).and_then(move |out| {
+      debug!(">>>>> bundle_async END");
+      Ok(out)
+    });
+  tokio_util::run(bundle_future);
+}
+
 fn run_repl(flags: DenoFlags, argv: Vec<String>) {
   let (mut worker, _state) = create_worker_and_state(flags, argv);
 
@@ -318,6 +338,7 @@ fn main() {
   });
 
   match subcommand {
+    DenoSubcommand::Bundle => bundle_command(flags, argv),
     DenoSubcommand::Eval => eval_command(flags, argv),
     DenoSubcommand::Fetch => fetch_or_info_command(flags, argv, false),
     DenoSubcommand::Info => fetch_or_info_command(flags, argv, true),

cli/state.rs

@@ -270,6 +270,15 @@ impl ThreadSafeState {
     }
   }
 
+  /// Read the out file from argv
+  pub fn out_file(&self) -> Option<String> {
+    if self.argv.len() <= 2 {
+      None
+    } else {
+      Some(self.argv[2].clone())
+    }
+  }
+
   pub fn mark_compiled(&self, module_id: &str) {
     let mut c = self.compiled.lock().unwrap();
     c.insert(module_id.to_string());