feat: add c_api for dracula & minor refactoring (#4)

* feat: add `capi` for line-munch & minor refactoring

* Autofix issues in 1 file

Resolved issues in cdracula/src/lib.rs via DeepSource Autofix

* fix: for DeepSource

* fix: formatting and incomplete bits of code

* fix: cleanup code

* fix: bug & refactor apis

* Apply suggestions from code review

Signed-off-by: raghav-deepsource <[email protected]>

* fix: cleanup code

* chore: fix tests & move asserts to only debug builds

* remove: `log` crate

* chore: cleanup code with macros & update interfaces

---------

Signed-off-by: raghav-deepsource <[email protected]>
Co-authored-by: deepsource-autofix[bot] <62050782+deepsource-autofix[bot]@users.noreply.github.com>
Co-authored-by: raghav-deepsource <[email protected]>

Author: 3 people

Cargo.lock

@@ -1,8 +1,13 @@
+[workspace]
+members = [
+    "cdracula"
+]
+
 [package]
 name = "dracula"
 description = "🧛 Count-ing lines, AH AH AHH!"
 version = "0.1.0"
-author = "Swarnim Arun <[email protected]>"
+authors = ["Swarnim Arun <[email protected]>"]
 edition = "2021"
 license-file = "LICENSE"
 documentation = "https://docs.rs/dracula"

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "cdracula"
+description = "🧛 Count-ing lines, AH AH AHH!"
+version = "0.1.0"
+authors = ["Swarnim Arun <[email protected]>"]
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+dracula = { path = ".." }

cdracula/Cargo.toml

@@ -0,0 +1,202 @@
+//! Functions provided here are a wrapper around `dracula` crate
+#![deny(improper_ctypes_definitions)]
+#![allow(non_upper_case_globals)]
+
+mod util_macros;
+
+use dracula::parse::ParseOutput;
+use std::ffi::{self, c_char};
+
+languages_supported! {
+    const Python = 1;
+    const C = 2;
+    const Rust = 3;
+    const Java = 4;
+}
+
+#[no_mangle]
+pub static PYTHON_LANG: ffi::c_uint = Python;
+#[no_mangle]
+pub static C_LANG: ffi::c_uint = C;
+#[no_mangle]
+pub static RUST_LANG: ffi::c_uint = Rust;
+#[no_mangle]
+pub static JAVA_LANG: ffi::c_uint = Java;
+
+#[no_mangle]
+/// This function is used to get the count of meaningful lines in the source.
+///
+/// It currently doesn't support setting the multiple ways(`kind`) of meaningful line
+/// search eg. `ignore whitespace`, `specific character`, etc.
+/// aka the definition of a meaningful line.
+/// But provided as field to avoid ABI incompatibility later.
+pub unsafe fn get_meaningful_line_count(
+    src: *const c_char,
+    lang: ffi::c_uint,
+    _kind: ffi::c_uint,
+) -> ffi::c_ulonglong {
+    let Some(parser) = get_parser(lang) else {
+        return ffi::c_ulonglong::MAX
+    };
+    let Some(is_meaningful) = is_meaningful(lang) else {
+        return ffi::c_ulonglong::MAX
+    };
+    let cstr = ffi::CStr::from_ptr(src);
+    cstr.to_str()
+        .map(|src| {
+            let parsed = parser(src);
+            let mut line_count: usize = 0;
+            let mut stack = vec![];
+            for p in parsed {
+                if matches!(p, ParseOutput::EOL(_) | ParseOutput::EOF) {
+                    if stack.iter().any(is_meaningful) {
+                        line_count += 1;
+                    }
+                    // We clear the stack once we reach the end of a line.
+                    stack.clear();
+                } else {
+                    // we accumulate tokens we see as meaningful tokens for the language.
+                    stack.push(p);
+                }
+            }
+            line_count
+        })
+        .unwrap_or_default() as _
+}
+
+#[no_mangle]
+/// This function is used to get the list of meaningful lines in the source.
+///
+/// It currently doesn't support setting the multiple ways(`kind`) of meaningful line
+/// search eg. `ignore whitespace`, `specific character`, etc.
+/// aka the definition of a meaningful line.
+/// But provided as field to avoid ABI incompatibility later.
+///
+/// NOTE:
+/// The caller is responsible for free'ing the obtained array
+pub unsafe fn meaningful_lines(
+    src: *const c_char,
+    lang: ffi::c_uint,
+    _kind: ffi::c_uint,
+    r_lines_len: *mut ffi::c_ulonglong,
+) -> *mut ffi::c_ulonglong {
+    let Some(parser) = get_parser(lang) else {
+        return std::ptr::null_mut()
+    };
+    let Some(is_meaningful) = is_meaningful(lang) else {
+        return std::ptr::null_mut()
+    };
+    let mut meaningful_lines = Vec::<ffi::c_ulonglong>::new();
+    if cfg!(dbg) {
+        assert!(!src.is_null());
+    }
+    let cstr = ffi::CStr::from_ptr(src);
+    _ = cstr.to_str().map(|src| {
+        let mut parsed = parser(src);
+        let lines = src.split_inclusive('\n').enumerate();
+        struct Span {
+            start: usize,
+            end: usize,
+        }
+        let mut line_span = Span { start: 0, end: 0 };
+        let mut parse_span = Span { start: 0, end: 0 };
+        let mut last_parsed_output = None;
+        for (idx, line) in lines {
+            // setup line start and end
+            line_span.start = line_span.end;
+            line_span.end += line.len();
+            // traverse parsed output until the span end is reached
+            let mut po_stack = if let Some(po) = last_parsed_output {
+                vec![po]
+            } else {
+                vec![]
+            };
+            while parse_span.end < line_span.end {
+                if let Some(parsed_output) = parsed.next() {
+                    // setup parsed start and end
+                    parse_span.start = parse_span.end;
+                    parse_span.end += parsed_output.len();
+                    po_stack.push(parsed_output);
+                }
+            }
+            if po_stack.iter().any(is_meaningful) {
+                meaningful_lines.push(idx as u64);
+            }
+            if cfg!(dbg) {
+                eprintln!("{} == {}", idx, po_stack.iter().any(is_meaningful));
+                eprintln!("{:?}", po_stack);
+                eprintln!("-------------------------------------------------");
+            }
+            if parse_span.end != line_span.end {
+                last_parsed_output = po_stack.pop();
+            } else {
+                last_parsed_output = None;
+            }
+        }
+    });
+    meaningful_lines.shrink_to_fit();
+    if cfg!(dbg) {
+        assert!(meaningful_lines.len() == meaningful_lines.capacity());
+    }
+    let ptr = meaningful_lines.as_mut_ptr();
+    let len = meaningful_lines.len();
+    *r_lines_len = len as _;
+    std::mem::forget(meaningful_lines); // prevent deallocation in Rust
+    ptr
+}
+
+#[no_mangle]
+/// This function is used to get the source of just the meaningful parts in the source,
+/// including the whitespaces.
+///
+/// It currently doesn't support setting the multiple ways(`kind`) of meaningful line
+/// search eg. `ignore whitespace`, `specific character`, etc.
+/// aka the definition of a meaningful line.
+/// But provided as field to avoid ABI incompatibility later.
+///
+/// NOTE:
+/// The caller is responsible for free'ing the obtained array
+pub unsafe fn get_cleaned_src(
+    src: *const c_char,
+    lang: ffi::c_uint,
+    _kind: ffi::c_uint,
+    _exclude: ffi::c_uint,
+) -> *mut i8 {
+    let Some(parser) = get_parser(lang) else {
+        return std::ptr::null_mut()
+    };
+    let Some(is_meaningful_src) = is_meaningful_src(lang) else {
+        return std::ptr::null_mut()
+    };
+    let cstr = ffi::CStr::from_ptr(src);
+    let src = cstr
+        .to_str()
+        .map(|src| {
+            let parsed = parser(src);
+            let mut meaningful_src = String::default();
+            let mut stack = vec![];
+            for p in parsed {
+                if matches!(p, ParseOutput::EOL(_) | ParseOutput::EOF) {
+                    let meaningful_src_len = meaningful_src.len();
+                    for po in stack.iter() {
+                        if let ParseOutput::Source(s) = po {
+                            if is_meaningful_src(s) {
+                                meaningful_src.push_str(s);
+                            }
+                        }
+                    }
+                    if matches!(p, ParseOutput::EOL(_))
+                        && meaningful_src_len != meaningful_src.len()
+                    {
+                        meaningful_src.push('\n');
+                    }
+                    stack.clear();
+                } else {
+                    stack.push(p);
+                }
+            }
+            meaningful_src
+        })
+        .unwrap_or_default();
+    ffi::CString::from_vec_unchecked(src.into()).into_raw()
+}

cdracula/src/lib.rs

@@ -0,0 +1,35 @@
+#[macro_export]
+macro_rules! languages_supported {
+    ($(const $name:ident = $num:literal;)+) => {
+        $(
+            const $name: std::ffi::c_uint = $num;
+        )+
+        fn get_parser(lang: std::ffi::c_uint) -> Option<fn(&str) -> dracula::parse::Parser> {
+            use dracula::parse::Language;
+            $(
+                if lang == $name {
+                    return Some(dracula::langs::$name::get_parser());
+                }
+            )+
+            None
+        }
+        fn is_meaningful(lang: std::ffi::c_uint) -> Option<fn(&dracula::parse::ParseOutput) -> bool> {
+            use dracula::parse::Language;
+            $(
+                if lang == $name {
+                    return Some(dracula::langs::$name::is_meaningful());
+                }
+            )+
+            None
+        }
+        fn is_meaningful_src(lang: std::ffi::c_uint) -> Option<fn(&str) -> bool> {
+            use dracula::parse::Language;
+            $(
+                if lang == $name {
+                    return Some(dracula::langs::$name::is_meaningful_src);
+                }
+            )+
+            None
+        }
+    };
+}