lua 프로젝트 레이아웃 변경

src/ffi/mod.rs

@@ -0,0 +1,57 @@
+use std::ffi::{CStr, CString};
+use std::os::raw::{c_char, c_void};
+
+use {parser, select, select_as_str};
+
+const INVALID_PATH: &str = "invalid path";
+const INVALID_JSON: &str = "invalud json";
+
+fn to_str(v: *const c_char, err_msg: &str) -> &str {
+    unsafe { CStr::from_ptr(v) }.to_str().expect(err_msg)
+}
+
+fn to_char_ptr(v: &str) -> *const c_char {
+    let s = CString::new(v).expect(&format!("invalid string: {}", v));
+    let ptr = s.as_ptr();
+    std::mem::forget(s);
+    ptr
+}
+
+#[no_mangle]
+pub extern "C" fn ffi_select(json_str: *const c_char, path: *const c_char) -> *const c_char {
+    let json_str = to_str(json_str, INVALID_JSON);
+    let path = to_str(path, INVALID_PATH);
+    match select_as_str(json_str, path) {
+        Ok(v) => to_char_ptr(v.as_str()),
+        Err(e) => {
+            panic!("{:?}", e);
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn ffi_path_compile(path: *const c_char) -> *mut c_void {
+    let path = to_str(path, INVALID_PATH);
+    let ref_node = Box::into_raw(Box::new(parser::Parser::compile(path).unwrap()));
+    let ptr = ref_node as *mut c_void;
+    std::mem::forget(ref_node);
+    ptr
+}
+
+#[no_mangle]
+pub extern "C" fn ffi_select_with_compiled_path(
+    path_ptr: *mut c_void,
+    json_ptr: *const c_char,
+) -> *const c_char {
+    let node = unsafe { Box::from_raw(path_ptr as *mut parser::Node) };
+    let json_str = to_str(json_ptr, INVALID_JSON);
+    let json = serde_json::from_str(json_str).expect(&format!("invalid json string: {}", json_str));
+
+    let mut selector = select::Selector::default();
+    let found = selector.compiled_path(&node).value(&json).select().unwrap();
+    std::mem::forget(node);
+
+    let result =
+        serde_json::to_string(&found).expect(&format!("json serialize error: {:?}", found));
+    to_char_ptr(result.as_str())
+}

src/lib.rs

@@ -135,9 +135,9 @@ use serde_json::Value;
 pub use parser::Parser;
 pub use select::JsonPathError;
 pub use select::{Selector, SelectorMut};
-use std::ffi::{CStr, CString};
-use std::os::raw::{c_char, c_void};
 
+#[doc(hidden)]
+mod ffi;
 #[doc(hidden)]
 mod parser;
 #[doc(hidden)]
@@ -468,71 +468,3 @@ where
     let value = selector.str_path(path)?.value(value).replace_with(fun)?;
     Ok(value.take().unwrap_or(Value::Null))
 }
-
-
-#[no_mangle]
-pub extern "C" fn ffi_select(json_str: *const c_char, path: *const c_char) -> *const c_char {
-    let json_str = match unsafe { CStr::from_ptr(json_str) }.to_str() {
-        Ok(s) => s,
-        Err(e) => {
-            panic!("{:?}", e);
-        }
-    };
-
-    let path = match unsafe { CStr::from_ptr(path) }.to_str() {
-        Ok(s) => s,
-        Err(e) => {
-            panic!("{:?}", e);
-        }
-    };
-
-    match select_as_str(json_str, path) {
-        Ok(v) => match serde_json::to_string(&v) {
-            Ok(s) => {
-                let s = CString::new(s.as_str()).unwrap();
-                let p = s.as_ptr();
-                std::mem::forget(s);
-                p
-            }
-            Err(e) => {
-                panic!("{:?}", e);
-            }
-        },
-        Err(e) => {
-            panic!("{:?}", e);
-        }
-    }
-}
-
-
-#[no_mangle]
-pub extern "C" fn ffi_path_compile(path: *const c_char) -> *mut c_void {
-    let path = match unsafe { CStr::from_ptr(path) }.to_str() {
-        Ok(s) => s,
-        Err(e) => {
-            panic!("{:?}", e);
-        }
-    };
-
-    Box::into_raw(Box::new(Parser::compile(path).unwrap())) as *mut c_void
-}
-
-#[no_mangle]
-pub extern "C" fn ffi_select_with_compiled(
-    path_ptr: *mut c_void,
-    json_ptr: *const c_char,
-) -> *const c_char {
-    let node = unsafe { Box::from_raw(path_ptr as *mut parser::Node) };
-    let json_str = unsafe { CStr::from_ptr(json_ptr) }.to_str().expect("invalid 'json_ptr' input");
-    let json = serde_json::from_str(json_str).expect(&format!("invalid json string: {}", json_str));
-
-    let mut selector = Selector::default();
-    let found = selector.compiled_path(&node).value(&json).select().unwrap();
-    std::mem::forget(node);
-
-    let result = serde_json::to_string(&found).expect(&format!("json serialize error: {:?}", found));
-    let result_cstring = CString::new(result.as_str()).expect(&format!("empty result: {:?}", result));
-    let result_ptr = result_cstring.as_ptr();
-    std::mem::forget(result_cstring);
-    result_ptr
-}

src/select/mod.rs

@@ -2,10 +2,10 @@ use std::collections::HashSet;
 use std::fmt;
 
 use array_tool::vec::{Intersect, Union};
+use serde_json::map::Entry;
 use serde_json::{Number, Value};
 
 use parser::*;
-use serde_json::map::Entry;
 
 fn to_f64(n: &Number) -> f64 {
     if n.is_i64() {