calceph-sys 0.1.4

Rust FFI bindings to the calceph library for astronomical computations.
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

use cmake::Config;
use std::path::PathBuf;
use std::{env, fs};
use std::process::Command;

const CALCEPH_DIR: &str = "CALCEPH_DIR";

fn main() {
    println!("cargo:rerun-if-env-changed={}", CALCEPH_DIR);

    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    let calceph_dir = env::var(CALCEPH_DIR).ok().map(PathBuf::from);

    let calceph_include = if calceph_dir.is_some() {
        calceph_dir.as_ref().unwrap().join("include")
    } else {
        PathBuf::from("vendor/calceph/include")
    };

    gen_bindings(&calceph_include);

    #[cfg(feature = "calceph-src")]
    let calceph_dir = calceph_dir.or_else(|| {
        let downloaded = out_path.join("cacleph");
        if !downloaded.exists() {
            download_calceph(&out_path);
        }
        Some(out_path)
    });

    let calceph_dir = match calceph_dir {
        Some(dir) => {
            if !dir.exists() {
                println!("cargo:warning={}", format!("`calceph_dir` does not point to a valid directory: {}", dir.display()));
                return;
            }
            dir
        },
        None => {
            println!("cargo:warning={}", format!("`calceph_dir` does not point to a valid directory. Please set the {} environment variable or use `calceph-src` feature.", CALCEPH_DIR));
            return;
        }
    };

    #[cfg(feature = "calceph-src")]
    build_calceph(&calceph_dir);

    let calceph_lib = calceph_dir.join("lib");
    let calceph_include = calceph_dir.join("include");

    println!("cargo:rustc-link-search=native={}", calceph_lib.to_str().unwrap());
    println!("cargo:rustc-link-lib=static=calceph");
    println!("cargo:include={}", calceph_include.to_str().unwrap());
}

#[cfg(feature = "calceph-src")]
fn download_calceph(dst: &PathBuf) {
    let calceph_version = "4_0_5";
    let url = format!("https://gitlab.obspm.fr/imcce_calceph/calceph/-/archive/calceph_{}/calceph-calceph_{}.tar.gz", calceph_version, calceph_version);

    let body = reqwest::blocking::get(url)
        .expect("Failed to download calceph archive")
        .bytes()
        .unwrap();

    let download_target = dst.join("calceph.tar.gz");
    std::fs::write(download_target, body).unwrap();
    
    // Extract package based on platform
    let output = Command::new("tar")
        .arg("-xzf")
        .arg("calceph.tar.gz")
        .current_dir(dst)
        .output()
        .expect("Failed to extract archive with tar");
    
    if !output.status.success() {
        panic!("Failed to extract archive: {}", String::from_utf8_lossy(&output.stderr));
    }

    // Move the extracted directory to the destination
    let from = dst.join(format!("calceph-calceph_{}", calceph_version));
    let to = dst.join("calceph");
    if to.exists() {
        fs::remove_dir_all(&to).expect("Failed to remove existing calceph directory");
    }
    fs::rename(&from, &to).expect("Failed to rename extracted directory");
}

#[cfg(feature = "calceph-src")]
fn build_calceph(cacleph_dir: &PathBuf) {
    let target = env::var("TARGET").unwrap();
    // Build the CMake project using NMake Makefiles generator
    let mut cfg = Config::new(cacleph_dir.join("calceph"));
    cfg.define("ENABLE_FORTRAN", "OFF");
    if target.contains("msvc")
    {
        cfg.generator("NMake Makefiles");
    }
    cfg.build();
}

fn gen_bindings(include_dst: &PathBuf) {
    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    // Generate the bindings
    let bindings = bindgen::Builder::default()
        .header(include_dst.join("calceph.h").to_str().unwrap())
        .generate()
        .expect("Unable to generate bindings");

    let bindings_path = out_path.join("bindings.rs");

    bindings
        .write_to_file(&bindings_path)
        .expect("Couldn't write bindings!");
}