chore: migrate to cargokit (#28)

* remove toolbox

* Squashed 'super_native_extensions/cargokit/' content from commit 5939b92

git-subtree-dir: super_native_extensions/cargokit
git-subtree-split: 5939b92685aa779b1740b6f6501e6f708a12bf3d

* Squashed 'super_native_extensions/cargokit/' changes from 5939b92..2ebfade

2ebfade fix problem with accessing gradle plugin properties too early

git-subtree-dir: super_native_extensions/cargokit
git-subtree-split: 2ebfade1d84c7e73e2f00a504277efa81b38d22f

* migrate to cargokit

* Squashed 'super_native_extensions/cargokit/' changes from 2ebfade..c4fc1fc

c4fc1fc fix regression for static libraries in cocoapods

git-subtree-dir: super_native_extensions/cargokit
git-subtree-split: c4fc1fcf9b621430e1a298b162f9ae02533a0fce

* migrate to cargokit (linux)

* migrate to cargokit (windows)

Author: knopp

super_drag_and_drop/example/ios/Podfile.lock

@@ -21,7 +21,7 @@ EXTERNAL SOURCES:
 SPEC CHECKSUMS:
   Flutter: f04841e97a9d0b0a8025694d0796dd46242b2854
   irondash_engine_context: 3458bf979b90d616ffb8ae03a150bafe2e860cc9
-  super_native_extensions: 55d087ec425f0a4af81a899705181ee51636a12d
+  super_native_extensions: 9d1f9d92e81e884c1d211d7c631de7abefb95f32
 
 PODFILE CHECKSUM: ef19549a9bc3046e7bb7d2fab4d021637c0c58a3
 

super_drag_and_drop/example/macos/Podfile.lock

@@ -21,7 +21,7 @@ EXTERNAL SOURCES:
 SPEC CHECKSUMS:
   FlutterMacOS: 8f6f14fa908a6fb3fba0cd85dbd81ec4b251fb24
   irondash_engine_context: da62996ee25616d2f01bbeb85dc115d813359478
-  super_native_extensions: 4325f59d4bf41d417ca9567420b37f278c71cd83
+  super_native_extensions: 639855da5aaa8ef5d63f26e0889423d201ec5e19
 
 PODFILE CHECKSUM: 353c8bcc5d5b0994e508d035b5431cfe18c1dea7
 

super_native_extensions/android/build.gradle

@@ -34,9 +34,10 @@ android {
     }
 }
 
-apply from: "../toolbox/gradle/plugin.gradle"
 
-toolbox {
+apply from: "../cargokit/gradle/plugin.gradle"
+
+cargokit {
     manifestDir = "../rust"
     libname = "super_native_extensions"
 }

super_native_extensions/toolbox/.gitignore super_native_extensions/cargokit/.gitignore

@@ -8,18 +8,19 @@ NEW_PATH=`echo $PATH | tr ":" "\n" | grep -v "Contents/Developer/" | tr "\n" ":"
 
 export PATH=${NEW_PATH%?} # remove trailing :
 
-export TOOLBOX_PLATFORM_NAME=$PLATFORM_NAME
-export TOOLBOX_ARCHS=$ARCHS
-export TOOLBOX_CONFIGURATION=$CONFIGURATION
-export TOOLBOX_SRCROOT=$PODS_TARGET_SRCROOT
-export TOOLBOX_TEMP_DIR=$TARGET_TEMP_DIR
-export TOOLBOX_PRODUCT_NAME=$PRODUCT_NAME
-export TOOLBOX_TARGET_DIR=$PODS_CONFIGURATION_BUILD_DIR
-export TOOLBOX_TOOL_TEMP_DIR=$TARGET_TEMP_DIR/rust_tool
+export CARGOKIT_PLATFORM_NAME=$PLATFORM_NAME
+export CARGOKIT_ARCHS=$ARCHS
+export CARGOKIT_CONFIGURATION=$CONFIGURATION
+export CARGOKIT_SRCROOT=$PODS_TARGET_SRCROOT
+export CARGOKIT_TEMP_DIR=$TARGET_TEMP_DIR
+export CARGOKIT_PRODUCT_NAME=$PRODUCT_NAME
+export CARGOKIT_TARGET_DIR=$PODS_CONFIGURATION_BUILD_DIR
+export CARGOKIT_TOOL_TEMP_DIR=$TARGET_TEMP_DIR/rust_tool
 
 $BASEDIR/run_rust_tool.sh build_pod $@
 
 # Make a symlink from built framework to phony file, which will be used as input to
 # build script. This should force rebuild (podspec currently doesn't support alwaysOutOfDate
 # attribute on custom build phase)
-ln -Fs "${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}" "${TARGET_TEMP_DIR}/toolbox_phony"
+ln -Fs "${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}" "${TARGET_TEMP_DIR}/cargokit_phony"
+ln -Fs "${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}" "${TARGET_TEMP_DIR}/cargokit_phony_out"

super_native_extensions/toolbox/LICENSE super_native_extensions/cargokit/LICENSE

@@ -1,4 +1,4 @@
-# Toolbox will get symlinked to project, but it's not part of workspace
+# CargoKit will get symlinked to project, but it's not part of workspace
 [workspace]
 
 [package]

super_native_extensions/toolbox/README super_native_extensions/cargokit/README

@@ -1,6 +1,12 @@
-use std::{fmt::Debug, fs, io::Write, path::Path, process::Command};
-
-use anyhow::Result;
+use std::{
+    fmt::Debug,
+    fs,
+    io::Write,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use anyhow::{Context, Result};
 use log::{debug, info};
 use semver::Version;
 
@@ -72,7 +78,7 @@ impl Target {
 }
 
 fn get_targets() -> Vec<Target> {
-    let platforms = std::env::var("TOOLBOX_TARGET_PLATFORMS")
+    let platforms = std::env::var("CARGOKIT_TARGET_PLATFORMS")
         .ok()
         .unwrap_or_else(|| "".into());
     platforms
@@ -83,7 +89,7 @@ fn get_targets() -> Vec<Target> {
 }
 
 fn is_release() -> bool {
-    let configuration = std::env::var("TOOLBOX_BUILD_MODE")
+    let configuration = std::env::var("CARGOKIT_BUILD_MODE")
         .ok()
         .unwrap_or_else(|| "release".into());
     configuration != "debug"
@@ -105,7 +111,7 @@ const CLANG_TOOL_EXTENSION: &str = "";
 // Workaround for libgcc missing in NDK23, inspired by cargo-ndk
 fn libgcc_workaround(build_dir: &Path, ndk_version: &Version) -> Result<String> {
     let workaround_dir = build_dir
-        .join("toolbox")
+        .join("cargokit")
         .join("libgcc_workaround")
         .join(ndk_version.major.to_string());
     fs::create_dir_all(&workaround_dir)?;
@@ -137,20 +143,28 @@ fn libgcc_workaround(build_dir: &Path, ndk_version: &Version) -> Result<String>
     Ok(rustflags)
 }
 
+fn pick_existing(paths: Vec<PathBuf>) -> Option<PathBuf> {
+    paths.into_iter().find(|p| p.exists())
+}
+
 fn build_for_target(target: &Target) -> Result<()> {
-    let min_version = string_from_env("TOOLBOX_MIN_SDK_VERSION")?;
+    let min_version = string_from_env("CARGOKIT_MIN_SDK_VERSION")?;
     let min_version: i32 = min_version.parse()?;
     let min_version = min_version.max(target.min_sdk_version());
 
-    let toolchain_path = path_from_env("TOOLBOX_NDK_DIR")?
+    let toolchain_path = path_from_env("CARGOKIT_NDK_DIR")?
         .join("toolchains")
         .join("llvm")
         .join("prebuilt")
         .join(ARCH)
         .join("bin");
 
     let ar_key = format!("AR_{}", target.rust_target());
-    let ar_value = toolchain_path.join(format!("{}-ar", target.ndk_prefix()));
+    let ar_value = pick_existing(vec![
+        toolchain_path.join(format!("{}-ar", target.ndk_prefix())),
+        toolchain_path.join("llvm-ar"),
+    ])
+    .expect("Did not find ar tool");
 
     let cc_key = format!("CC_{}", target.rust_target());
     let cc_value = toolchain_path.join(format!(
@@ -177,10 +191,10 @@ fn build_for_target(target: &Target) -> Result<()> {
     .to_ascii_uppercase();
     let linker_value = cc_value.clone();
 
-    let ndk_version = string_from_env("TOOLBOX_NDK_VERSION")?;
-    let build_dir = path_from_env("TOOLBOX_BUILD_DIR")?;
-    let output_dir = path_from_env("TOOLBOX_OUTPUT_DIR")?;
-    let lib_name = string_from_env("TOOLBOX_LIB_NAME")?;
+    let ndk_version = string_from_env("CARGOKIT_NDK_VERSION")?;
+    let build_dir = path_from_env("CARGOKIT_BUILD_DIR")?;
+    let output_dir = path_from_env("CARGOKIT_OUTPUT_DIR")?;
+    let lib_name = string_from_env("CARGOKIT_LIB_NAME")?;
 
     let ndk_version = Version::parse(&ndk_version)?;
     let rust_flags_value = libgcc_workaround(&build_dir, &ndk_version)?;
@@ -194,7 +208,7 @@ fn build_for_target(target: &Target) -> Result<()> {
     let mut cmd = Command::new("cargo");
     cmd.arg("build");
     cmd.arg("--manifest-path");
-    cmd.arg(path_from_env("TOOLBOX_MANIFEST_DIR")?.join("Cargo.toml"));
+    cmd.arg(path_from_env("CARGOKIT_MANIFEST_DIR")?.join("Cargo.toml"));
     cmd.arg("-p");
     cmd.arg(&lib_name);
     if is_release() {
@@ -217,13 +231,14 @@ fn build_for_target(target: &Target) -> Result<()> {
     fs::create_dir_all(&output_dir)?;
 
     let lib_name_full = format!("lib{}.so", lib_name);
-    fs::copy(
-        build_dir
-            .join(target.rust_target())
-            .join(if is_release() { "release" } else { "debug" })
-            .join(&lib_name_full),
-        output_dir.join(&lib_name_full),
-    )?;
+    let src = build_dir
+        .join(target.rust_target())
+        .join(if is_release() { "release" } else { "debug" })
+        .join(&lib_name_full);
+    let dst = output_dir.join(&lib_name_full);
+    fs::copy(&src, &dst)
+        .with_context(|| format!("dst: {:?}", dst))
+        .with_context(|| format!("src: {:?}", src))?;
 
     Ok(())
 }

super_native_extensions/toolbox/build_pod.sh super_native_extensions/cargokit/build_pod.sh

@@ -31,15 +31,15 @@ impl Target {
 }
 
 fn is_release() -> bool {
-    let configuration = std::env::var("TOOLBOX_CONFIGURATION")
+    let configuration = std::env::var("CARGOKIT_CONFIGURATION")
         .ok()
         .map(|s| s.to_ascii_lowercase())
         .unwrap_or_else(|| "release".into());
     configuration != "debug"
 }
 
 pub fn build_cmake() -> Result<()> {
-    let target = string_from_env("TOOLBOX_TARGET_PLATFORM")?;
+    let target = string_from_env("CARGOKIT_TARGET_PLATFORM")?;
     let target = Target::from_flutter_target(&target)
         .ok_or_else(|| anyhow::anyhow!("Invalid target {:?}", target))?;
     let installed_targets = installed_targets()?;
@@ -48,10 +48,10 @@ pub fn build_cmake() -> Result<()> {
         install_target(target.rust_target())?;
     }
 
-    let build_dir = path_from_env("TOOLBOX_BUILD_DIR")?;
-    let output_dir = path_from_env("TOOLBOX_TARGET_DIR")?;
-    let lib_name = string_from_env("TOOLBOX_LIB_NAME")?;
-    let manifest_path = path_from_env("TOOLBOX_MANIFEST_DIR")?
+    let build_dir = path_from_env("CARGOKIT_BUILD_DIR")?;
+    let output_dir = path_from_env("CARGOKIT_TARGET_DIR")?;
+    let lib_name = string_from_env("CARGOKIT_LIB_NAME")?;
+    let manifest_path = path_from_env("CARGOKIT_MANIFEST_DIR")?
         .join("Cargo.toml")
         .canonicalize()?;
 

super_native_extensions/toolbox/build_tool/Cargo.lock super_native_extensions/cargokit/build_tool/Cargo.lock

@@ -1,18 +1,22 @@
 use anyhow::Result;
 use log::info;
-use std::{env::Args, path::PathBuf, process::Command};
+use std::{
+    env::Args,
+    path::{Path, PathBuf},
+    process::Command,
+};
 
 use super::utils::*;
 
 fn get_archs() -> Vec<String> {
-    let archs = std::env::var("TOOLBOX_ARCHS")
+    let archs = std::env::var("CARGOKIT_ARCHS")
         .ok()
         .unwrap_or_else(|| "x86_64".into());
     archs.split(' ').into_iter().map(String::from).collect()
 }
 
 fn target_for_arch(arch: &str) -> Result<String> {
-    let platform_name = string_from_env("TOOLBOX_PLATFORM_NAME")?;
+    let platform_name = string_from_env("CARGOKIT_PLATFORM_NAME")?;
     let suffix = match platform_name.as_str() {
         "macosx" => "apple-darwin",
         "iphonesimulator" => "apple-ios-sim",
@@ -37,27 +41,27 @@ fn target_for_arch(arch: &str) -> Result<String> {
 }
 
 fn is_release() -> bool {
-    let configuration = std::env::var("TOOLBOX_CONFIGURATION")
+    let configuration = std::env::var("CARGOKIT_CONFIGURATION")
         .ok()
         .unwrap_or_else(|| "Release".into());
     configuration != "Debug"
 }
 
 fn manifest_path(src_path: &str) -> Result<PathBuf> {
-    let src_root = path_from_env("TOOLBOX_SRCROOT")?;
+    let src_root = path_from_env("CARGOKIT_SRCROOT")?;
     // Resolve symlink so that crates with relative paths work properly
     // when using as flutter plugin (which itself is symlinked)
     Ok(src_root.join(src_path).join("Cargo.toml").canonicalize()?)
 }
 
 fn temp_target_dir() -> Result<PathBuf> {
-    let target_dir = string_from_env("TOOLBOX_TEMP_DIR")?;
+    let target_dir = string_from_env("CARGOKIT_TEMP_DIR")?;
     Ok(target_dir.into())
 }
 
 fn final_target_dir() -> Result<PathBuf> {
-    let product_name = string_from_env("TOOLBOX_PRODUCT_NAME")?;
-    let target_path = path_from_env("TOOLBOX_TARGET_DIR")?;
+    let product_name = string_from_env("CARGOKIT_PRODUCT_NAME")?;
+    let target_path = path_from_env("CARGOKIT_TARGET_DIR")?;
     Ok(target_path.join(product_name))
 }
 
@@ -92,21 +96,63 @@ pub fn build_pod(mut args: Args) -> Result<()> {
         run_command(cmd)?;
     }
 
-    {
-        let lib_name = format!("lib{}.a", lib_name);
+    let lib_path = |lib_name: &str, arch: &str| -> Result<PathBuf> {
+        let path = temp_target_dir()?
+            .join(target_for_arch(arch)?)
+            .join(if is_release() { "release" } else { "debug" })
+            .join(lib_name);
+        Ok(path)
+    };
+
+    let perform_lipo = |target_file: &Path, lib_name: &str| -> Result<()> {
         let mut cmd = Command::new("lipo");
         cmd.arg("-create");
         for arch in &archs {
-            let path = temp_target_dir()?
-                .join(target_for_arch(arch)?)
-                .join(if is_release() { "release" } else { "debug" })
-                .join(&lib_name);
+            let path = lib_path(lib_name, arch)?;
             cmd.arg(path);
         }
         cmd.arg("-output");
-        cmd.arg(final_target_dir()?.join(lib_name));
+        cmd.arg(target_file);
         run_command(cmd)?;
-    }
+        Ok(())
+    };
+
+    let static_lib_name = format!("lib{}.a", lib_name);
+    let is_static_lib = archs.iter().any(|a| {
+        lib_path(&static_lib_name, a)
+            .map(|a| a.exists())
+            .unwrap_or(false)
+    });
 
-    Ok(())
+    // If the crate builds both staticlib and cdylib, we use static lib, assuming
+    // it will be linked with the rest of pod.
+    if is_static_lib {
+        let target_file = final_target_dir()?.join(&static_lib_name);
+        perform_lipo(&target_file, &static_lib_name)?;
+        Ok(())
+    } else {
+        let bundle_paths = &[
+            format!("{}.framework/Versions/A/{}", lib_name, lib_name),
+            format!("{}.framework/{}", lib_name, lib_name), // iOS
+        ];
+
+        // Dynamic library in a bundle. Replace bundle dylib with lipoed rust dylib.
+        for bundle_path in bundle_paths {
+            let target_file = final_target_dir()?.join(bundle_path);
+            if target_file.exists() {
+                let lib_name = format!("lib{}.dylib", lib_name);
+                perform_lipo(&target_file, &lib_name)?;
+
+                // Replace absolute id with @rpath one so that it works properly
+                // when moved to Frameworks.
+                let mut cmd = Command::new("install_name_tool");
+                cmd.arg("-id");
+                cmd.arg(format!("@rpath/{}", bundle_path));
+                cmd.arg(&target_file);
+                run_command(cmd)?;
+                return Ok(());
+            }
+        }
+        Err(anyhow::anyhow!("Unable to find bundle for dynamic library"))
+    }
 }

super_native_extensions/toolbox/build_tool/Cargo.toml super_native_extensions/cargokit/build_tool/Cargo.toml

@@ -10,7 +10,7 @@ mod logger;
 mod utils;
 
 fn init_logging() -> Result<()> {
-    let silent = std::env::var("TOOLBOX_SILENT")
+    let silent = std::env::var("CARGOKIT_SILENT")
         .ok()
         .unwrap_or_else(|| "".into());
     let level = if silent == "1" {
@@ -24,9 +24,9 @@ fn init_logging() -> Result<()> {
 }
 
 fn dump_environment() -> Result<()> {
-    debug!("Toolbox environment:");
+    debug!("CargoKit environment:");
     for var in std::env::vars() {
-        if var.0.to_ascii_lowercase().starts_with("toolbox_") {
+        if var.0.to_ascii_lowercase().starts_with("cargokit_") {
             debug!("{}={}", var.0, var.1);
         }
     }
@@ -55,7 +55,7 @@ fn run() -> Result<()> {
 fn main() {
     let res = run();
     if let Err(error) = res {
-        eprintln!("Build tool failed:\n{}", error);
+        eprintln!("Build tool failed:\n{:?}", error);
         exit(1);
     }
 }