graphql-idl-parser 0.1.0 → 0.1.1

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/test/clar/print.h

@@ -0,0 +1,74 @@
+
+static void clar_print_init(int test_count, int suite_count, const char *suite_names)
+{
+  (void)test_count;
+  printf("Loaded %d suites: %s\n", (int)suite_count, suite_names);
+  printf("Started\n");
+}
+
+static void clar_print_shutdown(int test_count, int suite_count, int error_count)
+{
+  (void)test_count;
+  (void)suite_count;
+  (void)error_count;
+
+  printf("\n\n");
+  clar_report_errors();
+}
+
+static void clar_print_error(int num, const struct clar_error *error)
+{
+  printf("  %d) Failure:\n", num);
+
+  printf("%s::%s [%s:%d]\n",
+         error->suite,
+         error->test,
+         error->file,
+         error->line_number);
+
+  printf("  %s\n", error->error_msg);
+
+  if (error->description != NULL) {
+    printf("  %s\n", error->description);
+  }
+
+  printf("\n");
+  fflush(stdout);
+}
+
+static void clar_print_ontest(const char *test_name, int test_number, enum cl_test_status status)
+{
+  (void)test_name;
+  (void)test_number;
+
+  switch(status) {
+  case CL_TEST_OK:
+    printf(".");
+    break;
+  case CL_TEST_FAILURE:
+    printf("F");
+    break;
+  case CL_TEST_SKIP:
+    printf("S");
+    break;
+  }
+
+  fflush(stdout);
+}
+
+static void clar_print_onsuite(const char *suite_name, int suite_index)
+{
+  if (_clar.report_suite_names) {
+    printf("\n%s", suite_name);
+  }
+
+  (void)suite_index;
+}
+
+static void clar_print_onabort(const char *msg, ...)
+{
+  va_list argp;
+  va_start(argp, msg);
+  vfprintf(stderr, msg, argp);
+  va_end(argp);
+}

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/test/clar/sandbox.h

@@ -0,0 +1,154 @@
+static char _clar_path[4096];
+
+static int
+is_valid_tmp_path(const char *path)
+{
+  STAT_T st;
+
+  if (stat(path, &st) != 0) {
+    return 0;
+  }
+
+  if (!S_ISDIR(st.st_mode)) {
+    return 0;
+  }
+
+  return (access(path, W_OK) == 0);
+}
+
+static int
+find_tmp_path(char *buffer, size_t length)
+{
+#ifndef _WIN32
+  static const size_t var_count = 5;
+  static const char *env_vars[] = {
+    "CLAR_TMP", "TMPDIR", "TMP", "TEMP", "USERPROFILE"
+  };
+
+  size_t i;
+
+  for (i = 0; i < var_count; ++i) {
+    const char *env = getenv(env_vars[i]);
+    if (!env) {
+      continue;
+    }
+
+    if (is_valid_tmp_path(env)) {
+      strncpy(buffer, env, length);
+      return 0;
+    }
+  }
+
+  /* If the environment doesn't say anything, try to use /tmp */
+  if (is_valid_tmp_path("/tmp")) {
+    strncpy(buffer, "/tmp", length);
+    return 0;
+  }
+
+#else
+  DWORD env_len = GetEnvironmentVariable("CLAR_TMP", buffer, (DWORD)length);
+  if (env_len > 0 && env_len < (DWORD)length) {
+    return 0;
+  }
+
+  if (GetTempPath((DWORD)length, buffer)) {
+    return 0;
+  }
+#endif
+
+  /* This system doesn't like us, try to use the current directory */
+  if (is_valid_tmp_path(".")) {
+    strncpy(buffer, ".", length);
+    return 0;
+  }
+
+  return -1;
+}
+
+static void clar_unsandbox(void)
+{
+  if (_clar_path[0] == '\0') {
+    return;
+  }
+
+  cl_must_pass(chdir(".."));
+
+  fs_rm(_clar_path);
+}
+
+static int build_sandbox_path(void)
+{
+#ifdef CLAR_TMPDIR
+  const char path_tail[] = CLAR_TMPDIR "_XXXXXX";
+#else
+  const char path_tail[] = "clar_tmp_XXXXXX";
+#endif
+
+  size_t len;
+
+  if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0) {
+    return -1;
+  }
+
+  len = strlen(_clar_path);
+
+#ifdef _WIN32
+  { /* normalize path to POSIX forward slashes */
+    size_t i;
+    for (i = 0; i < len; ++i) {
+      if (_clar_path[i] == '\\') {
+        _clar_path[i] = '/';
+      }
+    }
+  }
+#endif
+
+  if (_clar_path[len - 1] != '/') {
+    _clar_path[len++] = '/';
+  }
+
+  strncpy(_clar_path + len, path_tail, sizeof(_clar_path) - len);
+
+#if defined(__MINGW32__)
+  if (_mktemp(_clar_path) == NULL) {
+    return -1;
+  }
+
+  if (mkdir(_clar_path, 0700) != 0) {
+    return -1;
+  }
+#elif defined(_WIN32)
+  if (_mktemp_s(_clar_path, sizeof(_clar_path)) != 0) {
+    return -1;
+  }
+
+  if (mkdir(_clar_path, 0700) != 0) {
+    return -1;
+  }
+#else
+  if (mkdtemp(_clar_path) == NULL) {
+    return -1;
+  }
+#endif
+
+  return 0;
+}
+
+static int clar_sandbox(void)
+{
+  if (_clar_path[0] == '\0' && build_sandbox_path() < 0) {
+    return -1;
+  }
+
+  if (chdir(_clar_path) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+const char *clar_sandbox_path(void)
+{
+  return _clar_path;
+}
+

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/test/clar_test.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Vicent Marti. All rights reserved.
+ *
+ * This file is part of clar, distributed under the ISC license.
+ * For full terms see the included COPYING file.
+ */
+#ifndef __CLAR_TEST__
+#define __CLAR_TEST__
+
+/* Import the standard clar helper functions */
+#include "clar.h"
+
+/* Your custom shared includes / defines here */
+extern int global_test_counter;
+
+#include "helpers.h"
+#include "gql-idl-parser.h"
+
+#endif

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/test/enums.c

@@ -0,0 +1,40 @@
+#include "clar.h"
+#include "clar_test.h"
+#include <stdio.h>
+#include <string.h>
+
+static char *fixture;
+
+void test_enums__initialize(void)
+{
+  global_test_counter++;
+}
+
+void test_enums__cleanup(void)
+{
+  if (fixture != NULL) {
+    free(fixture);
+  }
+}
+
+void test_enums__inline(void)
+{
+  fixture = read_fixture("enums.graphql");
+
+  GraphQLTypes* types = NULL;
+  size_t types_len = 0;
+  uint8_t err;
+
+  err = gqlidl_parse_schema(fixture, &types, &types_len);
+
+  cl_assert_equal_i(err, 0);
+
+  cl_assert_equal_s(types[0].typename, "enum");
+  cl_assert_equal_s("ProjectState", types[0].enum_type.name);
+  cl_assert_equal_s("State of the project; either 'open' or 'closed'", types[0].enum_type.description);
+  cl_assert_equal_i(2, types[0].enum_type.values.length);
+  cl_assert_equal_s("CLOSED", types[0].enum_type.values.data[0].name);
+  cl_assert_equal_s("The project is closed.", types[0].enum_type.values.data[0].description);
+  cl_assert_equal_s("OPEN", types[0].enum_type.values.data[1].name);
+  cl_assert_equal_s("The project is open.", types[0].enum_type.values.data[1].description);
+}

data/ext/graphql-idl-parser/graphql-idl-parser/graphql-idl-parser-ffi/test/generate.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python
+#
+# Copyright (c) Vicent Marti. All rights reserved.
+#
+# This file is part of clar, distributed under the ISC license.
+# For full terms see the included COPYING file.
+#
+
+from __future__ import with_statement
+from string import Template
+import re, fnmatch, os, codecs, pickle
+
+class Module(object):
+    class Template(object):
+        def __init__(self, module):
+            self.module = module
+
+        def _render_callback(self, cb):
+            if not cb:
+                return '    { NULL, NULL }'
+            return '    { "%s", &%s }' % (cb['short_name'], cb['symbol'])
+
+    class DeclarationTemplate(Template):
+        def render(self):
+            out = "\n".join("extern %s;" % cb['declaration'] for cb in self.module.callbacks) + "\n"
+
+            if self.module.initialize:
+                out += "extern %s;\n" % self.module.initialize['declaration']
+
+            if self.module.cleanup:
+                out += "extern %s;\n" % self.module.cleanup['declaration']
+
+            return out
+
+    class CallbacksTemplate(Template):
+        def render(self):
+            out = "static const struct clar_func _clar_cb_%s[] = {\n" % self.module.name
+            out += ",\n".join(self._render_callback(cb) for cb in self.module.callbacks)
+            out += "\n};\n"
+            return out
+
+    class InfoTemplate(Template):
+        def render(self):
+            return Template(
+            r"""
+    {
+        "${clean_name}",
+    ${initialize},
+    ${cleanup},
+        ${cb_ptr}, ${cb_count}, ${enabled}
+    }"""
+            ).substitute(
+                clean_name = self.module.clean_name(),
+                initialize = self._render_callback(self.module.initialize),
+                cleanup = self._render_callback(self.module.cleanup),
+                cb_ptr = "_clar_cb_%s" % self.module.name,
+                cb_count = len(self.module.callbacks),
+                enabled = int(self.module.enabled)
+            )
+
+    def __init__(self, name):
+        self.name = name
+
+        self.mtime = 0
+        self.enabled = True
+        self.modified = False
+
+    def clean_name(self):
+        return self.name.replace("_", "::")
+
+    def _skip_comments(self, text):
+        SKIP_COMMENTS_REGEX = re.compile(
+            r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
+            re.DOTALL | re.MULTILINE)
+
+        def _replacer(match):
+            s = match.group(0)
+            return "" if s.startswith('/') else s
+
+        return re.sub(SKIP_COMMENTS_REGEX, _replacer, text)
+
+    def parse(self, contents):
+        TEST_FUNC_REGEX = r"^(void\s+(test_%s__(\w+))\s*\(\s*void\s*\))\s*\{"
+
+        contents = self._skip_comments(contents)
+        regex = re.compile(TEST_FUNC_REGEX % self.name, re.MULTILINE)
+
+        self.callbacks = []
+        self.initialize = None
+        self.cleanup = None
+
+        for (declaration, symbol, short_name) in regex.findall(contents):
+            data = {
+                "short_name" : short_name,
+                "declaration" : declaration,
+                "symbol" : symbol
+            }
+
+            if short_name == 'initialize':
+                self.initialize = data
+            elif short_name == 'cleanup':
+                self.cleanup = data
+            else:
+                self.callbacks.append(data)
+
+        return self.callbacks != []
+
+    def refresh(self, path):
+        self.modified = False
+
+        try:
+            st = os.stat(path)
+
+            # Not modified
+            if st.st_mtime == self.mtime:
+                return True
+
+            self.modified = True
+            self.mtime = st.st_mtime
+
+            with codecs.open(path, encoding='utf-8') as fp:
+                raw_content = fp.read()
+
+        except IOError:
+            return False
+
+        return self.parse(raw_content)
+
+class TestSuite(object):
+
+    def __init__(self, path):
+        self.path = path
+
+    def should_generate(self, path):
+        if not os.path.isfile(path):
+            return True
+
+        if any(module.modified for module in self.modules.values()):
+            return True
+
+        return False
+
+    def find_modules(self):
+        modules = []
+        for root, _, files in os.walk(self.path):
+            module_root = root[len(self.path):]
+            module_root = [c for c in module_root.split(os.sep) if c]
+
+            tests_in_module = fnmatch.filter(files, "*.c")
+
+            for test_file in tests_in_module:
+                full_path = os.path.join(root, test_file)
+                module_name = "_".join(module_root + [test_file[:-2]]).replace("-", "_")
+
+                modules.append((full_path, module_name))
+
+        return modules
+
+    def load_cache(self):
+        path = os.path.join(self.path, '.clarcache')
+        cache = {}
+
+        try:
+            fp = open(path, 'rb')
+            cache = pickle.load(fp)
+            fp.close()
+        except (IOError, ValueError):
+            pass
+
+        return cache
+
+    def save_cache(self):
+        path = os.path.join(self.path, '.clarcache')
+        with open(path, 'wb') as cache:
+            pickle.dump(self.modules, cache)
+
+    def load(self, force = False):
+        module_data = self.find_modules()
+        self.modules = {} if force else self.load_cache()
+
+        for path, name in module_data:
+            if name not in self.modules:
+                self.modules[name] = Module(name)
+
+            if not self.modules[name].refresh(path):
+                del self.modules[name]
+
+    def disable(self, excluded):
+        for exclude in excluded:
+            for module in self.modules.values():
+                name = module.clean_name()
+                if name.startswith(exclude):
+                    module.enabled = False
+                    module.modified = True
+
+    def suite_count(self):
+        return len(self.modules)
+
+    def callback_count(self):
+        return sum(len(module.callbacks) for module in self.modules.values())
+
+    def write(self):
+        output = os.path.join(self.path, 'clar.suite')
+
+        if not self.should_generate(output):
+            return False
+
+        with open(output, 'w') as data:
+            for module in self.modules.values():
+                t = Module.DeclarationTemplate(module)
+                data.write(t.render())
+
+            for module in self.modules.values():
+                t = Module.CallbacksTemplate(module)
+                data.write(t.render())
+
+            suites = "static struct clar_suite _clar_suites[] = {" + ','.join(
+                Module.InfoTemplate(module).render() for module in sorted(self.modules.values(), key=lambda module: module.name)
+            ) + "\n};\n"
+
+            data.write(suites)
+
+            data.write("static const size_t _clar_suite_count = %d;\n" % self.suite_count())
+            data.write("static const size_t _clar_callback_count = %d;\n" % self.callback_count())
+
+        self.save_cache()
+        return True
+
+if __name__ == '__main__':
+    from optparse import OptionParser
+
+    parser = OptionParser()
+    parser.add_option('-f', '--force', action="store_true", dest='force', default=False)
+    parser.add_option('-x', '--exclude', dest='excluded', action='append', default=[])
+
+    options, args = parser.parse_args()
+
+    for path in args or ['.']:
+        suite = TestSuite(path)
+        suite.load(options.force)
+        suite.disable(options.excluded)
+        if suite.write():
+            print("Written `clar.suite` (%d tests in %d suites)" % (suite.callback_count(), suite.suite_count()))