Merge pull request #22 from editorconfig-checker/enumerateArchitecture

Enumerate Architecture

Author: mstruebing

src/architecture.rs

@@ -0,0 +1,32 @@
+use std::str::FromStr;
+
+use crate::error::{Error, Result};
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Architecture {
+    Amd64,
+    I386,
+}
+
+impl Architecture {
+    pub fn stringify(self) -> &'static str {
+        use Architecture::*;
+        match self {
+            Amd64 => "amd64",
+            I386 => "386",
+        }
+    }
+}
+
+impl FromStr for Architecture {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let lower = s.to_lowercase();
+        match lower.as_str() {
+            "x86_64" => Ok(Architecture::Amd64),
+            // TODO: test if this actually matches
+            "x86" => Ok(Architecture::I386),
+            _ => Err(Error::ParseArch(lower)),
+        }
+    }
+}

src/checker.rs

@@ -1,3 +1,4 @@
+use crate::architecture::Architecture;
 use crate::error::{Error, Result};
 use crate::ostype::OsType;
 use std::{fs, io, path::Path, path::PathBuf};
@@ -9,14 +10,21 @@ mod tests {
     use flate2::write::GzEncoder;
     use flate2::Compression;
     use std::env;
+    use std::env::consts;
     use std::fs::File;
     use tempfile::NamedTempFile;
 
     #[test]
     fn test_generate_filename() {
-        assert_eq!(generate_filename(OsType::Plan9, "def"), "ec-plan9-def");
+        assert_eq!(
+            generate_filename(OsType::Plan9, Architecture::Amd64),
+            "ec-plan9-amd64"
+        );
 
-        assert_eq!(generate_filename(OsType::Linux, "amd64"), "ec-linux-amd64");
+        assert_eq!(
+            generate_filename(OsType::Linux, Architecture::I386),
+            "ec-linux-386"
+        );
     }
 
     #[test]
@@ -68,9 +76,10 @@ mod tests {
     fn test_download() -> Result<()> {
         let base_url = generate_base_url("2.0.3");
         let base_path = get_base_path(env::current_exe().unwrap()).unwrap();
-        let os_type = sys_info::os_type()?.parse::<OsType>()?;
+        let architecture = consts::ARCH.parse::<Architecture>()?;
+        let os_type = consts::OS.parse::<OsType>()?;
 
-        let filename = generate_filename(os_type, get_architecture().unwrap());
+        let filename = generate_filename(os_type, architecture);
 
         let result = download(&base_url, &base_path, &filename);
         let tar_path = format!("{}/{}.tar.gz", base_path, filename);
@@ -118,25 +127,12 @@ mod tests {
     }
 }
 
-// TODO: How to use cfg to pass a value into this function to be able to test it?
-// TODO: Test
-pub fn get_architecture() -> Result<&'static str> {
-    // TODO: This is not sufficient and needs to care for more cases
-    if cfg!(target_pointer_width = "64") {
-        Ok("amd64")
-    } else if cfg!(target_pointer_width = "32") {
-        Ok("386")
-    } else {
-        Err(Error::UnknownArch)
-    }
-}
-
 pub fn path_exists(filename: impl AsRef<std::path::Path>) -> bool {
     filename.as_ref().exists()
 }
 
-pub fn generate_filename(os: OsType, arch: &str) -> String {
-    format!("ec-{}-{}", os.stringify(), arch)
+pub fn generate_filename(os: OsType, arch: Architecture) -> String {
+    format!("ec-{}-{}", os.stringify(), arch.stringify())
 }
 
 pub fn generate_base_url(version: &str) -> String {

src/error.rs

@@ -5,9 +5,8 @@ pub type Result<T, E = Error> = std::result::Result<T, E>;
 #[derive(Debug)]
 pub enum Error {
     IO(std::io::Error),
-    UnknownArch,
-    UnknownOS(sys_info::Error),
     ParseOS(String),
+    ParseArch(String),
     InvalidPathName(std::ffi::OsString),
     Network(reqwest::Error),
     Encoding(std::str::Utf8Error),
@@ -20,9 +19,8 @@ impl fmt::Display for Error {
         use Error::*;
         match self {
             IO(err) => write!(fmt, "IO({})", err),
-            UnknownArch => write!(fmt, "Unknown Architecture"),
-            UnknownOS(err) => write!(fmt, "Unknown Operating System ({})", err),
             ParseOS(err) => write!(fmt, "Cannot parse Operating System Name ({})", err),
+            ParseArch(err) => write!(fmt, "Cannot parse System Architecture ({})", err),
             InvalidPathName(err) => write!(fmt, "Invalid Path Name ({:?})", err),
             Network(err) => write!(fmt, "Error downloading the file ({})", err),
             Encoding(err) => write!(fmt, "Encoding error ({})", err),
@@ -38,12 +36,6 @@ impl From<std::io::Error> for Error {
     }
 }
 
-impl From<sys_info::Error> for Error {
-    fn from(err: sys_info::Error) -> Self {
-        Error::UnknownOS(err)
-    }
-}
-
 impl From<std::ffi::OsString> for Error {
     fn from(err: std::ffi::OsString) -> Self {
         Error::InvalidPathName(err)

src/main.rs

@@ -1,20 +1,21 @@
+mod architecture;
 mod checker;
 mod error;
 mod ostype;
 
-use crate::{error::Result, ostype::OsType};
+use crate::{architecture::Architecture, error::Result, ostype::OsType};
 use std::{
     env,
+    env::consts,
     io::{self, Write},
     process,
 };
 
 fn main() -> Result<()> {
     let version = "2.0.3";
 
-    let architecture = checker::get_architecture()?;
-    let os_type = sys_info::os_type()?;
-    let os_type = os_type.parse::<OsType>()?;
+    let architecture = consts::ARCH.parse::<Architecture>()?;
+    let os_type = consts::OS.parse::<OsType>()?;
 
     let base_path = checker::get_base_path(env::current_exe()?)?;
     let filename = checker::generate_filename(os_type, architecture);

src/ostype.rs

@@ -11,6 +11,7 @@ mod tests {
         assert!("HALLO".parse::<OsType>().is_err());
         assert_eq!("Linux".parse::<OsType>().unwrap(), OsType::Linux);
         assert_eq!("Darwin".parse::<OsType>().unwrap(), OsType::Darwin);
+        assert_eq!("macos".parse::<OsType>().unwrap(), OsType::Darwin);
         assert_eq!("WiNdOwS".parse::<OsType>().unwrap(), OsType::Windows);
     }
 }
@@ -51,12 +52,12 @@ impl FromStr for OsType {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let lower = s.to_lowercase();
         match lower.as_str() {
+            "linux" => Ok(OsType::Linux),
+            "macos" | "darwin" => Ok(OsType::Darwin),
             // TODO: test if this actually matches
             "dragonfly" => Ok(OsType::Dragonfly),
             // TODO: test if this actually matches
             "freebsd" => Ok(OsType::FreeBSD),
-            "linux" => Ok(OsType::Linux),
-            "darwin" => Ok(OsType::Darwin),
             // TODO: test if this actually matches
             "netbsd" => Ok(OsType::NetBSD),
             // TODO: test if this actually matches