evaluate environment variable at runtime

Author: HerrMuellerluedenscheid

Cargo.lock

@@ -1,11 +1,16 @@
 [package]
 name = "needs_env_var"
-version = "1.1.0"
+version = "2.0.0"
 edition = "2021"
-description = "Skip compilation if environment variable is missing"
+description = "Skip a test if an environment variable is undefined or has a specific value."
 license = "MIT"
 repository = "https://github.com/HerrMuellerluedenscheid/needs_env_var"
 keywords = ["test"]
 
 [lib]
 proc-macro = true
+
+[dependencies]
+syn = { version = "2.0.100", features = ["full"] }
+quote = "1.0"
+

Cargo.toml

@@ -3,11 +3,11 @@ Needs Environment Variable
 
 [![Crates.io Version](https://img.shields.io/crates/v/needs_env_var)](https://crates.io/crates/needs_env_var)
 
-Skip code (such as a test) **at compile time** if an environment variable is undefined.
+Early return from a test (or method in general) if an environment variable is undefined or does not match a specific value.
 
 # Example
 
-`some_test` will not be compiled if `SOMEENVIRONMENTVARIABLE` is not defined:
+`some_test` will be skipped if `SOMEENVIRONMENTVARIABLE` is not defined or does not match `1` (examples 2 & 3).
 
 ```rust
 use needs_env_var::*;
@@ -32,6 +32,3 @@ fn some_test() {
     assert!(1 == 1);
 }
 ```
-
-❗**Note:** As `needs_env_var` is evaluated at compile time you need to force a re-compilation an environment variable
-is defined after compilation, e.g. with `cargo clean`❗ 

README.md

@@ -1,23 +1,58 @@
 use proc_macro::TokenStream;
-use std::env::var;
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    parse_macro_input, ItemFn, LitStr,
+};
 
+struct InputArgs {
+    environment_variable: LitStr,
+}
+
+impl Parse for InputArgs {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let environment_variable = input.parse::<LitStr>()?;
+        Ok(Self {
+            environment_variable,
+        })
+    }
+}
 
-/// Skip compilation if the environment variable `env_var` is undefined or if its content does not
-/// match the provided value.
 #[proc_macro_attribute]
-pub fn needs_env_var(env_var: TokenStream, input: TokenStream) -> TokenStream {
-    let macro_string = env_var.to_string().replace(" = ", "=");
-    let mut parts = macro_string.split('=');
+pub fn needs_env_var(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+    let input_args = parse_macro_input!(attr as InputArgs);
+    let environment_variable = input_args.environment_variable.value().replace(" ", "");
 
-    let var_str = parts.next().expect("macro needs an environment variable name");
-    let matches  = parts.next();
+    let (env_var, expected_value): (String, Option<String>) =
+        match environment_variable.split_once("=") {
+            Some((key, value)) => (key.to_string(), Some(value.to_string())),
+            None => (environment_variable.clone(), None),
+        };
 
-    let var_content = var(var_str);
-    let exists = var_content.is_ok();
+    let ItemFn {
+        attrs,
+        vis,
+        sig,
+        block,
+    } = input;
 
-    if !exists || matches.is_some() && matches != var_content.ok().as_deref() {
-        println!("\x1b[93mskipped. environment variable: \"{}\" did not match or was not set.\x1b[0m", var_str);
-        return TokenStream::new();
-    }
-    input
+    let expanded = quote! {
+        #(#attrs)* #vis #sig {
+            match std::env::var(#env_var) {
+                Err(_) => {eprintln!("\x1b[93mSkipping test because environment variable {} is not set.\x1b[0m", #env_var);
+                    return;
+                }
+                Ok(value) => {
+                    if value != #expected_value {
+                        eprintln!("\x1b[93mSkipping test because environment variable {}={}. Expected: {}.\x1b[0m", #env_var, value, #expected_value);
+                        return;
+                    }
+                }
+            };
+            #block
+        }
+    };
+
+    TokenStream::from(expanded)
 }