Extract elf module.

- Add tests to the module.
- Include code owners.

Signed-off-by: David Calavera <david.calavera@gmail.com>

Author: calavera

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @calavera

.github/pull_request_template.md

@@ -0,0 +1,5 @@
+### Summary
+
+### Test plan
+
+### Relevant links (GH issues, bugsnag, etc.) or a picture of cute animal

src/elf.rs

@@ -0,0 +1,77 @@
+use goblin::{elf::sym, elf::Elf, error::Error};
+
+const RUST_PERSONALITY: &str = "rust_eh_personality";
+const GO_SECTION: &str = ".note.go.buildid";
+
+#[derive(Debug, PartialEq)]
+pub enum Runtime {
+    Go,
+    Rust,
+}
+
+pub fn detect(data: &[u8]) -> Result<Option<Runtime>, Error> {
+    let elf = match Elf::parse(data) {
+        Ok(elf) => elf,
+        _ => return Ok(None),
+    };
+
+    for s in elf.shdr_strtab.to_vec()? {
+        if s == GO_SECTION {
+            return Ok(Some(Runtime::Go));
+        }
+    }
+
+    for s in elf.strtab.to_vec()? {
+        if s == RUST_PERSONALITY {
+            return Ok(Some(Runtime::Rust));
+        }
+    }
+
+    for s in elf.syms.iter() {
+        if s.is_function() && s.st_bind() == sym::STB_GLOBAL {
+            if let Some(Ok(sym_name)) = elf.strtab.get(s.st_name) {
+                if sym_name == RUST_PERSONALITY {
+                    return Ok(Some(Runtime::Rust));
+                }
+            }
+        }
+    }
+
+    Ok(None)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_detect_go_runtime() {
+        let buffer =
+            std::fs::read("tests/data/hello-world-go").expect("failed to load binary file");
+
+        let runtime = detect(&buffer)
+            .expect("failed to detect runtime")
+            .expect("failed to return some runtime");
+        assert_eq!(Runtime::Go, runtime);
+    }
+
+    #[test]
+    fn test_detect_rust_runtime() {
+        let buffer =
+            std::fs::read("tests/data/hello-world-rs").expect("failed to load binary file");
+
+        let runtime = detect(&buffer)
+            .expect("failed to detect runtime")
+            .expect("failed to return some runtime");
+        assert_eq!(Runtime::Rust, runtime);
+    }
+
+    #[test]
+    fn test_detect_ignores_invalid_file() {
+        let buffer =
+            std::fs::read("tests/data/hello-world-text").expect("failed to load binary file");
+
+        let runtime = detect(&buffer).expect("failed to detect runtime");
+        assert_eq!(None, runtime);
+    }
+}

src/lib.rs

@@ -1,6 +1,4 @@
-use goblin::{elf::sym, elf::Elf};
-
-mod utils;
+mod elf;
 
 use wasm_bindgen::prelude::*;
 
@@ -10,54 +8,36 @@ use wasm_bindgen::prelude::*;
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 
-const RUST_PERSONALITY: &str = "rust_eh_personality";
-const GO_SECTION: &str = ".note.go.buildid";
-
 #[wasm_bindgen]
-#[derive(Debug, PartialEq)]
 pub enum Runtime {
     Go,
     Rust,
 }
 
-#[wasm_bindgen(catch)]
-pub fn detect(data: &[u8]) -> Result<Option<Runtime>, JsValue> {
-    utils::set_panic_hook();
-
-    let elf = match Elf::parse(data) {
-        Ok(elf) => elf,
-        _ => return Ok(None),
-    };
-
-    for s in elf
-        .shdr_strtab
-        .to_vec()
-        .map_err(|e| format!("error reading symbols: {}", e))?
-    {
-        if s == GO_SECTION {
-            return Ok(Some(Runtime::Go));
-        }
-    }
-
-    for s in elf
-        .strtab
-        .to_vec()
-        .map_err(|e| format!("error reading sections: {}", e))?
-    {
-        if s == RUST_PERSONALITY {
-            return Ok(Some(Runtime::Rust));
+impl From<elf::Runtime> for Runtime {
+    fn from(rt: elf::Runtime) -> Self {
+        match rt {
+            elf::Runtime::Go => Runtime::Go,
+            elf::Runtime::Rust => Runtime::Rust,
         }
     }
+}
 
-    for s in elf.syms.iter() {
-        if s.is_function() && s.st_bind() == sym::STB_GLOBAL {
-            if let Some(Ok(sym_name)) = elf.strtab.get(s.st_name) {
-                if sym_name == RUST_PERSONALITY {
-                    return Ok(Some(Runtime::Rust));
-                }
-            }
-        }
-    }
+#[wasm_bindgen(catch)]
+pub fn detect(data: &[u8]) -> Result<Option<Runtime>, JsValue> {
+    set_panic_hook();
+    elf::detect(data)
+        .map_err(|e| JsValue::from(format!("error reading elf metadata: {}", e)))
+        .map(|o| o.map(Runtime::from))
+}
 
-    Ok(None)
+fn set_panic_hook() {
+    // When the `console_error_panic_hook` feature is enabled, we can call the
+    // `set_panic_hook` function at least once during initialization, and then
+    // we will get better error messages if our code ever panics.
+    //
+    // For more details see
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    #[cfg(feature = "console_error_panic_hook")]
+    console_error_panic_hook::set_once();
 }

src/utils.rs

@@ -0,0 +1 @@
+Hello, world!