Use 2 space indent.

Apologies for the churn, but my screen is small. rustfmt assumes big
monitors.

src/main.rs

@@ -9,101 +9,101 @@ use std::ptr;
 
 mod binding;
 use binding::{
-    deno_delete, deno_execute, deno_handle_msg_from_js, deno_init,
-    deno_last_exception, deno_new, deno_set_flags, DenoC,
+  deno_delete, deno_execute, deno_handle_msg_from_js, deno_init,
+  deno_last_exception, deno_new, deno_set_flags, DenoC,
 };
 
 // Pass the command line arguments to v8.
 // Returns a vector of command line arguments that v8 did not understand.
 fn set_flags() -> Vec<String> {
-    // deno_set_flags(int* argc, char** argv) mutates argc and argv to remove
-    // flags that v8 understands.
-    // Convert command line arguments to a vector of C strings.
-    let mut argv = std::env::args()
-        .map(|arg| CString::new(arg).unwrap().into_bytes_with_nul())
-        .collect::<Vec<_>>();
-    // Make a new array, that can be modified by V8::SetFlagsFromCommandLine(),
-    // containing mutable raw pointers to the individual command line args.
-    let mut c_argv = argv.iter_mut()
-        .map(|arg| arg.as_mut_ptr() as *mut i8)
-        .collect::<Vec<_>>();
-    // Store the length of the argv array in a local variable. We'll pass a
-    // pointer to this local variable to deno_set_flags(), which then
-    // updates its value.
-    let mut c_argc = argv.len() as c_int;
-    // Let v8 parse the arguments it recognizes and remove them from c_argv.
-    unsafe {
-        deno_set_flags(&mut c_argc, c_argv.as_mut_ptr());
-    };
-    // If c_argc was updated we have to change the length of c_argv to match.
-    c_argv.truncate(c_argc as usize);
-    // Copy the modified arguments list into a proper rust vec and return it.
-    c_argv
-        .iter()
-        .map(|ptr| unsafe {
-            let cstr = CStr::from_ptr(*ptr as *const i8);
-            let slice = cstr.to_str().unwrap();
-            slice.to_string()
-        })
-        .collect::<Vec<_>>()
+  // deno_set_flags(int* argc, char** argv) mutates argc and argv to remove
+  // flags that v8 understands.
+  // Convert command line arguments to a vector of C strings.
+  let mut argv = std::env::args()
+    .map(|arg| CString::new(arg).unwrap().into_bytes_with_nul())
+    .collect::<Vec<_>>();
+  // Make a new array, that can be modified by V8::SetFlagsFromCommandLine(),
+  // containing mutable raw pointers to the individual command line args.
+  let mut c_argv = argv
+    .iter_mut()
+    .map(|arg| arg.as_mut_ptr() as *mut i8)
+    .collect::<Vec<_>>();
+  // Store the length of the argv array in a local variable. We'll pass a
+  // pointer to this local variable to deno_set_flags(), which then
+  // updates its value.
+  let mut c_argc = argv.len() as c_int;
+  // Let v8 parse the arguments it recognizes and remove them from c_argv.
+  unsafe {
+    deno_set_flags(&mut c_argc, c_argv.as_mut_ptr());
+  };
+  // If c_argc was updated we have to change the length of c_argv to match.
+  c_argv.truncate(c_argc as usize);
+  // Copy the modified arguments list into a proper rust vec and return it.
+  c_argv
+    .iter()
+    .map(|ptr| unsafe {
+      let cstr = CStr::from_ptr(*ptr as *const i8);
+      let slice = cstr.to_str().unwrap();
+      slice.to_string()
+    })
+    .collect::<Vec<_>>()
 }
 
 type DenoException<'a> = &'a str;
 
 struct Deno {
-    ptr: *const DenoC,
+  ptr: *const DenoC,
 }
 
 impl Deno {
-    fn new() -> Deno {
-        let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
-        Deno { ptr: ptr }
-    }
+  fn new() -> Deno {
+    let ptr = unsafe { deno_new(ptr::null(), deno_handle_msg_from_js) };
+    Deno { ptr: ptr }
+  }
 
-    fn execute(
-        &mut self,
-        js_filename: &str,
-        js_source: &str,
-    ) -> Result<(), DenoException> {
-        let filename = CString::new(js_filename).unwrap();
-        let source = CString::new(js_source).unwrap();
-        let r = unsafe {
-            deno_execute(self.ptr, filename.as_ptr(), source.as_ptr())
-        };
-        if r == 0 {
-            let ptr = unsafe { deno_last_exception(self.ptr) };
-            let cstr = unsafe { CStr::from_ptr(ptr) };
-            return Err(cstr.to_str().unwrap());
-        }
-        Ok(())
+  fn execute(
+    &mut self,
+    js_filename: &str,
+    js_source: &str,
+  ) -> Result<(), DenoException> {
+    let filename = CString::new(js_filename).unwrap();
+    let source = CString::new(js_source).unwrap();
+    let r =
+      unsafe { deno_execute(self.ptr, filename.as_ptr(), source.as_ptr()) };
+    if r == 0 {
+      let ptr = unsafe { deno_last_exception(self.ptr) };
+      let cstr = unsafe { CStr::from_ptr(ptr) };
+      return Err(cstr.to_str().unwrap());
     }
+    Ok(())
+  }
 }
 
 impl Drop for Deno {
-    fn drop(&mut self) {
-        unsafe { deno_delete(self.ptr) }
-    }
+  fn drop(&mut self) {
+    unsafe { deno_delete(self.ptr) }
+  }
 }
 
 fn main() {
-    log::set_max_level(log::LevelFilter::Debug);
+  log::set_max_level(log::LevelFilter::Debug);
 
-    unsafe { deno_init() };
+  unsafe { deno_init() };
 
-    set_flags();
+  set_flags();
 
-    /*
+  /*
     let v = unsafe { deno_v8_version() };
     let c_str = unsafe { CStr::from_ptr(v) };
     let version = c_str.to_str().unwrap();
     println!("version: {}", version);
     */
 
-    let mut d = Deno::new();
+  let mut d = Deno::new();
 
-    d.execute("deno_main.js", "denoMain();")
-        .unwrap_or_else(|err| {
-            error!("{}", err);
-            std::process::exit(1);
-        });
+  d.execute("deno_main.js", "denoMain();")
+    .unwrap_or_else(|err| {
+      error!("{}", err);
+      std::process::exit(1);
+    });
 }