Rename ts_document_set_debugger -> ts_document_set_logger

spec/helpers/log_debugger.h

@@ -1,8 +0,0 @@
-#ifndef HELPERS_LOG_DEBUGGER_H_
-#define HELPERS_LOG_DEBUGGER_H_
-
-#include "tree_sitter/runtime.h"
-
-TSDebugger log_debugger_make(bool include_lexing);
-
-#endif  // HELPERS_LOG_DEBUGGER_H_

spec/helpers/spy_debugger.cc

@@ -1,22 +0,0 @@
-#include "helpers/spy_debugger.h"
-#include <string>
-#include <vector>
-
-using std::string;
-using std::vector;
-
-static void spy_debug(void *data, TSDebugType type, const char *msg) {
-  SpyDebugger *debugger = static_cast<SpyDebugger *>(data);
-  debugger->messages.push_back(msg);
-}
-
-TSDebugger SpyDebugger::debugger() {
-  TSDebugger result;
-  result.payload = (void *)this;
-  result.debug_fn = spy_debug;
-  return result;
-}
-
-void SpyDebugger::clear() {
-  messages.clear();
-}

spec/helpers/spy_logger.cc

@@ -0,0 +1,22 @@
+#include "helpers/spy_logger.h"
+#include <string>
+#include <vector>
+
+using std::string;
+using std::vector;
+
+static void spy_log(void *data, TSLogType type, const char *msg) {
+  SpyLogger *logger = static_cast<SpyLogger *>(data);
+  logger->messages.push_back(msg);
+}
+
+TSLogger SpyLogger::logger() {
+  TSLogger result;
+  result.payload = (void *)this;
+  result.log = spy_log;
+  return result;
+}
+
+void SpyLogger::clear() {
+  messages.clear();
+}

spec/helpers/spy_logger.h

@@ -1,14 +1,14 @@
-#ifndef HELPERS_SPY_DEBUGGER_H_
-#define HELPERS_SPY_DEBUGGER_H_
+#ifndef HELPERS_SPY_LOGGER_H_
+#define HELPERS_SPY_LOGGER_H_
 
 #include <string>
 #include <vector>
 #include "tree_sitter/runtime.h"
 
-class SpyDebugger {
+class SpyLogger {
  public:
   void clear();
-  TSDebugger debugger();
+  TSLogger logger();
   std::vector<std::string> messages;
 };
 

spec/helpers/stderr_logger.cc

@@ -1,22 +1,22 @@
 #include "tree_sitter/runtime.h"
 #include <stdio.h>
 
-static void log_debug(void *payload, TSDebugType type, const char *msg) {
+static void log(void *payload, TSLogType type, const char *msg) {
   bool include_lexing = (bool)payload;
   switch (type) {
-    case TSDebugTypeParse:
+    case TSLogTypeParse:
       fprintf(stderr, "* %s\n", msg);
       break;
-    case TSDebugTypeLex:
+    case TSLogTypeLex:
       if (include_lexing)
         fprintf(stderr, "  %s\n", msg);
       break;
   }
 }
 
-TSDebugger log_debugger_make(bool include_lexing) {
-  TSDebugger result;
+TSLogger stderr_logger_new(bool include_lexing) {
+  TSLogger result;
   result.payload = (void *)include_lexing;
-  result.debug_fn = log_debug;
+  result.log = log;
   return result;
 }

spec/helpers/stderr_logger.h

@@ -0,0 +1,8 @@
+#ifndef HELPERS_STDERR_LOGGER_H_
+#define HELPERS_STDERR_LOGGER_H_
+
+#include "tree_sitter/runtime.h"
+
+TSLogger stderr_logger_new(bool include_lexing);
+
+#endif  // HELPERS_STDERR_LOGGER_H_

spec/integration/corpus_specs.cc

@@ -3,7 +3,7 @@
 #include "helpers/load_language.h"
 #include "helpers/read_test_entries.h"
 #include "helpers/spy_input.h"
-#include "helpers/log_debugger.h"
+#include "helpers/stderr_logger.h"
 #include "helpers/point_helpers.h"
 #include "helpers/encoding_helpers.h"
 #include "helpers/record_alloc.h"
@@ -80,7 +80,7 @@ describe("The Corpus", []() {
         document = ts_document_new();
         ts_document_set_language(document, get_test_language(language_name));
 
-        // ts_document_set_debugger(document, log_debugger_make(true));
+        ts_document_set_logger(document, stderr_logger_new(true));
         // ts_document_print_debugging_graphs(document, true);
       });
 

spec/runtime/document_spec.cc

@@ -1,13 +1,11 @@
 #include "spec_helper.h"
 #include "runtime/alloc.h"
-#include "runtime/debugger.h"
 #include "helpers/record_alloc.h"
 #include "helpers/stream_methods.h"
 #include "helpers/tree_helpers.h"
-#include "helpers/spy_debugger.h"
+#include "helpers/spy_logger.h"
 #include "helpers/spy_input.h"
 #include "helpers/load_language.h"
-#include "helpers/log_debugger.h"
 
 START_TEST
 
@@ -146,51 +144,51 @@ describe("Document", [&]() {
     });
   });
 
-  describe("set_debugger(TSDebugger)", [&]() {
-    SpyDebugger *debugger;
+  describe("set_logger(TSDebugger)", [&]() {
+    SpyLogger *logger;
 
     before_each([&]() {
-      debugger = new SpyDebugger();
+      logger = new SpyLogger();
       ts_document_set_language(doc, get_test_language("json"));
       ts_document_set_input_string(doc, "[1, 2]");
     });
 
     after_each([&]() {
-      delete debugger;
+      delete logger;
     });
 
     it("calls the debugger with a message for each lex action", [&]() {
-      ts_document_set_debugger(doc, debugger->debugger());
+      ts_document_set_logger(doc, logger->logger());
       ts_document_parse(doc);
 
-      AssertThat(debugger->messages, Contains("lookahead char:'1'"));
-      AssertThat(debugger->messages, Contains("lookahead char:'['"));
+      AssertThat(logger->messages, Contains("lookahead char:'1'"));
+      AssertThat(logger->messages, Contains("lookahead char:'['"));
     });
 
     it("calls the debugger with a message for each parse action", [&]() {
-      ts_document_set_debugger(doc, debugger->debugger());
+      ts_document_set_logger(doc, logger->logger());
       ts_document_parse(doc);
 
-      AssertThat(debugger->messages, Contains("new_parse"));
-      AssertThat(debugger->messages, Contains("lookahead char:'['"));
-      AssertThat(debugger->messages, Contains("reduce sym:array, child_count:4"));
-      AssertThat(debugger->messages, Contains("accept"));
+      AssertThat(logger->messages, Contains("new_parse"));
+      AssertThat(logger->messages, Contains("lookahead char:'['"));
+      AssertThat(logger->messages, Contains("reduce sym:array, child_count:4"));
+      AssertThat(logger->messages, Contains("accept"));
     });
 
     it("allows the debugger to be retrieved later", [&]() {
-      ts_document_set_debugger(doc, debugger->debugger());
-      AssertThat(ts_document_debugger(doc).payload, Equals(debugger));
+      ts_document_set_logger(doc, logger->logger());
+      AssertThat(ts_document_logger(doc).payload, Equals(logger));
     });
 
     describe("disabling debugging", [&]() {
       before_each([&]() {
-        ts_document_set_debugger(doc, debugger->debugger());
-        ts_document_set_debugger(doc, ts_debugger_null());
+        ts_document_set_logger(doc, logger->logger());
+        ts_document_set_logger(doc, {NULL, NULL});
       });
 
       it("does not call the debugger any more", [&]() {
         ts_document_parse(doc);
-        AssertThat(debugger->messages, IsEmpty());
+        AssertThat(logger->messages, IsEmpty());
       });
     });
   });

spec/runtime/parser_spec.cc

@@ -3,7 +3,6 @@
 #include "helpers/record_alloc.h"
 #include "helpers/spy_input.h"
 #include "helpers/load_language.h"
-#include "helpers/log_debugger.h"
 #include "helpers/record_alloc.h"
 
 START_TEST