use crate::{
SplitDependency as RustSplitDependency, SplitPackage as RustSplitPackage,
SrcInfo as RustSrcInfo,
};
use pyo3::{create_exception, exceptions::PyException, prelude::*};
create_exception!(
makedeb_srcinfo,
ParserError,
PyException,
"A class representing the output of a parsing error."
);
#[pyclass]
struct SrcInfo {
srcinfo: RustSrcInfo,
}
#[pymethods]
impl SrcInfo {
#[new]
fn new(content: String) -> PyResult<Self> {
match RustSrcInfo::new(&content) {
Ok(srcinfo) => Ok(SrcInfo { srcinfo }),
Err(err) => {
let msg: String;
if let Some(line_num) = err.line_num {
msg = format!("[Line {}] {}", line_num, err.msg);
} else {
msg = err.msg;
}
let py_err = ParserError::new_err(msg);
Err(py_err)
}
}
}
pub fn get_string(&self, key: String) -> Option<String> {
self.srcinfo.get_string(&key).cloned()
}
pub fn get_array(&self, key: String) -> Option<Vec<String>> {
self.srcinfo.get_array(&key).cloned()
}
pub fn get_extended_values(&self, key: String) -> Option<Vec<String>> {
self.srcinfo.get_extended_values(&key)
}
}
#[allow(dead_code)]
#[derive(Clone)]
#[pyclass(dict)]
pub struct SplitPackage {
#[pyo3(get, set)]
pub pkgname: String,
#[pyo3(get, set)]
pub operator: Option<String>,
#[pyo3(get, set)]
pub version: Option<String>,
}
#[pymethods]
impl SplitPackage {
#[new]
fn new(pkg_string: String) -> Self {
let split_pkg = RustSplitPackage::new(&pkg_string);
Self {
pkgname: split_pkg.pkgname,
operator: split_pkg.operator,
version: split_pkg.version,
}
}
}
impl SplitPackage {
fn to_rust_split_package(&self) -> RustSplitPackage {
RustSplitPackage {
pkgname: self.pkgname.clone(),
operator: self.operator.clone(),
version: self.version.clone(),
}
}
}
#[derive(Clone)]
#[pyclass(dict)]
pub struct SplitDependency {
#[pyo3(get, set)]
pub deps: Vec<SplitPackage>,
}
#[pymethods]
impl SplitDependency {
#[new]
fn new(dep_string: String) -> Self {
let mut deps = vec![];
for dep in RustSplitDependency::new(&dep_string).deps {
deps.push(SplitPackage {
pkgname: dep.pkgname,
operator: dep.operator,
version: dep.version,
});
}
Self { deps }
}
fn as_control(&self) -> String {
let mut deps = vec![];
for dep in &self.deps {
deps.push(dep.to_rust_split_package());
}
RustSplitDependency::internal_as_control(&deps)
}
}
#[pymodule]
fn makedeb_srcinfo(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
m.add_class::<SrcInfo>()?;
m.add_class::<SplitPackage>()?;
m.add_class::<SplitDependency>()?;
Ok(())
}