Replace cargo_toml library with cargo inner TomlManifest

.github/workflows/ci.yml

@@ -99,9 +99,13 @@ jobs:
           toolchain: stable
           override: true
       - name: Install Apple targets
-        run: rustup target add aarch64-apple-ios x86_64-apple-ios
+        run: |
+          rustup upgrade
+          rustup target add aarch64-apple-ios x86_64-apple-ios
       - name: Install Android targets
-        run: rustup target add aarch64-linux-android x86_64-linux-android
+        run: |
+          rustup upgrade
+          rustup target add aarch64-linux-android x86_64-linux-android
       - name: Install bundletool
         run: |
           wget https://github.com/google/bundletool/releases/download/1.8.2/bundletool-all-1.8.2.jar

crossbundle/cli/Cargo.toml

@@ -24,7 +24,6 @@ path = "src/main.rs"
 [dependencies]
 crossbundle-tools = { path = "../tools", version = "0.1.3" }
 clap = { version = "3.0.5", features = ["derive"] }
-cargo_toml = "0.10.1"
 serde = { version = "1.0", features = ["derive"] }
 dunce = "1.0"
 thiserror = "1.0"
@@ -36,6 +35,8 @@ fs_extra = "1.2"
 android-tools = "0.2.7"
 dirs = "4.0.0"
 ureq = "2.4.0"
+cargo = "0.59.0"
+cargo-util = "0.1.1"
 
 [features]
 default = ["android", "ios"]

crossbundle/cli/src/cargo_manifest.rs

@@ -1,10 +1,7 @@
-pub use cargo_toml::Package as CargoPackage;
 use crossbundle_tools::types::{android_manifest::UsesPermission, *};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
-pub type CargoManifest = cargo_toml::Manifest<Metadata>;
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Metadata {
     pub app_name: Option<String>,

crossbundle/cli/src/commands/build/build_context.rs

@@ -1,10 +1,12 @@
 use crate::{
-    cargo_manifest::{CargoManifest, CargoPackage, Metadata},
+    cargo_manifest::Metadata,
     error::{Error, Result},
 };
+use cargo::core::Manifest;
 use crossbundle_tools::{
     commands::{
         android, apple, find_package_cargo_manifest_path, find_workspace_cargo_manifest_path,
+        parse_manifest,
     },
     tools::AndroidSdk,
     types::{
@@ -19,7 +21,8 @@ pub struct BuildContext {
     pub workspace_manifest_path: PathBuf,
     pub package_manifest_path: PathBuf,
     pub project_path: PathBuf,
-    pub cargo_package: CargoPackage<Metadata>,
+    pub manifest: Manifest,
+    pub metadata: Metadata,
     pub target_dir: PathBuf,
 }
 
@@ -31,35 +34,38 @@ impl BuildContext {
         let target_dir =
             target_dir.unwrap_or_else(|| workspace_manifest_path.parent().unwrap().join("target"));
         info!("Parsing Cargo.toml");
-        let cargo_manifest = CargoManifest::from_path_with_metadata(&package_manifest_path)?;
-        let cargo_package = cargo_manifest.package.ok_or(Error::InvalidManifest)?;
+        let manifest = parse_manifest(&package_manifest_path)?;
+        let custom_metadata = manifest
+            .custom_metadata()
+            .ok_or(Error::InvalidManifestMetadata)?
+            .to_owned();
+        let metadata = custom_metadata
+            .try_into::<Metadata>()
+            .map_err(|_| Error::InvalidManifestMetadata)?;
         Ok(Self {
             workspace_manifest_path,
             package_manifest_path,
+            manifest,
             project_path,
-            cargo_package,
+            metadata,
             target_dir,
         })
     }
 
     pub fn package_name(&self) -> String {
-        if let Some(metadata) = &self.cargo_package.metadata {
-            if let Some(package_name) = metadata.android_package_name.clone() {
-                return package_name;
-            };
+        if let Some(package_name) = self.metadata.android_package_name.clone() {
+            return package_name;
         };
-        self.cargo_package.name.clone()
+        self.manifest.summary().name().to_string()
     }
 
     pub fn package_version(&self) -> String {
-        self.cargo_package.version.clone()
+        self.manifest.summary().version().to_string()
     }
 
     pub fn target_sdk_version(&self, sdk: &AndroidSdk) -> u32 {
-        if let Some(metadata) = &self.cargo_package.metadata {
-            if let Some(target_sdk_version) = metadata.target_sdk_version {
-                return target_sdk_version;
-            };
+        if let Some(target_sdk_version) = self.metadata.target_sdk_version {
+            return target_sdk_version;
         };
         sdk.default_platform()
     }
@@ -68,35 +74,22 @@ impl BuildContext {
         if !build_targets.is_empty() {
             return build_targets.clone();
         };
-        if self.cargo_package.metadata.is_none() {
+        if self.metadata.android_build_targets.is_none() {
             return vec![AndroidTarget::Aarch64LinuxAndroid];
         };
-        let targets = self
-            .cargo_package
-            .metadata
-            .clone()
-            .unwrap()
-            .android_build_targets;
+        let targets = self.metadata.android_build_targets.clone();
         if targets.is_some() && !targets.as_ref().unwrap().is_empty() {
             return targets.unwrap();
         };
         vec![AndroidTarget::Aarch64LinuxAndroid]
     }
 
     pub fn android_res(&self) -> Option<PathBuf> {
-        self.cargo_package
-            .metadata
-            .as_ref()
-            .map(|m| m.android_res.clone())
-            .unwrap_or_default()
+        self.metadata.android_res.clone()
     }
 
     pub fn android_assets(&self) -> Option<PathBuf> {
-        self.cargo_package
-            .metadata
-            .as_ref()
-            .map(|m| m.android_assets.clone())
-            .unwrap_or_default()
+        self.metadata.android_assets.clone()
     }
 
     pub fn gen_android_manifest(
@@ -105,36 +98,35 @@ impl BuildContext {
         package_name: &String,
         debuggable: bool,
     ) -> Result<AndroidManifest> {
-        if let Some(metadata) = &self.cargo_package.metadata {
-            if metadata.use_android_manifest {
-                let path = metadata
-                    .android_manifest_path
+        if self.metadata.use_android_manifest {
+            let path = self
+                .metadata
+                .android_manifest_path
+                .clone()
+                .unwrap_or_else(|| self.project_path.join("AndroidManifest.xml"));
+            Ok(android::read_android_manifest(&path)?)
+        } else if !self.metadata.use_android_manifest {
+            let mut manifest = android::gen_minimal_android_manifest(
+                self.metadata.android_package_name.clone(),
+                package_name,
+                self.metadata.app_name.clone(),
+                self.metadata
+                    .version_name
                     .clone()
-                    .unwrap_or_else(|| self.project_path.join("AndroidManifest.xml"));
-                Ok(android::read_android_manifest(&path)?)
-            } else {
-                let mut manifest = android::gen_minimal_android_manifest(
-                    metadata.android_package_name.clone(),
-                    package_name,
-                    metadata.app_name.clone(),
-                    metadata
-                        .version_name
-                        .clone()
-                        .unwrap_or(self.package_version()),
-                    metadata.version_code.clone(),
-                    metadata.min_sdk_version,
-                    metadata
-                        .target_sdk_version
-                        .unwrap_or_else(|| sdk.default_platform()),
-                    metadata.max_sdk_version,
-                    metadata.icon.clone(),
-                    debuggable,
-                );
-                if !metadata.android_permissions.is_empty() {
-                    manifest.uses_permission = metadata.android_permissions.clone();
-                }
-                Ok(manifest)
+                    .unwrap_or(self.package_version()),
+                self.metadata.version_code.clone(),
+                self.metadata.min_sdk_version,
+                self.metadata
+                    .target_sdk_version
+                    .unwrap_or_else(|| sdk.default_platform()),
+                self.metadata.max_sdk_version,
+                self.metadata.icon.clone(),
+                debuggable,
+            );
+            if !self.metadata.android_permissions.is_empty() {
+                manifest.uses_permission = self.metadata.android_permissions.clone();
             }
+            Ok(manifest)
         } else {
             let target_sdk_version = sdk.default_platform();
             Ok(android::gen_minimal_android_manifest(
@@ -153,23 +145,22 @@ impl BuildContext {
     }
 
     pub fn gen_info_plist(&self, package_name: &String) -> Result<InfoPlist> {
-        if let Some(metadata) = &self.cargo_package.metadata {
-            if metadata.use_info_plist {
-                let path = metadata
-                    .info_plist_path
+        if self.metadata.use_info_plist {
+            let path = self
+                .metadata
+                .info_plist_path
+                .clone()
+                .unwrap_or_else(|| self.project_path.join("Info.plist"));
+            Ok(apple::read_info_plist(&path)?)
+        } else if !self.metadata.use_info_plist {
+            Ok(apple::gen_minimal_info_plist(
+                package_name,
+                self.metadata.app_name.clone(),
+                self.metadata
+                    .version_name
                     .clone()
-                    .unwrap_or_else(|| self.project_path.join("Info.plist"));
-                Ok(apple::read_info_plist(&path)?)
-            } else {
-                Ok(apple::gen_minimal_info_plist(
-                    package_name,
-                    metadata.app_name.clone(),
-                    metadata
-                        .version_name
-                        .clone()
-                        .unwrap_or(self.package_version()),
-                ))
-            }
+                    .unwrap_or(self.package_version()),
+            ))
         } else {
             Ok(apple::gen_minimal_info_plist(
                 package_name,
@@ -183,34 +174,21 @@ impl BuildContext {
         if !build_targets.is_empty() {
             return build_targets.clone();
         };
-        if self.cargo_package.metadata.is_none() {
+        if self.metadata.apple_build_targets.is_none() {
             return vec![AppleTarget::X86_64AppleIos];
         };
-        let targets = self
-            .cargo_package
-            .metadata
-            .clone()
-            .unwrap()
-            .apple_build_targets;
+        let targets = self.metadata.clone().apple_build_targets;
         if targets.is_some() && !targets.as_ref().unwrap().is_empty() {
             return targets.unwrap();
         };
         vec![AppleTarget::X86_64AppleIos]
     }
 
     pub fn apple_res(&self) -> Option<PathBuf> {
-        self.cargo_package
-            .metadata
-            .as_ref()
-            .map(|m| m.apple_res.clone())
-            .unwrap_or_default()
+        self.metadata.apple_res.clone()
     }
 
     pub fn apple_assets(&self) -> Option<PathBuf> {
-        self.cargo_package
-            .metadata
-            .as_ref()
-            .map(|m| m.apple_assets.clone())
-            .unwrap_or_default()
+        self.metadata.apple_assets.clone()
     }
 }

crossbundle/cli/src/error.rs

@@ -24,8 +24,6 @@ pub enum Error {
     Io(#[from] std::io::Error),
     /// Clap error
     Clap(#[from] clap::Error),
-    /// Cargo toml parse error
-    CargoToml(#[from] cargo_toml::Error),
     /// Crossbundle Tools error
     CrossbundleTools(#[from] crossbundle_tools::error::Error),
     /// AndroidManifest error

crossbundle/tools/Cargo.toml

@@ -31,8 +31,6 @@ log = "0.4"
 zip = "0.5.13"
 zip-extensions = "0.6"
 tempfile = "3.2"
-
-
 cargo = "0.59.0"
 cargo-util = "0.1.1"
 

crossbundle/tools/src/commands/common/mod.rs

@@ -2,9 +2,11 @@
 mod create_project;
 mod find_cargo_manifest_path;
 mod gen_minimal_project;
+mod parse_manifest;
 mod rust_compile;
 
 pub use create_project::*;
 pub use find_cargo_manifest_path::*;
 pub use gen_minimal_project::*;
+pub use parse_manifest::*;
 pub use rust_compile::*;

crossbundle/tools/src/commands/common/parse_manifest.rs

@@ -0,0 +1,20 @@
+use crate::error::Error;
+use cargo::{
+    core::{EitherManifest, Manifest, SourceId},
+    util::toml::read_manifest,
+    Config,
+};
+use std::path::Path;
+
+/// Read manifest files and deserialize it
+pub fn parse_manifest(manifest_path: &Path) -> crate::error::Result<Manifest> {
+    let source_id = SourceId::for_path(manifest_path)?;
+    let cargo_config = Config::default()?;
+    let either_manifest = read_manifest(manifest_path, source_id, &cargo_config)
+        .map_err(|_| Error::FailedToFindManifest(manifest_path.to_owned()))?
+        .0;
+    match either_manifest {
+        EitherManifest::Real(manifest) => Ok(manifest),
+        _ => Err(Error::FailedToFindManifest(manifest_path.to_owned())),
+    }
+}

crossbundle/tools/src/error.rs

@@ -82,6 +82,8 @@ pub enum Error {
         path: PathBuf,
         cause: std::io::Error,
     },
+    /// Failed to find the manifest in path: {0}
+    FailedToFindManifest(PathBuf),
     /// Invalid profile: {0}
     InvalidProfile(String),
     /// Invalid interface orientation: {0:?}

crossbundle/tools/tests/aab_full.rs

@@ -17,7 +17,7 @@ fn test_aab_full() {
 
     // Assigns configuration for project
     let macroquad_project = false;
-    let package_name = gen_minimal_project(&project_path, macroquad_project).unwrap();
+    let package_name = gen_minimal_project(project_path, macroquad_project).unwrap();
     let sdk = AndroidSdk::from_env().unwrap();
     let ndk = AndroidNdk::from_env(Some(sdk.sdk_path())).unwrap();
     let target_sdk_version = 30;
@@ -31,7 +31,7 @@ fn test_aab_full() {
     android::compile_rust_for_android(
         &ndk,
         build_target,
-        &project_path,
+        project_path,
         profile,
         vec![],
         false,

crossbundle/tools/tests/add_libs.rs

@@ -14,8 +14,8 @@ fn add_libs_into_aapt2_test() {
     let project_path = tempdir.path();
 
     // Assigns configuration for project
-    let macroquad_project = true;
-    let package_name = gen_minimal_project(&project_path, macroquad_project).unwrap();
+    let macroquad_project = false;
+    let package_name = gen_minimal_project(project_path, macroquad_project).unwrap();
 
     // Assigns configuration for project
     let sdk = AndroidSdk::from_env().unwrap();
@@ -31,7 +31,7 @@ fn add_libs_into_aapt2_test() {
     compile_rust_for_android(
         &ndk,
         build_target,
-        &project_path,
+        project_path,
         profile,
         vec![],
         false,