Add resources to package

SwiftRustIntegrationTestRunner/integration-test-create-swift-package/src/main.rs

@@ -15,5 +15,6 @@ fn main() {
         )]),
         out_dir: PathBuf::from("swift-package-rust-library-fixture/MySwiftPackage"),
         package_name: "MySwiftPackage".to_string(),
+        resources: vec![],
     });
 }

book/src/building/swift-packages/README.md

@@ -235,3 +235,19 @@ cd SwiftProject
 swift run
 # You should see "Hello from Rust!" in your terminal.
 ```
+
+## Adding resources
+
+You can add resources to your Swift Package by specifying them when running the `swift-bridge-cli`
+with the `--resource` flag. Use colon-separated source and destination paths.
+Examples:
+
+- `--resource=source:destination`
+- `--resource=some_folder/some_file.txt:to_folder/some_file.txt`
+- `--resource=source_folder:destination_folder`.
+
+These resources will be accessible from your Swift Package's `Bundle` as a property.
+
+```swift
+Bundle.<camel cased cargo package name>
+```

crates/swift-bridge-build/Cargo.toml

@@ -9,6 +9,7 @@ license = "Apache-2.0/MIT"
 
 [dependencies]
 proc-macro2 = "1"
-swift-bridge-ir = {version = "0.1.48", path = "../swift-bridge-ir"}
-syn = {version = "1"}
+swift-bridge-ir = { version = "0.1.45", path = "../swift-bridge-ir" }
+syn = { version = "1" }
 tempfile = "3.3"
+copy_dir = "0.1"

crates/swift-bridge-build/src/lib.rs

@@ -5,6 +5,7 @@
 
 mod package;
 use crate::generate_core::write_core_swift_and_c;
+pub use crate::package::CopyBundleResourceDesc;
 pub use package::*;
 use std::path::Path;
 use swift_bridge_ir::{CodegenConfig, SwiftBridgeModule};

crates/swift-bridge-build/src/package.rs

@@ -18,6 +18,8 @@ pub struct CreatePackageConfig {
     pub out_dir: PathBuf,
     /// The name for the Swift package
     pub package_name: String,
+    /// Additional resources to copy into the package, first PathBuf is source and second is destination
+    pub resources: Vec<CopyBundleResourceDesc>,
 }
 
 impl CreatePackageConfig {
@@ -27,12 +29,14 @@ impl CreatePackageConfig {
         paths: HashMap<ApplePlatform, PathBuf>,
         out_dir: PathBuf,
         package_name: String,
+        resources: Vec<CopyBundleResourceDesc>,
     ) -> Self {
         Self {
             bridge_dir,
             paths,
             out_dir,
             package_name,
+            resources,
         }
     }
 }
@@ -142,7 +146,7 @@ fn gen_xcframework(output_dir: &Path, config: &CreatePackageConfig) {
         bridge_dir.join("SwiftBridgeCore.h"),
         &include_dir.join("SwiftBridgeCore.h"),
     )
-    .expect("Couldn't copy SwiftBirdgeCore header file");
+    .expect("Couldn't copy SwiftBridgeCore header file");
     let bridge_project_dir = fs::read_dir(&bridge_dir)
         .expect("Couldn't read generated directory")
         .find_map(|file| {
@@ -299,15 +303,43 @@ fn gen_package(output_dir: &Path, config: &CreatePackageConfig) {
             }
         })
         .expect("Couldn't find project's bridging swift file");
-    fs::write(
-        sources_dir.join(&bridge_project_swift_dir.file_name().unwrap()),
+
+    let bridge_swift = fs::read_to_string(&bridge_project_swift_dir)
+        .expect("Couldn't read project's bridging swift file");
+
+    let bridge_content = if config.resources.is_empty() {
+        format!("import RustXcframework\n{bridge_swift}")
+    } else {
+        // add a Bundle extension with a convenience accessor for the resources making
+        // them accessible from Swift with `Bundle.<package_name>`
         format!(
-            "import RustXcframework\n{}",
-            fs::read_to_string(&bridge_project_swift_dir)
-                .expect("Couldn't read project's bridging swift file")
-        ),
-    )
-    .expect("Couldn't copy project's bridging swift file to the package");
+            r#"import RustXcframework
+import Foundation
+
+{bridge_swift}
+
+extension Bundle {{
+    public static var {}: Bundle = .module
+}} 
+"#,
+            first_lowercased(&config.package_name)
+        )
+    };
+
+    let bridge_path = sources_dir.join(&bridge_project_swift_dir.file_name().unwrap());
+
+    fs::write(bridge_path, bridge_content)
+        .expect("Couldn't copy project's bridging swift file to the package");
+
+    let resource_entries = config
+        .resources
+        .iter()
+        .map(|r| {
+            let name = r.copy(&sources_dir);
+            format!("				.copy(\"{name}\")")
+        })
+        .collect::<Vec<String>>()
+        .join("\n");
 
     // Generate Package.swift
     let package_name = &config.package_name;
@@ -329,7 +361,11 @@ let package = Package(
 		),
 		.target(
 			name: "{package_name}",
-			dependencies: ["RustXcframework"])
+			dependencies: ["RustXcframework"],
+			resources: [
+{resource_entries}
+			]
+		)
 	]
 )
 	"#
@@ -338,3 +374,92 @@ let package = Package(
     fs::write(output_dir.join("Package.swift"), package_swift)
         .expect("Couldn't write Package.swift file");
 }
+
+/// make first char lowercase
+fn first_lowercased(name: &str) -> String {
+    let mut c = name.chars();
+    match c.next() {
+        None => String::new(),
+        Some(f) => f.to_lowercase().collect::<String>() + c.as_str(),
+    }
+}
+
+/// Describes a bundle resource to copy from some source path to some destination.
+///
+/// The source is a path to an existing file or directory that you wish to bundle.
+///
+/// The destination is a relative path that the resource will get copied to within the
+/// generated Swift package's `Sources/YourLibraryName` directory.
+///
+/// # Examples
+///
+/// ```
+/// # use swift_bridge_build::CopyBundleResourceDesc;
+///
+/// // If you are creating a Swift Package called "MyLibrary", this descriptor will
+/// // lead to the package generator copying the `/path/to/images` directory to the
+/// // the Swift package's `Sources/MyLibrary/assets/icons` directory.
+/// let resource = CopyBundleResourceDesc::new("/path/to/images", "assets/icons");
+/// ```
+pub struct CopyBundleResourceDesc {
+    source: PathBuf,
+    destination: PathBuf,
+}
+
+impl CopyBundleResourceDesc {
+    /// Parse a colon-separated pair of paths into a [`CopyBundleResourceDesc`].
+    ///
+    /// Examples: `source:destination`, `some_folder/some_file.txt:to_folder/some_file.txt`
+    /// or `source_folder:destination_folder`.
+    ///
+    /// # Panics
+    /// Panics if there is no colon in the pair.
+    pub fn from(pair: String) -> Self {
+        let mut split = pair.split(':');
+        let from = PathBuf::from(split.next().unwrap());
+        let to = PathBuf::from(
+            split
+                .next()
+                .expect(&format!("Invalid resource pair: {pair}")),
+        );
+        if !from.exists() {
+            panic!("Resource file does not exist: {from:?}");
+        }
+        if to.is_absolute() {
+            panic!("Resource destination must be relative: {to:?}");
+        }
+        Self {
+            source: from,
+            destination: to,
+        }
+    }
+    /// See [`CopyBundleResourceDesc`] for documentation.
+    ///
+    /// # Panics
+    /// Panics if the destination is an absolute path.
+    pub fn new(source: impl Into<PathBuf>, destination: impl Into<PathBuf>) -> Self {
+        let destination = destination.into();
+        assert!(destination.is_relative());
+        Self {
+            source: source.into(),
+            destination,
+        }
+    }
+
+    fn copy(&self, sources_dir: &Path) -> String {
+        let to = sources_dir.join(&self.destination);
+
+        if self.source.is_dir() {
+            copy_dir::copy_dir(&self.source, &to).expect(&format!(
+                "Could not copy resource directory {:?} to {to:?}",
+                self.source
+            ));
+        } else {
+            if let Some(parent) = to.parent() {
+                fs::create_dir_all(parent).expect("Couldn't create directory for resource");
+            }
+            fs::copy(&self.source, to).expect("Couldn't copy resource");
+        }
+        self.destination.display().to_string()
+    }
+}

crates/swift-bridge-cli/src/clap_app.rs

@@ -100,4 +100,18 @@ fn create_package_command() -> Command<'static> {
                 .required(true)
                 .help("The name for the Swift Package"),
         )
+        .arg(
+            Arg::new("resource")
+                .long("resource")
+                .takes_value(true)
+                // TODO whenever clap supports array arguments we should switch to switch to using [PathBuf; 2] instead.
+                // See: https://github.com/clap-rs/clap/issues/1682
+                .value_name("SRC_PATH:DEST_PATH")
+                .multiple_values(true)
+                .help(
+                    "A resource to copy to the package. \
+                    Use colon-separated source and destination paths. \
+                    Ex: --resource=./folder/myresource.txt:packagefolder/myresource.txt",
+                ),
+        )
 }

crates/swift-bridge-cli/src/clap_exec.rs

@@ -1,7 +1,9 @@
 use clap::ArgMatches;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use swift_bridge_build::{create_package, ApplePlatform, CreatePackageConfig};
+use swift_bridge_build::{
+    create_package, ApplePlatform, CopyBundleResourceDesc, CreatePackageConfig,
+};
 
 /// Executes the correct function depending on the cli input
 pub fn handle_matches(matches: ArgMatches) {
@@ -18,12 +20,14 @@ fn handle_create_package(matches: &ArgMatches) {
     let bridges_dir = matches.value_of("bridges-dir").unwrap(); // required
     let out_dir = matches.value_of("out-dir").map(|p| Path::new(p)).unwrap(); // required
     let name = matches.value_of("name").unwrap(); // required
+    let resources = parse_copybundleresourcedesc_args(matches);
 
     let mut config = CreatePackageConfig {
         bridge_dir: PathBuf::from(bridges_dir),
         paths: HashMap::new(),
         out_dir: out_dir.to_path_buf(),
         package_name: name.to_string(),
+        resources,
     };
 
     for platform in ApplePlatform::ALL {
@@ -34,3 +38,15 @@ fn handle_create_package(matches: &ArgMatches) {
 
     create_package(config);
 }
+
+fn parse_copybundleresourcedesc_args(matches: &ArgMatches) -> Vec<CopyBundleResourceDesc> {
+    let pairs: Vec<String> = matches
+        .get_many("resource")
+        .map(|v| v.cloned().collect())
+        .unwrap_or_default();
+
+    pairs
+        .into_iter()
+        .map(CopyBundleResourceDesc::from)
+        .collect()
+}