Break up the monolithic lib.rs into language specific functionality (#90)

* split language builders out into their own modules

* optimizations

* fix lint

Author: jadamcrain

Cargo.lock

@@ -9,5 +9,5 @@ oo-bindgen = { path = "../oo-bindgen" }
 c-oo-bindgen = { path = "../generators/c-oo-bindgen" }
 dotnet-oo-bindgen = { path = "../generators/dotnet-oo-bindgen" }
 java-oo-bindgen = { path = "../generators/java-oo-bindgen" }
-clap = "2.33"
+clap = "3.2.17"
 pathdiff = "0.2"

ci-script/Cargo.toml

@@ -0,0 +1,94 @@
+use crate::{BindingBuilder, BindingBuilderSettings};
+use oo_bindgen::backend::PlatformLocations;
+use std::path::PathBuf;
+use std::process::Command;
+
+pub(crate) struct CBindingBuilder {
+    settings: BindingBuilderSettings,
+    platforms: PlatformLocations,
+    extra_files: Vec<PathBuf>,
+}
+
+impl CBindingBuilder {
+    pub(crate) fn new(
+        settings: BindingBuilderSettings,
+        platforms: PlatformLocations,
+        extra_files: &[PathBuf],
+    ) -> Self {
+        Self {
+            settings,
+            platforms,
+            extra_files: extra_files.to_vec(),
+        }
+    }
+
+    fn output_dir(&self) -> PathBuf {
+        self.settings.destination_path.join("c/generated")
+    }
+
+    fn build_dir(&self) -> PathBuf {
+        self.settings.destination_path.join("c/build")
+    }
+}
+
+impl BindingBuilder for CBindingBuilder {
+    fn name() -> &'static str {
+        "c"
+    }
+
+    fn generate(&mut self, _is_packaging: bool, generate_doxygen: bool) {
+        for platform in self.platforms.iter() {
+            let config = c_oo_bindgen::CBindgenConfig {
+                output_dir: self.output_dir(),
+                ffi_target_name: self.settings.ffi_target_name,
+                ffi_name: self.settings.ffi_name,
+                is_release: env!("PROFILE") == "release",
+                extra_files: self.extra_files.clone(),
+                platform_location: platform.clone(),
+                generate_doxygen,
+            };
+
+            c_oo_bindgen::generate_c_package(&self.settings.library, &config)
+                .expect("failed to package C lib");
+        }
+    }
+
+    fn build(&mut self) {
+        // Clear/create build directory
+        let build_dir = self.build_dir();
+        if build_dir.exists() {
+            std::fs::remove_dir_all(&build_dir).unwrap();
+        }
+        std::fs::create_dir_all(&build_dir).unwrap();
+
+        // CMake configure
+        let result = Command::new("cmake")
+            .current_dir(&build_dir)
+            .arg("..")
+            .status()
+            .expect("cmake failed");
+        assert!(result.success());
+
+        // CMake build
+        let result = Command::new("cmake")
+            .current_dir(&build_dir)
+            .args(&["--build", ".", "--config", "Debug"])
+            .status()
+            .expect("cmake failed");
+        assert!(result.success());
+    }
+
+    fn test(&mut self) {
+        // Run unit tests
+        let result = Command::new("ctest")
+            .current_dir(&self.build_dir())
+            .args(&[".", "-C", "Debug"])
+            .status()
+            .unwrap();
+        assert!(result.success());
+    }
+
+    fn package(&mut self) {
+        // Already done in generate
+    }
+}

ci-script/src/builders/c.rs

@@ -0,0 +1,97 @@
+use crate::{BindingBuilder, BindingBuilderSettings};
+use oo_bindgen::backend::PlatformLocations;
+use std::path::PathBuf;
+use std::process::Command;
+
+pub(crate) struct DotnetBindingBuilder {
+    settings: BindingBuilderSettings,
+    platforms: PlatformLocations,
+    extra_files: Vec<PathBuf>,
+}
+
+impl DotnetBindingBuilder {
+    pub(crate) fn new(
+        settings: BindingBuilderSettings,
+        platforms: PlatformLocations,
+        extra_files: &[PathBuf],
+    ) -> Self {
+        Self {
+            settings,
+            platforms,
+            extra_files: extra_files.to_vec(),
+        }
+    }
+
+    fn output_dir(&self) -> PathBuf {
+        self.settings.destination_path.join("dotnet")
+    }
+
+    fn build_dir(&self) -> PathBuf {
+        let mut output_dir = self.output_dir();
+        output_dir.push(self.settings.library.settings.name.to_string());
+        output_dir
+    }
+}
+
+impl BindingBuilder for DotnetBindingBuilder {
+    fn name() -> &'static str {
+        "dotnet"
+    }
+
+    fn generate(&mut self, _is_packaging: bool, generate_doxygen: bool) {
+        // Clear/create generated files
+        let build_dir = self.build_dir();
+        if build_dir.exists() {
+            std::fs::remove_dir_all(&build_dir).unwrap();
+        }
+        std::fs::create_dir_all(&build_dir).unwrap();
+
+        let config = dotnet_oo_bindgen::DotnetBindgenConfig {
+            output_dir: build_dir,
+            ffi_name: self.settings.ffi_name,
+            extra_files: self.extra_files.clone(),
+            platforms: self.platforms.clone(),
+            generate_doxygen,
+        };
+
+        dotnet_oo_bindgen::generate_dotnet_bindings(&self.settings.library, &config).unwrap();
+    }
+
+    fn build(&mut self) {
+        let result = Command::new("dotnet")
+            .current_dir(&self.output_dir())
+            .arg("build")
+            .arg("--configuration")
+            .arg("Release")
+            .status()
+            .unwrap();
+        assert!(result.success());
+    }
+
+    fn test(&mut self) {
+        // Run unit tests
+        let result = Command::new("dotnet")
+            .current_dir(&self.output_dir())
+            .arg("test")
+            .arg("--configuration")
+            .arg("Release")
+            .status()
+            .unwrap();
+        assert!(result.success());
+    }
+
+    fn package(&mut self) {
+        // Produce a nupkg
+        let result = Command::new("dotnet")
+            .current_dir(&self.output_dir())
+            .arg("pack")
+            .arg("--configuration")
+            .arg("Release")
+            .arg("--include-symbols")
+            .arg("--output")
+            .arg("nupkg")
+            .status()
+            .unwrap();
+        assert!(result.success());
+    }
+}