Implement the logic for the rs_loader_impl_load_from_file and implement a basic functionality for metacall_registrator

Author: devraymondsh

source/loaders/rs_loader/rust/Cargo.toml

@@ -14,7 +14,8 @@ rustc_private = true
 opt-level = "z"
 
 [workspace]
-members = ["parser"]
+members = ["parser", "metacall_registrator"]
 
 [dependencies]
-parser = { path = "./parser" }
+parser = { path = "./parser" }
+metacall_registrator = { path = "metacall_registrator" }

source/loaders/rs_loader/rust/metacall_registrator/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "metacall_registrator"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+cargo_toml = "0.8.1"

source/loaders/rs_loader/rust/metacall_registrator/src/lib.rs

@@ -0,0 +1,18 @@
+use std::{ffi::c_void, path::PathBuf};
+
+pub struct CargoCdylibProject {
+    path_to_project: PathBuf,
+    path_to_project_librs: PathBuf,
+}
+impl CargoCdylibProject {
+    pub fn new(
+        path_buf: PathBuf,
+        loader_impl: *mut c_void,
+    ) -> Result<CargoCdylibProject, &'static str> {
+        Err("Basic implementation")
+    }
+
+    pub fn register_the_project_in_metacall(&self) -> Result<(), &'static str> {
+        Err("Basic implementation")
+    }
+}

source/loaders/rs_loader/rust/src/lib.rs

@@ -18,10 +18,10 @@ pub use lifecycle::rs_loader_impl_load_from_memory;
 pub use lifecycle::rs_loader_impl_load_from_package;
 
 pub struct LoaderLifecycleState {
-    paths: Vec<PathBuf>,
+    execution_paths: Vec<PathBuf>,
 }
 impl LoaderLifecycleState {
-    pub fn new(paths: Vec<PathBuf>) -> LoaderLifecycleState {
-        LoaderLifecycleState { paths }
+    pub fn new(execution_paths: Vec<PathBuf>) -> LoaderLifecycleState {
+        LoaderLifecycleState { execution_paths }
     }
 }

source/loaders/rs_loader/rust/src/lifecycle/execution_path.rs

@@ -13,7 +13,7 @@ pub extern "C" fn rs_loader_impl_execution_path(
 
     unsafe {
         (*(loader_lifecycle_state))
-            .paths
+            .execution_paths
             .push(PathBuf::from(path_slice));
     }
 

source/loaders/rs_loader/rust/src/lifecycle/load_from_file.rs

@@ -1,19 +1,69 @@
-use crate::{c_char, c_int, c_void, CStr};
+use crate::{bridge_api, c_char, c_int, c_void, CStr, PathBuf};
+
+use metacall_registrator;
+
+fn rs_loader_impl_load_from_file_on_error(error: &str) -> *mut c_void {
+    eprintln!("{}", error);
+
+    0 as c_int as *mut c_void
+}
 
 #[no_mangle]
 pub extern "C" fn rs_loader_impl_load_from_file(
-    _loader_impl: *mut c_void,
+    loader_impl: *mut c_void,
     paths: *const *mut c_char,
     size: usize,
 ) -> *mut c_void {
+    let loader_lifecycle_state = bridge_api::get_loader_lifecycle_state(loader_impl);
+    let mut execution_paths_iterator = unsafe { (*loader_lifecycle_state).execution_paths.iter() };
+
     for i in 0..size {
         let path: *const c_char = paths.wrapping_offset(i as isize) as *const c_char;
+        let path_slice = unsafe { CStr::from_ptr(path) }.to_str().unwrap();
+        let mut path_buf = PathBuf::from(path_slice);
+
+        if !path_buf.is_absolute() {
+            let execution_path = execution_paths_iterator.next();
+
+            match execution_path {
+                Some(execution_path) => {
+                    let mut execution_path = execution_path.clone();
+                    let mut execution_path_as_str = execution_path.to_str().unwrap();
+
+                    if !execution_path_as_str.ends_with("/") {
+                        execution_path = PathBuf::from(format!("{}{}", execution_path_as_str, "/"));
+
+                        //Reassign the execution_path_as_str since the execution_path got changed
+                        execution_path_as_str = execution_path.to_str().unwrap();
+                    }
 
-        let c_path: &CStr = unsafe { CStr::from_ptr(path) };
+                    path_buf = PathBuf::from(format!(
+                        "{}{}",
+                        execution_path_as_str,
+                        path_buf.to_str().unwrap()
+                    ));
+                }
+                None => {
+                    return rs_loader_impl_load_from_file_on_error(
+                        "Execution path's length is less than non-absolute path's length",
+                    )
+                }
+            };
+        }
+        if !path_buf.is_file() {
+            return rs_loader_impl_load_from_file_on_error("Not a valid path to a file");
+        }
 
-        let path_slice: &str = c_path.to_str().unwrap();
+        let cargo_cdylib_project =
+            match metacall_registrator::CargoCdylibProject::new(path_buf, loader_impl) {
+                Ok(cargo_cdylib_project) => cargo_cdylib_project,
+                Err(error) => return rs_loader_impl_load_from_file_on_error(error),
+            };
 
-        println!("Path slice given from Rust: {}", path_slice);
+        match cargo_cdylib_project.register_the_project_in_metacall() {
+            Ok(_) => (),
+            Err(error) => return rs_loader_impl_load_from_file_on_error(error),
+        };
     }
 
     1 as c_int as *mut c_void