graphql-idl-parser 0.1.0 → 0.1.1

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/src/lib.rs

@@ -0,0 +1,128 @@
+extern crate libc;
+extern crate graphql_idl_parser;
+
+mod types;
+
+use types::*;
+
+use libc::{c_char, size_t};
+use std::ffi::CStr;
+use std::mem;
+use std::io::{self, Write};
+
+#[repr(C)]
+pub union GraphQLType {
+    scalar: Scalar,
+    object: Object,
+    enum_type: Enum,
+    interface: Interface,
+    union: Union,
+    input_object: InputObject,
+}
+
+#[no_mangle]
+#[allow(unused)]
+pub extern "C" fn gqlidl_parse_schema(
+    schema: *const c_char,
+    types: *mut *mut GraphQLType,
+    types_len: *mut size_t,
+) -> u8 {
+    // Convert C string to Rust string
+    let c_schema = unsafe {
+        assert!(!schema.is_null());
+        CStr::from_ptr(schema)
+    };
+    let r_schema = c_schema.to_str().unwrap();
+
+    match graphql_idl_parser::gqlidl::parse_schema(r_schema) {
+        Ok(vec) => {
+            let mut tmp_vec: Vec<GraphQLType> = vec.into_iter()
+                .map(|mut v| {
+                    let s = match v.typename() {
+                        "scalar" => {
+                            let d = Scalar::new(v.typename(), v.description(), v.name());
+                            return GraphQLType { scalar: d };
+                        }
+                        "object" => {
+                            let d = Object::new(
+                                v.typename(),
+                                v.description(),
+                                v.name(),
+                                v.implements(),
+                                v.directives(),
+                                v.fields(),
+                            );
+                            return GraphQLType { object: d };
+                        }
+                        "enum" => {
+                            let d = Enum::new(
+                                v.typename(),
+                                v.description(),
+                                v.name(),
+                                v.directives(),
+                                v.values(),
+                            );
+                            return GraphQLType { enum_type: d };
+                        }
+                        "interface" => {
+                            let d = Interface::new(
+                                v.typename(),
+                                v.description(),
+                                v.name(),
+                                v.directives(),
+                                v.fields(),
+                            );
+                            return GraphQLType { interface: d };
+                        }
+                        "union" => {
+                            let d = Union::new(
+                                v.typename(),
+                                v.description(),
+                                v.name(),
+                                v.directives(),
+                                v.types(),
+                            );
+                            return GraphQLType { union: d };
+                        }
+                        "input_object" => {
+                            let d = InputObject::new(
+                                v.typename(),
+                                v.description(),
+                                v.name(),
+                                v.directives(),
+                                v.fields(),
+                            );
+                            return GraphQLType { input_object: d };
+                        }
+                        _ => panic!("Unknown typename: {}", v.typename()),
+                    };
+
+                    mem::forget(v);
+                    s
+                })
+                .collect();
+
+            tmp_vec.shrink_to_fit();
+            assert!(tmp_vec.len() == tmp_vec.capacity());
+
+            // Return number of types
+            unsafe {
+                *types_len = tmp_vec.len() as size_t;
+            }
+
+            // Return pointer to data
+            unsafe {
+                *types = tmp_vec.as_mut_ptr();
+            }
+
+            // Prevent memory from being deallocated
+            mem::forget(tmp_vec);
+
+            0
+        }
+        Err(err) => {
+            writeln!(io::stderr(), "Catastrophic error: {:?}", err).unwrap();
+            1
+        }
+    }
+}

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/src/types.rs

@@ -0,0 +1,485 @@
+extern crate graphql_idl_parser;
+
+use graphql_idl_parser::type_definition::{GraphQLDirective, GraphQLField, GraphQLValue};
+
+use libc::{c_char, c_void, size_t};
+use std::ffi::CString;
+use std::{mem, ptr};
+
+fn convert_optional_string_to_cstr(string: Option<&str>) -> *const c_char {
+    match string {
+        Some(string) => CString::new(string).unwrap().into_raw(),
+        None => ptr::null(),
+    }
+}
+
+#[derive(Copy)]
+#[repr(C)]
+pub struct Scalar {
+    pub typename: *const c_char,
+    pub description: *const c_char,
+    pub name: *const c_char,
+}
+
+impl Clone for Scalar {
+    fn clone(&self) -> Scalar {
+        *self
+    }
+}
+
+impl Scalar {
+    pub fn new(typename: &str, description: Option<&str>, name: &str) -> Scalar {
+        Scalar {
+            typename: CString::new(typename).unwrap().into_raw(),
+            description: convert_optional_string_to_cstr(description),
+            name: CString::new(name).unwrap().into_raw(),
+        }
+    }
+}
+
+#[derive(Copy)]
+#[repr(C)]
+pub struct Object {
+    typename: *const c_char,
+    description: *const c_char,
+    name: *const c_char,
+    implements: ArrayOfCStrings,
+    directives: ArrayOfDirectives,
+    fields: ArrayOfFields,
+}
+
+impl Clone for Object {
+    fn clone(&self) -> Object {
+        *self
+    }
+}
+
+impl Object {
+    pub fn new(
+        typename: &str,
+        description: Option<&str>,
+        name: &str,
+        implements: Option<Vec<String>>,
+        directives: Option<Vec<GraphQLDirective>>,
+        fields: Option<Vec<GraphQLField>>,
+    ) -> Object {
+        Object {
+            typename: CString::new(typename).unwrap().into_raw(),
+            description: convert_optional_string_to_cstr(description),
+            name: CString::new(name).unwrap().into_raw(),
+            implements: match implements {
+                None => ArrayOfCStrings::from_vec(vec![]),
+                Some(implements) => ArrayOfCStrings::from_vec(implements),
+            },
+            directives: match directives {
+                None => ArrayOfDirectives::from_vec(vec![]),
+                Some(directives) => ArrayOfDirectives::from_vec(directives),
+            },
+            fields: match fields {
+                None => ArrayOfFields::from_vec(vec![]),
+                Some(fields) => ArrayOfFields::from_vec(fields),
+            },
+        }
+    }
+}
+
+
+#[derive(Copy)]
+#[repr(C)]
+pub struct Enum {
+    typename: *const c_char,
+    description: *const c_char,
+    name: *const c_char,
+    directives: ArrayOfDirectives,
+    values: ArrayOfValues,
+}
+
+impl Clone for Enum {
+    fn clone(&self) -> Enum {
+        *self
+    }
+}
+
+impl Enum {
+    pub fn new(
+        typename: &str,
+        description: Option<&str>,
+        name: &str,
+        directives: Option<Vec<GraphQLDirective>>,
+        values: Option<Vec<GraphQLValue>>,
+    ) -> Enum {
+        Enum {
+            typename: CString::new(typename).unwrap().into_raw(),
+            description: convert_optional_string_to_cstr(description),
+            name: CString::new(name).unwrap().into_raw(),
+            directives: match directives {
+                None => ArrayOfDirectives::from_vec(vec![]),
+                Some(directives) => ArrayOfDirectives::from_vec(directives),
+            },
+            values: match values {
+                None => ArrayOfValues::from_vec(vec![]),
+                Some(values) => ArrayOfValues::from_vec(values),
+            },
+        }
+    }
+}
+
+#[derive(Copy)]
+#[repr(C)]
+pub struct Interface {
+    typename: *const c_char,
+    description: *const c_char,
+    name: *const c_char,
+    directives: ArrayOfDirectives,
+    fields: ArrayOfFields,
+}
+
+impl Clone for Interface {
+    fn clone(&self) -> Interface {
+        *self
+    }
+}
+
+impl Interface {
+    pub fn new(
+        typename: &str,
+        description: Option<&str>,
+        name: &str,
+        directives: Option<Vec<GraphQLDirective>>,
+        fields: Option<Vec<GraphQLField>>,
+    ) -> Interface {
+        Interface {
+            typename: CString::new(typename).unwrap().into_raw(),
+            description: convert_optional_string_to_cstr(description),
+            name: CString::new(name).unwrap().into_raw(),
+            directives: match directives {
+                None => ArrayOfDirectives::from_vec(vec![]),
+                Some(directives) => ArrayOfDirectives::from_vec(directives),
+            },
+            fields: match fields {
+                None => ArrayOfFields::from_vec(vec![]),
+                Some(fields) => ArrayOfFields::from_vec(fields),
+            },
+        }
+    }
+}
+
+#[derive(Copy)]
+#[repr(C)]
+pub struct Union {
+    typename: *const c_char,
+    description: *const c_char,
+    name: *const c_char,
+    directives: ArrayOfDirectives,
+    types: ArrayOfCStrings,
+}
+
+impl Clone for Union {
+    fn clone(&self) -> Union {
+        *self
+    }
+}
+
+impl Union {
+    pub fn new(
+        typename: &str,
+        description: Option<&str>,
+        name: &str,
+        directives: Option<Vec<GraphQLDirective>>,
+        types: Option<Vec<String>>,
+    ) -> Union {
+        Union {
+            typename: CString::new(typename).unwrap().into_raw(),
+            description: convert_optional_string_to_cstr(description),
+            name: CString::new(name).unwrap().into_raw(),
+            directives: match directives {
+                None => ArrayOfDirectives::from_vec(vec![]),
+                Some(directives) => ArrayOfDirectives::from_vec(directives),
+            },
+            types: match types {
+                None => ArrayOfCStrings::from_vec(vec![]),
+                Some(types) => ArrayOfCStrings::from_vec(types),
+            },
+        }
+    }
+}
+
+#[derive(Copy)]
+#[repr(C)]
+pub struct InputObject {
+    typename: *const c_char,
+    description: *const c_char,
+    name: *const c_char,
+    directives: ArrayOfDirectives,
+    fields: ArrayOfFields,
+}
+
+impl Clone for InputObject {
+    fn clone(&self) -> InputObject {
+        *self
+    }
+}
+
+impl InputObject {
+    pub fn new(
+        typename: &str,
+        description: Option<&str>,
+        name: &str,
+        directives: Option<Vec<GraphQLDirective>>,
+        fields: Option<Vec<GraphQLField>>,
+    ) -> InputObject {
+        InputObject {
+            typename: CString::new(typename).unwrap().into_raw(),
+            description: convert_optional_string_to_cstr(description),
+            name: CString::new(name).unwrap().into_raw(),
+            directives: match directives {
+                None => ArrayOfDirectives::from_vec(vec![]),
+                Some(directives) => ArrayOfDirectives::from_vec(directives),
+            },
+            fields: match fields {
+                None => ArrayOfFields::from_vec(vec![]),
+                Some(fields) => ArrayOfFields::from_vec(fields),
+            },
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct FieldType {
+    name: *const c_char,
+    type_info: *const c_char,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Argument {
+    description: *const c_char,
+    name: *const c_char,
+    type_info: FieldType,
+    default_value: *const c_char,
+    directives: ArrayOfDirectives,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ArrayOfArguments {
+    length: size_t,
+    values: *const *const c_void,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Field {
+    description: *const c_char,
+    name: *const c_char,
+    type_info: FieldType,
+    arguments: ArrayOfArguments,
+    directives: ArrayOfDirectives,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ArrayOfFields {
+    length: size_t,
+    values: *const *const c_void,
+}
+
+impl ArrayOfFields {
+    fn from_vec(vec: Vec<GraphQLField>) -> ArrayOfFields {
+        let mut field_vec: Vec<Field> = vec![];
+
+        for v in vec {
+            let mut argument_vec: Vec<Argument> = vec![];
+            match v.arguments() {
+                None => {}
+                Some(arguments) => for arg in arguments {
+                    argument_vec.push(Argument {
+                        name: CString::new(arg.name()).unwrap().into_raw(),
+                        description: convert_optional_string_to_cstr(arg.description()),
+                        type_info: FieldType {
+                            name: CString::new(arg.typeinfo().name()).unwrap().into_raw(),
+                            type_info: CString::new(arg.typeinfo().info()).unwrap().into_raw(),
+                        },
+                        default_value: convert_optional_string_to_cstr(arg.default()),
+                        directives: match v.directives() {
+                            None => ArrayOfDirectives::from_vec(vec![]),
+                            Some(directives) => ArrayOfDirectives::from_vec(directives),
+                        },
+                    });
+                },
+            }
+
+            argument_vec.shrink_to_fit();
+
+            let arguments = ArrayOfArguments {
+                length: argument_vec.len() as size_t,
+                values: argument_vec.as_ptr() as *const *const c_void,
+            };
+
+            field_vec.push(Field {
+                description: convert_optional_string_to_cstr(v.description()),
+                name: CString::new(v.name()).unwrap().into_raw(),
+                type_info: FieldType {
+                    name: CString::new(v.typeinfo().name()).unwrap().into_raw(),
+                    type_info: CString::new(v.typeinfo().info()).unwrap().into_raw(),
+                },
+                arguments: arguments,
+                directives: match v.directives() {
+                    None => ArrayOfDirectives::from_vec(vec![]),
+                    Some(directives) => ArrayOfDirectives::from_vec(directives),
+                },
+            });
+
+            mem::forget(argument_vec);
+        }
+        field_vec.shrink_to_fit();
+
+        let array = ArrayOfFields {
+            length: field_vec.len() as size_t,
+            values: field_vec.as_ptr() as *const *const c_void,
+        };
+
+        mem::forget(field_vec);
+        array
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ArrayOfCStrings {
+    length: size_t,
+    values: *const *const c_char,
+}
+
+impl ArrayOfCStrings {
+    fn from_vec(vec: Vec<String>) -> ArrayOfCStrings {
+        let mut cstr_vec: Vec<*const c_char> = vec![];
+        for s in vec {
+            let cstr = CString::new(s).unwrap();
+            cstr_vec.push(cstr.into_raw() as *const c_char);
+        }
+        cstr_vec.shrink_to_fit();
+
+        let array = ArrayOfCStrings {
+            length: cstr_vec.len() as size_t,
+            values: cstr_vec.as_ptr() as *const *const c_char,
+        };
+
+        mem::forget(cstr_vec);
+        array
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Value {
+    description: *const c_char,
+    name: *const c_char,
+    directives: ArrayOfDirectives,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ArrayOfValues {
+    length: size_t,
+    values: *const *const c_void,
+}
+
+impl ArrayOfValues {
+    fn from_vec(vec: Vec<GraphQLValue>) -> ArrayOfValues {
+        let mut value_vec: Vec<Value> = vec![];
+
+        for v in vec {
+            value_vec.push(Value {
+                name: CString::new(v.name()).unwrap().into_raw(),
+                description: convert_optional_string_to_cstr(v.description()),
+                directives: match v.directives() {
+                    None => ArrayOfDirectives::from_vec(vec![]),
+                    Some(directives) => ArrayOfDirectives::from_vec(directives),
+                },
+            });
+        }
+        value_vec.shrink_to_fit();
+
+        let array = ArrayOfValues {
+            length: value_vec.len() as size_t,
+            values: value_vec.as_ptr() as *const *const c_void,
+        };
+
+        mem::forget(value_vec);
+
+        array
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Directive {
+    name: *const c_char,
+    arguments: ArrayOfDirectiveArguments,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ArrayOfDirectives {
+    length: size_t,
+    values: *const *const c_void,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct DirectiveArgument {
+    name: *const c_char,
+    value: *const c_char,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ArrayOfDirectiveArguments {
+    length: size_t,
+    values: *const *const c_void,
+}
+
+impl ArrayOfDirectives {
+    fn from_vec(vec: Vec<GraphQLDirective>) -> ArrayOfDirectives {
+        let mut value_vec: Vec<Directive> = vec![];
+
+        for v in vec {
+            let mut argument_vec: Vec<DirectiveArgument> = vec![];
+            match v.arguments() {
+                None => {}
+                Some(arguments) => for arg in arguments {
+                    argument_vec.push(DirectiveArgument {
+                        name: CString::new(arg.name()).unwrap().into_raw(),
+                        value: convert_optional_string_to_cstr(arg.value()),
+                    });
+                },
+            }
+
+            argument_vec.shrink_to_fit();
+
+            let arguments = ArrayOfDirectiveArguments {
+                length: argument_vec.len() as size_t,
+                values: argument_vec.as_ptr() as *const *const c_void,
+            };
+
+            value_vec.push(Directive {
+                name: CString::new(v.name()).unwrap().into_raw(),
+                arguments: arguments,
+            });
+
+            mem::forget(argument_vec);
+        }
+        value_vec.shrink_to_fit();
+
+        let array = ArrayOfDirectives {
+            length: value_vec.len() as size_t,
+            values: value_vec.as_ptr() as *const *const c_void,
+        };
+
+        mem::forget(value_vec);
+
+        array
+    }
+}