nmhit 0.1.3__tar.gz → 0.1.4__tar.gz

{nmhit-0.1.3 → nmhit-0.1.4}/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 # Keep this version in sync with [project] version in pyproject.toml.
-project(neml2-hit VERSION 0.1.3 LANGUAGES CXX)
+project(neml2-hit VERSION 0.1.4 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

{nmhit-0.1.3 → nmhit-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nmhit
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python bindings for the nmhit NEML2-flavored HIT parser
 License: MIT
 Classifier: Programming Language :: Python :: 3

{nmhit-0.1.3 → nmhit-0.1.4}/include/nmhit/Node.h

@@ -244,8 +244,18 @@ public:
   std::string render(int indent = 0, const std::string & indent_text = "  ") const override;
   std::unique_ptr<Node> clone() const override;
 
+  /// True if this section was synthesized by the parser to wrap a path-split
+  /// key (e.g. the "Models" in `Models/a/foo = 1`), rather than being written
+  /// explicitly by the user as `[Models] ... []`.  Wrapper sections are merged
+  /// with same-name siblings at parse time; explicit sections are not.
+  bool is_path_wrapper() const { return _is_wrapper; }
+
+  // ── internal setter (used by the parser) ──────────────────────────────────
+  void _set_path_wrapper(bool v) { _is_wrapper = v; }
+
 private:
   std::string _name;
+  bool _is_wrapper = false;
 };
 
 /// A key-value field, e.g. dim = 3 or values = '1 2 3'.

{nmhit-0.1.3 → nmhit-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "nmhit"
-version = "0.1.3"  # Keep in sync with VERSION in CMakeLists.txt.
+version = "0.1.4"  # Keep in sync with VERSION in CMakeLists.txt.
 description = "Python bindings for the nmhit NEML2-flavored HIT parser"
 readme = "README.md"
 requires-python = ">=3.9"

{nmhit-0.1.3 → nmhit-0.1.4}/src/Node.cpp

@@ -501,6 +501,7 @@ Section::clone() const
 {
   auto s = std::make_unique<Section>(_name);
   s->_set_location(filename(), line(), column());
+  s->_is_wrapper = _is_wrapper;
   for (const auto & c : children())
     s->add_child(c->clone());
   return s;
@@ -705,12 +706,16 @@ ParseDriver::parse()
 
 /// Apply last-override-wins semantics to items, merging same-name sections.
 ///
-/// Pass 1 — section merge: sections with the same name are collapsed into the
-///   first occurrence by moving all children of the duplicate into the first.
-///   This handles path-split fields that share a common ancestor section
-///   (e.g. "Models/a/foo = 1" and "Models/b/bar = 2" both create a "Models"
-///   wrapper; the two wrappers are merged so lookup through a single "Models"
-///   finds both).
+/// Pass 1 — path-wrapper section merge: a "path wrapper" is a section the
+///   parser synthesized to represent intermediate segments of a path-split
+///   key (e.g. the "Models" in `Models/a/foo = 1`), flagged via
+///   Section::is_path_wrapper().  When a wrapper meets a preceding same-name
+///   sibling (wrapper or explicit), its children are folded into that
+///   sibling and the duplicate node is dropped.  The surviving section
+///   becomes "explicit" if either input was explicit.
+///
+///   Two explicit `[Name] ... []` sections written by the user are NEVER
+///   merged — they round-trip as two distinct top-level blocks.
 ///
 /// Pass 2 — field duplicate / override check (per level):
 ///   - If the later occurrence was built with ':=', the earlier one is removed.
@@ -722,9 +727,11 @@ ParseDriver::parse()
 void
 ParseDriver::apply_overrides(std::vector<std::unique_ptr<nmhit::Node>> & items)
 {
-  // ── Pass 1: merge same-name sections ─────────────────────────────────────
+  // ── Pass 1: fold path-wrapper sections into same-name siblings ───────────
   {
-    std::unordered_map<std::string, std::size_t> section_first;
+    // For each section name, the index of the most recent surviving
+    // same-name section that a subsequent wrapper may fold into.
+    std::unordered_map<std::string, std::size_t> latest;
     std::vector<bool> merged(items.size(), false);
 
     for (std::size_t i = 0; i < items.size(); ++i)
@@ -733,19 +740,26 @@ ParseDriver::apply_overrides(std::vector<std::unique_ptr<nmhit::Node>> & items)
       if (!sec)
         continue;
 
-      auto it = section_first.find(sec->path());
-      if (it != section_first.end())
-      {
-        auto * first = dynamic_cast<nmhit::Section *>(items[it->second].get());
-        auto raw_kids = sec->children();
-        for (auto * k : raw_kids)
-          first->add_child(sec->remove_child(k));
-        merged[i] = true;
-      }
-      else
+      auto it = latest.find(sec->path());
+      if (it != latest.end())
       {
-        section_first[sec->path()] = i;
+        auto * prev = dynamic_cast<nmhit::Section *>(items[it->second].get());
+        const bool either_wrapper = sec->is_path_wrapper() || prev->is_path_wrapper();
+        if (either_wrapper)
+        {
+          auto raw_kids = sec->children();
+          for (auto * k : raw_kids)
+            prev->add_child(sec->remove_child(k));
+          // Surviving section is explicit if either input was explicit.
+          if (!sec->is_path_wrapper())
+            prev->_set_path_wrapper(false);
+          merged[i] = true;
+          continue;
+        }
+        // Both explicit: leave as separate siblings, fall through to update
+        // `latest` so a later wrapper folds into the most recent block.
       }
+      latest[sec->path()] = i;
     }
 
     if (std::any_of(merged.begin(), merged.end(), [](bool b) { return b; }))
@@ -842,6 +856,12 @@ split_path(const std::string & path)
 }
 
 /// Wrap a node in a chain of Section nodes for a/b/c-style paths.
+///
+/// Every wrapper created here is marked via `_set_path_wrapper(true)` so that
+/// apply_overrides() can distinguish synthesized wrappers (which must merge
+/// with same-name siblings to make `Models/a/foo = 1` + `Models/b/bar = 2`
+/// resolve through a single "Models") from explicit `[Models] ... []` blocks
+/// written by the user (which are preserved verbatim for round-tripping).
 static std::unique_ptr<nmhit::Node>
 wrap_in_sections(std::vector<std::string> segs,
                  std::unique_ptr<nmhit::Node> inner_node,
@@ -856,6 +876,7 @@ wrap_in_sections(std::vector<std::string> segs,
   {
     auto wrapper = std::make_unique<nmhit::Section>(segs[i]);
     wrapper->_set_location(fname, line, col);
+    wrapper->_set_path_wrapper(true);
     wrapper->add_child(std::move(inner_node));
     inner_node = std::move(wrapper);
   }

{nmhit-0.1.3 → nmhit-0.1.4}/tests/test_hit.cpp

@@ -730,6 +730,72 @@ main()
            std::string::npos);
   });
 
+  // ── 20. Explicit duplicate sections preserved (round-trip) ────────────────
+
+  run("two_explicit_same_name_sections_preserved", []() {
+    // Two user-written [Models] blocks must remain as two distinct siblings
+    // — not collapsed into one — so the document round-trips intact.
+    auto root = p("[Models]\n  a = 1\n[]\n[Models]\n  b = 2\n[]");
+    auto secs = root->children(nmhit::NodeType::Section);
+    EXPECT(secs.size() == 2);
+    EXPECT(secs[0]->path() == "Models");
+    EXPECT(secs[1]->path() == "Models");
+    // The first block owns `a`, the second owns `b`; they are not merged.
+    EXPECT(secs[0]->children(nmhit::NodeType::Field).size() == 1);
+    EXPECT(secs[1]->children(nmhit::NodeType::Field).size() == 1);
+    EXPECT(secs[0]->children(nmhit::NodeType::Field)[0]->path() == "a");
+    EXPECT(secs[1]->children(nmhit::NodeType::Field)[0]->path() == "b");
+  });
+
+  run("two_explicit_sections_round_trip", []() {
+    // Rendering then re-parsing keeps both blocks distinct.
+    auto root = p("[Models]\n  a = 1\n[]\n[Models]\n  b = 2\n[]");
+    auto rendered = root->render();
+    auto root2 = p(rendered);
+    EXPECT(root2->children(nmhit::NodeType::Section).size() == 2);
+  });
+
+  run("explicit_then_path_split_merges", []() {
+    // A path-split fragment whose root name matches an existing explicit
+    // section folds into that explicit block — backward-compatible behavior.
+    auto root = p("[Models]\n  a = 1\n[]\nModels/b = 2");
+    auto secs = root->children(nmhit::NodeType::Section);
+    EXPECT(secs.size() == 1);
+    EXPECT(root->param<int>("Models/a") == 1);
+    EXPECT(root->param<int>("Models/b") == 2);
+  });
+
+  run("path_split_then_explicit_merges", []() {
+    // Reverse order: a leading path-split fragment is folded into the
+    // following explicit block of the same name.
+    auto root = p("Models/a = 1\n[Models]\n  b = 2\n[]");
+    auto secs = root->children(nmhit::NodeType::Section);
+    EXPECT(secs.size() == 1);
+    EXPECT(root->param<int>("Models/a") == 1);
+    EXPECT(root->param<int>("Models/b") == 2);
+  });
+
+  run("two_explicit_blocks_then_path_split_targets_latest", []() {
+    // [Models]a[]  [Models]b[]  Models/c=3  →  the wrapper folds into the
+    // most recent same-name explicit block (the second [Models]).
+    auto root = p("[Models]\n  a = 1\n[]\n[Models]\n  b = 2\n[]\nModels/c = 3");
+    auto secs = root->children(nmhit::NodeType::Section);
+    EXPECT(secs.size() == 2);
+    EXPECT(secs[0]->children(nmhit::NodeType::Field).size() == 1);  // just a
+    EXPECT(secs[1]->children(nmhit::NodeType::Field).size() == 2);  // b + c
+  });
+
+  run("explicit_duplicate_field_in_first_block_no_error", []() {
+    // Same field name in two SEPARATE explicit blocks of the same name is
+    // not a duplicate-field error: the blocks are independent containers.
+    auto root = p("[Models]\n  k = 1\n[]\n[Models]\n  k = 2\n[]");
+    auto secs = root->children(nmhit::NodeType::Section);
+    EXPECT(secs.size() == 2);
+    // find() walks the first match; HIT semantics for duplicate explicit
+    // sections leave value resolution document-order dependent.
+    EXPECT(root->param<int>("Models/k") == 1);
+  });
+
   // ── Summary ───────────────────────────────────────────────────────────────
 
   std::cerr << "\n=== Results: " << g_passed << " passed, " << g_failed << " failed ===\n";