herb 0.9.7-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/src/diff/herb_diff.c

@@ -0,0 +1,137 @@
+// Tree diffing algorithm inspired by React's Reconciliation approach:
+// comparing trees level-by-level and producing a minimal set of operations.
+// https://legacy.reactjs.org/docs/reconciliation.html
+
+#include "../include/diff/herb_diff.h"
+
+#include <stdio.h>
+
+herb_diff_path_T herb_diff_path_empty(void) {
+  herb_diff_path_T path;
+
+  path.depth = 0;
+
+  return path;
+}
+
+herb_diff_path_T herb_diff_path_append(const herb_diff_path_T path, const uint32_t index) {
+  herb_diff_path_T result = path;
+
+  if (result.depth < HERB_DIFF_PATH_MAX_DEPTH) {
+    result.indices[result.depth] = index;
+    result.depth++;
+  } else {
+    fprintf(stderr, "herb: diff path depth exceeded maximum of %d\n", HERB_DIFF_PATH_MAX_DEPTH);
+  }
+
+  return result;
+}
+
+static void emit_operation(
+  herb_diff_result_T* result,
+  const herb_diff_operation_type_T type,
+  const herb_diff_path_T path,
+  const AST_NODE_T* old_node,
+  const AST_NODE_T* new_node,
+  const uint32_t old_index,
+  const uint32_t new_index
+) {
+  herb_diff_operation_T* operation =
+    (herb_diff_operation_T*) hb_allocator_alloc(result->allocator, sizeof(herb_diff_operation_T));
+
+  operation->type = type;
+  operation->path = path;
+  operation->old_node = old_node;
+  operation->new_node = new_node;
+  operation->old_index = old_index;
+  operation->new_index = new_index;
+
+  hb_array_append(result->operations, operation);
+}
+
+herb_diff_result_T* herb_diff(
+  const AST_DOCUMENT_NODE_T* old_document,
+  const AST_DOCUMENT_NODE_T* new_document,
+  hb_allocator_T* allocator
+) {
+  herb_diff_result_T* result = (herb_diff_result_T*) hb_allocator_alloc(allocator, sizeof(herb_diff_result_T));
+  result->operations = hb_array_init(16, allocator);
+  result->allocator = allocator;
+  result->trees_identical = false;
+
+  herb_hash_map_T old_hashes;
+  herb_hash_map_T new_hashes;
+
+  herb_hash_map_init(&old_hashes, 256, allocator);
+  herb_hash_map_init(&new_hashes, 256, allocator);
+
+  herb_hash_T old_root_hash = herb_hash_tree((const AST_NODE_T*) old_document, &old_hashes);
+  herb_hash_T new_root_hash = herb_hash_tree((const AST_NODE_T*) new_document, &new_hashes);
+
+  if (old_root_hash == new_root_hash) {
+    result->trees_identical = true;
+    return result;
+  }
+
+  herb_diff_path_T root_path = herb_diff_path_empty();
+
+  herb_diff_node(
+    (const AST_NODE_T*) old_document,
+    (const AST_NODE_T*) new_document,
+    root_path,
+    &old_hashes,
+    &new_hashes,
+    result
+  );
+
+  return result;
+}
+
+size_t herb_diff_operation_count(const herb_diff_result_T* result) {
+  if (result == NULL || result->operations == NULL) { return 0; }
+
+  return hb_array_size(result->operations);
+}
+
+const herb_diff_operation_T* herb_diff_operation_at(const herb_diff_result_T* result, const size_t index) {
+  if (result == NULL || result->operations == NULL) { return NULL; }
+
+  return (const herb_diff_operation_T*) hb_array_get(result->operations, index);
+}
+
+bool herb_diff_trees_identical(const herb_diff_result_T* result) {
+  if (result == NULL) { return false; }
+
+  return result->trees_identical;
+}
+
+const char* herb_diff_operation_type_to_string(const herb_diff_operation_type_T type) {
+  switch (type) {
+    case HERB_DIFF_ATTRIBUTE_ADDED: return "attribute_added";
+    case HERB_DIFF_ATTRIBUTE_REMOVED: return "attribute_removed";
+    case HERB_DIFF_ATTRIBUTE_VALUE_CHANGED: return "attribute_value_changed";
+    case HERB_DIFF_ERB_CONTENT_CHANGED: return "erb_content_changed";
+    case HERB_DIFF_NODE_INSERTED: return "node_inserted";
+    case HERB_DIFF_NODE_MOVED: return "node_moved";
+    case HERB_DIFF_NODE_REMOVED: return "node_removed";
+    case HERB_DIFF_NODE_REPLACED: return "node_replaced";
+    case HERB_DIFF_NODE_UNWRAPPED: return "node_unwrapped";
+    case HERB_DIFF_NODE_WRAPPED: return "node_wrapped";
+    case HERB_DIFF_TAG_NAME_CHANGED: return "tag_name_changed";
+    case HERB_DIFF_TEXT_CHANGED: return "text_changed";
+  }
+
+  return "unknown";
+}
+
+void herb_diff_emit_operation(
+  herb_diff_result_T* result,
+  const herb_diff_operation_type_T type,
+  const herb_diff_path_T path,
+  const AST_NODE_T* old_node,
+  const AST_NODE_T* new_node,
+  const uint32_t old_index,
+  const uint32_t new_index
+) {
+  emit_operation(result, type, path, old_node, new_node, old_index, new_index);
+}

data/src/diff/herb_diff_attributes.c

@@ -0,0 +1,207 @@
+#include "../include/diff/herb_diff.h"
+
+void herb_diff_attributes(
+  const hb_array_T* old_attributes,
+  const hb_array_T* new_attributes,
+  const herb_diff_path_T parent_path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (old_attributes == NULL && new_attributes == NULL) { return; }
+
+  if (old_attributes == NULL) {
+    for (size_t index = 0; index < hb_array_size(new_attributes); index++) {
+      const AST_NODE_T* new_attribute = (const AST_NODE_T*) hb_array_get(new_attributes, index);
+
+      herb_diff_emit_operation(
+        result,
+        HERB_DIFF_ATTRIBUTE_ADDED,
+        herb_diff_path_append(parent_path, (uint32_t) index),
+        NULL,
+        new_attribute,
+        0,
+        (uint32_t) index
+      );
+    }
+
+    return;
+  }
+
+  if (new_attributes == NULL) {
+    for (size_t index = 0; index < hb_array_size(old_attributes); index++) {
+      const AST_NODE_T* old_attribute = (const AST_NODE_T*) hb_array_get(old_attributes, index);
+
+      herb_diff_emit_operation(
+        result,
+        HERB_DIFF_ATTRIBUTE_REMOVED,
+        herb_diff_path_append(parent_path, (uint32_t) index),
+        old_attribute,
+        NULL,
+        (uint32_t) index,
+        0
+      );
+    }
+
+    return;
+  }
+
+  const size_t old_size = hb_array_size(old_attributes);
+  const size_t new_size = hb_array_size(new_attributes);
+
+  if (old_size == 0) {
+    for (size_t index = 0; index < new_size; index++) {
+      const AST_NODE_T* new_attribute = (const AST_NODE_T*) hb_array_get(new_attributes, index);
+
+      herb_diff_emit_operation(
+        result,
+        HERB_DIFF_ATTRIBUTE_ADDED,
+        herb_diff_path_append(parent_path, (uint32_t) index),
+        NULL,
+        new_attribute,
+        0,
+        (uint32_t) index
+      );
+    }
+
+    return;
+  }
+
+  if (new_size == 0) {
+    for (size_t index = 0; index < old_size; index++) {
+      const AST_NODE_T* old_attribute = (const AST_NODE_T*) hb_array_get(old_attributes, index);
+
+      herb_diff_emit_operation(
+        result,
+        HERB_DIFF_ATTRIBUTE_REMOVED,
+        herb_diff_path_append(parent_path, (uint32_t) index),
+        old_attribute,
+        NULL,
+        (uint32_t) index,
+        0
+      );
+    }
+
+    return;
+  }
+
+  bool* old_matched = (bool*) hb_allocator_alloc(result->allocator, old_size * sizeof(bool));
+
+  for (size_t index = 0; index < old_size; index++) {
+    old_matched[index] = false;
+  }
+
+  for (size_t new_index = 0; new_index < new_size; new_index++) {
+    const AST_NODE_T* new_node = (const AST_NODE_T*) hb_array_get(new_attributes, new_index);
+
+    if (new_node->type != AST_HTML_ATTRIBUTE_NODE) {
+      bool found = false;
+
+      for (size_t old_index = 0; old_index < old_size; old_index++) {
+        if (old_matched[old_index]) { continue; }
+
+        const AST_NODE_T* old_node = (const AST_NODE_T*) hb_array_get(old_attributes, old_index);
+
+        if (old_node->type == new_node->type) {
+          old_matched[old_index] = true;
+          found = true;
+
+          herb_hash_T old_hash = herb_hash_map_get(old_hashes, old_node);
+          herb_hash_T new_hash = herb_hash_map_get(new_hashes, new_node);
+
+          if (old_hash != new_hash) {
+            herb_diff_node(
+              old_node,
+              new_node,
+              herb_diff_path_append(parent_path, (uint32_t) new_index),
+              old_hashes,
+              new_hashes,
+              result
+            );
+          }
+
+          break;
+        }
+      }
+
+      if (!found) {
+        herb_diff_emit_operation(
+          result,
+          HERB_DIFF_ATTRIBUTE_ADDED,
+          herb_diff_path_append(parent_path, (uint32_t) new_index),
+          NULL,
+          new_node,
+          0,
+          (uint32_t) new_index
+        );
+      }
+
+      continue;
+    }
+
+    const AST_HTML_ATTRIBUTE_NODE_T* new_attribute = (const AST_HTML_ATTRIBUTE_NODE_T*) new_node;
+    herb_hash_T new_name_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_attribute->name);
+
+    bool found = false;
+
+    for (size_t old_index = 0; old_index < old_size; old_index++) {
+      if (old_matched[old_index]) { continue; }
+
+      const AST_NODE_T* old_node = (const AST_NODE_T*) hb_array_get(old_attributes, old_index);
+      if (old_node->type != AST_HTML_ATTRIBUTE_NODE) { continue; }
+
+      const AST_HTML_ATTRIBUTE_NODE_T* old_attribute = (const AST_HTML_ATTRIBUTE_NODE_T*) old_node;
+      herb_hash_T old_name_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_attribute->name);
+
+      if (old_name_hash == new_name_hash) {
+        old_matched[old_index] = true;
+        found = true;
+
+        herb_hash_T old_value_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_attribute->value);
+        herb_hash_T new_value_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_attribute->value);
+
+        if (old_value_hash != new_value_hash) {
+          herb_diff_emit_operation(
+            result,
+            HERB_DIFF_ATTRIBUTE_VALUE_CHANGED,
+            herb_diff_path_append(parent_path, (uint32_t) new_index),
+            old_node,
+            new_node,
+            (uint32_t) old_index,
+            (uint32_t) new_index
+          );
+        }
+
+        break;
+      }
+    }
+
+    if (!found) {
+      herb_diff_emit_operation(
+        result,
+        HERB_DIFF_ATTRIBUTE_ADDED,
+        herb_diff_path_append(parent_path, (uint32_t) new_index),
+        NULL,
+        new_node,
+        0,
+        (uint32_t) new_index
+      );
+    }
+  }
+
+  for (size_t old_index = 0; old_index < old_size; old_index++) {
+    if (!old_matched[old_index]) {
+      const AST_NODE_T* old_node = (const AST_NODE_T*) hb_array_get(old_attributes, old_index);
+
+      herb_diff_emit_operation(
+        result,
+        HERB_DIFF_ATTRIBUTE_REMOVED,
+        herb_diff_path_append(parent_path, (uint32_t) old_index),
+        old_node,
+        NULL,
+        (uint32_t) old_index,
+        0
+      );
+    }
+  }
+}