macron-path 0.1.3

Creates a new instance of PathBuf
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))]

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;

/// Creates a new instance of PathBuf
#[proc_macro]
pub fn path(input: TokenStream) -> TokenStream {
    // empty string:
    if input.is_empty() {
        return quote! { ::std::path::PathBuf::new() }.into();
    }
    
    // path formatting:
    let Format { expr, args } = syn::parse_macro_input!(input as Format);
    
    if let syn::Expr::Lit( syn::ExprLit { lit: syn::Lit::Str(lit_str), .. } ) = expr {
        let path_str = lit_str.value().replace("\\", "/");
        let args = if let Some(args) = args { quote!{#args} }else{ quote!{} };
        
        // executable file path:
        if path_str == "$" {
            quote! {{
                ::std::env::current_exe()
                    .expect("Failed to get executable file path")
            }}
        }
        
        // executable file dir path:
        else if path_str.starts_with("$/") {
            let path_str = &path_str[2..];
            let lit_str = syn::LitStr::new(path_str, proc_macro2::Span::call_site());
            
            quote! {{
                let exe_dir = ::std::env::current_exe().expect("Failed to get executable file path")
                    .parent()
                    .map(::std::path::PathBuf::from)
                    .expect("Failed to get binary file dir");
                exe_dir.join(&::std::format!(#lit_str #args))
            }}
        }

        // home dir path:
        else if path_str.starts_with("~/") {
            let path_str = &path_str[2..];
            let lit_str = syn::LitStr::new(path_str, proc_macro2::Span::call_site());
        
            quote! {{
                #[cfg(target_os = "windows")]
                {
                    let home_dir = ::std::env::var("USERPROFILE")
                        .map(::std::path::PathBuf::from)
                        .expect("USERPROFILE not found");
                    home_dir.join(&::std::format!(#lit_str #args))
                }
                
                #[cfg(not(target_os = "windows"))]
                {
                    let home_dir = ::std::env::var("HOME")
                        .map(::std::path::PathBuf::from)
                        .expect("HOME not found");
                    home_dir.join(&::std::format!(#lit_str #args))
                }
            }}
        }

        // user data dir path:
        else if path_str.starts_with("%/") {
            let path_str = &path_str[2..];
            let lit_str = syn::LitStr::new(path_str, proc_macro2::Span::call_site());
        
            quote! {{
                #[cfg(target_os = "windows")]
                {
                    let home_dir = ::std::env::var("APPDATA")
                        .map(::std::path::PathBuf::from)
                        .expect("Failed to get user data dir");
                    home_dir.join(&::std::format!(#lit_str #args))
                }

                #[cfg(target_os = "macos")]
                {
                    let home_dir = ::std::env::var("HOME")
                        .map(::std::path::PathBuf::from)
                        .expect("Failed to get user data dir");
                    let lib_dir = home_dir.join("Library/Application Support");
                    lib_dir.join(&::std::format!(#lit_str #args))
                }

                #[cfg(all(unix, not(target_os = "macos")))]
                {
                    let home_dir = ::std::env::var("XDG_DATA_HOME")
                        .map(::std::path::PathBuf::from)
                        .or_else(|_| 
                            ::std::env::var("HOME")

                                .map(|p| ::std::path::PathBuf::from(p).join(".local/share"))
                        )
                        .expect("Failed to get user data dir");
                    home_dir.join(&::std::format!(#lit_str #args))
                }
            }}
        }
        
        // other:
        else {
            quote! {
                ::std::path::PathBuf::from(&::std::format!(#lit_str #args))
            }
        }
    } else {
        quote! {
            ::std::path::PathBuf::from(#expr)
        }
    }
    .into()
}

/// The string formatter
struct Format {
    pub expr: syn::Expr,
    pub args: Option<TokenStream2>,
}

impl syn::parse::Parse for Format {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        // parse expression:
        let expr = input.parse()?;

        // parse arguments:
        let args = if input.peek(syn::token::Comma) {
            Some(input.parse()?)
        } else {
            None
        };
        
        Ok(Self { expr, args })
    }
}