python/ffi spike

.gitignore

@@ -1,4 +1,6 @@
 /target
 /Cargo.lock
+/cargo/*/Cargo.toml
+/cargo/*/Cargo.lock
 /*.profraw
-.idea
+.idea

Makefile

@@ -0,0 +1,33 @@
+DEV_DEP_LINE = $(shell cat Cargo.toml | grep -n "\[dev-dependencies\]" | cut -d : -f 1)
+LINE = $(shell echo $$(( $(DEV_DEP_LINE) - 2 )))
+LINES = $(shell cat Cargo.toml | wc -l)
+TAIL_LINES = $(shell echo $$(( $(LINES) - $(LINE) )))
+
+python:
+	@head -n $(LINE) Cargo.toml > cargo/$@/Cargo.toml
+	@echo "pyo3 = { version = \"0.18.0\", features = [\"abi3\", \"extension-module\"] }" >> cargo/$@/Cargo.toml
+	@tail -n $(TAIL_LINES) Cargo.toml >> cargo/$@/Cargo.toml
+	@echo >> cargo/$@/Cargo.toml
+	@cat cargo/$@/Cargo.toml.tail >> cargo/$@/Cargo.toml
+	@cd cargo/$@ && cargo build --release --target-dir ../../target/$@
+	@mv target/$@/release/libcesride.dylib target/$@/release/cesride.so
+
+python-shell:
+	@cd target/python/release/ && python3
+
+rust:
+	@cargo build --release
+
+libs: rust python
+
+clean:
+	cargo clean
+
+preflight:
+	cargo fmt
+	cargo fix
+	cargo clippy -- -D warnings
+	cargo build --release
+	cargo test --release
+	cargo audit
+	cargo tarpaulin

cargo/python/.cargo/config.toml

@@ -0,0 +1,11 @@
+[target.x86_64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]

cargo/python/Cargo.toml.tail

@@ -0,0 +1,11 @@
+[lib]
+path = "../../src/lib_python.rs"
+test = false
+doctest = false
+bench = true
+doc = true
+crate-type = ["cdylib"]
+
+[features]
+default = ["python"]
+python = []

src/core/counter/mod.rs

@@ -1,4 +1,4 @@
-pub(crate) mod tables;
+pub mod tables;
 
 use crate::core::util;
 use crate::error::{err, Error, Result};

src/core/diger.rs

@@ -5,7 +5,7 @@ use crate::error::{err, Error, Result};
 
 type Blake2b256 = blake2::Blake2b<blake2::digest::consts::U32>;
 
-trait Diger {
+pub trait Diger {
     fn new_with_code_and_raw(code: &str, raw: &[u8]) -> Result<Matter>
     where
         Self: Sized;

src/core/matter/mod.rs

@@ -1,17 +1,102 @@
-pub(crate) mod tables;
+#[cfg(feature = "python")]
+use pyo3::{
+    exceptions::{PyException, PyValueError},
+    prelude::*,
+};
 
 use base64::{engine::general_purpose as b64_engine, Engine};
 
 use crate::core::util;
 use crate::error::{err, Error, Result};
 
+pub mod tables;
+
+#[cfg_attr(feature = "python", pyclass)]
 #[derive(Debug, Clone)]
 pub struct Matter {
     pub(crate) raw: Vec<u8>,
     pub(crate) code: String,
     pub(crate) size: u32,
 }
 
+#[cfg(feature = "python")]
+#[pymethods]
+impl Matter {
+    #[new]
+    fn py_new(
+        code: Option<&str>,
+        raw: Option<&[u8]>,
+        raw_size: Option<usize>,
+        qb64: Option<&str>,
+        qb64b: Option<&[u8]>,
+        qb2: Option<&[u8]>,
+        strip: Option<bool>,
+    ) -> PyResult<Self> {
+        let result = if let Some(code) = code {
+            let (raw, raw_size) = if raw.is_none() || raw_size.is_none() {
+                return Err(PyValueError::new_err("code present, raw and raw_size missing"));
+            } else {
+                (raw.unwrap(), raw_size.unwrap())
+            };
+
+            Self::new_with_code_and_raw(code, raw, raw_size)
+        } else if let Some(qb64) = qb64 {
+            Self::new_with_qb64(qb64)
+        } else if let Some(qb64b) = qb64b {
+            Self::new_with_qb64b(qb64b)
+        } else if let Some(qb2) = qb2 {
+            Self::new_with_qb2(qb2)
+        } else {
+            return Err(PyValueError::new_err("must specify some parameters"));
+        };
+
+        match result {
+            Ok(matter) => {
+                if strip.is_some() && strip.unwrap() == true {
+                    todo!()
+                } else {
+                    Ok(matter)
+                }
+            }
+            Err(e) => Err(PyException::new_err(e.to_string())),
+        }
+    }
+
+    #[pyo3(name = "code")]
+    fn py_code(&self) -> String {
+        self.code()
+    }
+
+    #[pyo3(name = "raw")]
+    fn py_raw(&self) -> Vec<u8> {
+        self.raw()
+    }
+
+    #[pyo3(name = "qb64")]
+    fn py_qb64(&self) -> PyResult<String> {
+        match self.qb64() {
+            Ok(s) => Ok(s),
+            Err(e) => Err(PyException::new_err(e.to_string())),
+        }
+    }
+
+    #[pyo3(name = "qb64b")]
+    fn py_qb64b(&self) -> PyResult<Vec<u8>> {
+        match self.qb64b() {
+            Ok(b) => Ok(b),
+            Err(e) => Err(PyException::new_err(e.to_string())),
+        }
+    }
+
+    #[pyo3(name = "qb2")]
+    fn py_qb2(&self) -> PyResult<Vec<u8>> {
+        match self.qb2() {
+            Ok(b) => Ok(b),
+            Err(e) => Err(PyException::new_err(e.to_string())),
+        }
+    }
+}
+
 impl Matter {
     pub fn new_with_code_and_raw(code: &str, raw: &[u8], raw_size: usize) -> Result<Matter> {
         if code.is_empty() {
@@ -131,8 +216,6 @@ impl Matter {
         self.binfil()
     }
 
-    pub fn transferable() {}
-
     fn infil(&self) -> Result<String> {
         let code = &self.code;
         let size = self.size;

src/core/mod.rs

@@ -1,6 +1,6 @@
-mod cigar;
-mod counter;
-mod diger;
-mod matter;
-mod util;
-mod verfer;
+pub mod cigar;
+pub mod counter;
+pub mod diger;
+pub mod matter;
+pub mod util;
+pub mod verfer;

src/lib.rs

@@ -3,3 +3,10 @@
 
 mod core;
 mod error;
+
+pub use crate::core::cigar::Cigar;
+pub use crate::core::counter::{tables as counter, Counter};
+pub use crate::core::diger::Diger;
+pub use crate::core::matter::{tables as matter, Matter};
+pub use crate::core::util;
+pub use crate::core::verfer::Verfer;

src/lib_python.rs

@@ -0,0 +1,15 @@
+// TODO: remove before 1.0.0
+#![allow(dead_code)]
+
+use pyo3::prelude::*;
+
+mod core;
+mod error;
+
+pub use crate::core::matter::Matter; 
+
+#[pymodule]
+fn cesride(_py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<Matter>()?;
+    Ok(())
+}