Add support for Rust contract meta crates; more conversion to pathlib.Path; method renaming

Author: camilbancioiu

erdpy/projects/project_base.py

@@ -26,7 +26,7 @@ def build(self, options: Union[Dict[str, Any], None] = None) -> Path:
         return self._do_after_build()
 
     def clean(self):
-        utils.remove_folder(self._get_output_folder())
+        utils.remove_folder(self.get_output_folder())
 
     def _ensure_dependencies_installed(self):
         module_keys = self.get_dependencies()
@@ -42,36 +42,35 @@ def perform_build(self) -> None:
     def get_file_wasm(self):
         return self.find_file_in_output("*.wasm")
 
-    def find_file_globally(self, pattern):
-        folder = self.directory
-        return self.find_file_in_folder(folder, pattern)
+    def find_file_globally(self, pattern: str) -> Path:
+        return self.find_file_in_folder(self.path, pattern)
 
-    def find_file_in_output(self, pattern):
-        folder = path.join(self.directory, "output")
+    def find_file_in_output(self, pattern: str) -> Path:
+        folder = self.path / 'output'
         return self.find_file_in_folder(folder, pattern)
 
-    def find_file_in_folder(self, folder, pattern):
-        files = list(Path(folder).rglob(pattern))
+    def find_file_in_folder(self, folder: Path, pattern: str) -> Path:
+        files = list(folder.rglob(pattern))
 
         if len(files) == 0:
             raise errors.KnownError(f"No file matches pattern [{pattern}].")
         if len(files) > 1:
             logger.warning(f"More files match pattern [{pattern}]. Will pick first:\n{files}")
 
-        file = path.join(folder, files[0])
+        file = folder / files[0]
         return Path(file).resolve()
 
     def _do_after_build(self) -> Path:
         raise NotImplementedError()
 
-    def _copy_to_output(self, source: str, destination: str = None) -> Path:
-        output_folder = self._get_output_folder()
+    def _copy_to_output(self, source: Path, destination: str = None) -> Path:
+        output_folder = self.get_output_folder()
         utils.ensure_folder(output_folder)
         destination = path.join(output_folder, destination) if destination else output_folder
-        output_wasm_file = shutil.copy(source, destination)
+        output_wasm_file = shutil.copy(str(source), destination)
         return Path(output_wasm_file)
 
-    def _get_output_folder(self):
+    def get_output_folder(self):
         return path.join(self.directory, "output")
 
     def get_bytecode(self):

erdpy/projects/project_clang.py

@@ -1,9 +1,10 @@
 import logging
-import os
 import subprocess
 from os import path
 from pathlib import Path
 
+from typing import List
+
 from erdpy import dependencies, errors, myprocess, utils
 from erdpy.projects.project_base import Project
 
@@ -135,9 +136,9 @@ def ensure_source_files(self):
 
         self.config['source_files'] = source_files
 
-    def get_exported_functions(self):
+    def get_exported_functions(self) -> List[str]:
         file_export = self.find_file_globally('*.export')
-        lines = utils.read_lines(file_export)
+        lines = utils.read_lines(str(file_export))
         return lines
 
     def default_config(self):

erdpy/projects/project_rust.py

@@ -14,107 +14,132 @@
 class ProjectRust(Project):
     def __init__(self, directory):
         super().__init__(directory)
-        self.cargo_file = self._get_cargo_file()
+        self.cargo_file = self.get_cargo_file()
 
     def clean(self):
         super().clean()
         utils.remove_folder(path.join(self.directory, "wasm", "target"))
 
-    def _get_cargo_file(self):
-        cargo_path = path.join(self.directory, "Cargo.toml")
+    def get_cargo_file(self):
+        cargo_path = self.path / 'Cargo.toml'
         return CargoFile(cargo_path)
 
+    def get_meta_folder(self):
+        return self.path / 'meta'
+
     def perform_build(self):
+        meta = self.has_meta()
         try:
+            if meta:
+                self.run_meta()
             self.run_cargo()
-            self._generate_abi()
+
+            # ABI generated separately for backwards compatibility
+            if not meta:
+                self.generate_abi()
         except subprocess.CalledProcessError as err:
             raise errors.BuildError(err.output)
 
     def run_cargo(self):
-        env = self._get_env()
+        env = self.get_env()
 
         args = [
             "cargo",
             "build",
             "--target=wasm32-unknown-unknown",
             "--release",
             "--out-dir",
-            self._get_output_folder(),
+            self.get_output_folder(),
             "-Z"
             "unstable-options"
         ]
-        self._decorate_cargo_args(args)
+        self.decorate_cargo_args(args)
 
         if not self.options.get("wasm_symbols"):
             env["RUSTFLAGS"] = "-C link-arg=-s"
 
-        cwd = path.join(self.directory, "wasm")
-        return_code = myprocess.run_process_async(args, env=env, cwd=cwd)
+        cwd = self.path / 'wasm'
+        return_code = myprocess.run_process_async(args, env=env, cwd=str(cwd))
+        if return_code != 0:
+            raise errors.BuildError(f"error code = {return_code}, see output")
+
+    def run_meta(self):
+        cwd = self.get_meta_folder()
+        env = self.get_env()
+
+        args = [
+            "cargo",
+            "build",
+        ]
+
+        return_code = myprocess.run_process_async(args, env=env, cwd=str(cwd))
         if return_code != 0:
             raise errors.BuildError(f"error code = {return_code}, see output")
 
-    def _decorate_cargo_args(self, args):
+    def decorate_cargo_args(self, args):
         target_dir = self.options.get("cargo_target_dir")
         if target_dir:
             args.extend(["--target-dir", target_dir])
 
-    def _generate_abi(self):
-        if not self._has_abi():
+    def generate_abi(self):
+        if not self.has_abi():
             return
 
         args = [
             "cargo",
             "run"
         ]
-        self._decorate_cargo_args(args)
+        self.decorate_cargo_args(args)
 
-        env = self._get_env()
+        env = self.get_env()
         cwd = path.join(self.directory, "abi")
-        sink = myprocess.FileOutputSink(self._get_abi_filepath())
+        sink = myprocess.FileOutputSink(self.get_abi_filepath())
         return_code = myprocess.run_process_async(args, env=env, cwd=cwd, stdout_sink=sink)
         if return_code != 0:
             raise errors.BuildError(f"error code = {return_code}, see output")
 
-        utils.prettify_json_file(self._get_abi_filepath())
+        utils.prettify_json_file(self.get_abi_filepath())
+
+    def has_meta(self):
+        return self.get_meta_folder().exists()
 
-    def _has_abi(self):
-        return (self._get_abi_folder() / "Cargo.toml").exists()
+    def has_abi(self):
+        return (self.get_abi_folder() / "Cargo.toml").exists()
 
-    def _get_abi_filepath(self):
-        return self._get_abi_folder() / "abi.json"
+    def get_abi_filepath(self):
+        return self.get_abi_folder() / "abi.json"
 
-    def _get_abi_folder(self):
+    def get_abi_folder(self):
         return Path(self.directory, "abi")
 
     def _do_after_build(self) -> Path:
         original_name = self.cargo_file.package_name
         wasm_base_name = self.cargo_file.package_name.replace("-", "_")
-        wasm_file = Path(self._get_output_folder(), f"{wasm_base_name}_wasm.wasm").resolve()
+        wasm_file = Path(self.get_output_folder(), f"{wasm_base_name}_wasm.wasm").resolve()
         wasm_file_renamed = self.options.get("wasm_name")
         if not wasm_file_renamed:
             wasm_file_renamed = f"{original_name}.wasm"
-        wasm_file_renamed_path = Path(self._get_output_folder(), wasm_file_renamed)
+        wasm_file_renamed_path = Path(self.get_output_folder(), wasm_file_renamed)
         shutil.move(wasm_file, wasm_file_renamed_path)
 
-        if self._has_abi():
-            abi_file = self._get_abi_filepath()
-            abi_file_renamed = Path(self._get_output_folder(), f"{original_name}.abi.json")
+        if self.has_abi():
+            abi_file = self.get_abi_filepath()
+            abi_file_renamed = Path(self.get_output_folder(), f"{original_name}.abi.json")
             shutil.move(abi_file, abi_file_renamed)
 
         return wasm_file_renamed_path
 
     def get_dependencies(self):
         return ["rust"]
 
-    def _get_env(self):
+    def get_env(self):
         return dependencies.get_module_by_key("rust").get_env()
 
 
 class CargoFile:
     data: Dict[str, Any]
 
-    def __init__(self, path):
+    def __init__(self, path: Path):
         self.data = {}
         self.path = path
 

erdpy/utils.py

@@ -79,7 +79,7 @@ def uniquify(path: Path) -> Path:
     return path
 
 
-def read_lines(file: str):
+def read_lines(file: str) -> List[str]:
     with open(file) as f:
         lines = f.readlines()
     lines = [line.strip() for line in lines]