#traversal

#The node model

///|
test "fields and children" {
  let r = @parser.parse_text(
    (
      #|$version: "2"
      #|namespace a
      #|
      #|/// A person.
      #|structure Person {
      #|    name: String
      #|}
      #|
    ),
  )
  let root = @traversal.NodeRef::of_result(r).unwrap()
  let person = root.field("shapes")[0]
  inspect("\{person.category()}/\{person.kind()}", content="shape/structure")
  inspect(
    person.children().map(c => c.category()).join(" "),
    content="doc name member",
  )
}

#Walk, fold and reduce

///|
test "walk, fold and reduce" {
  let r = @parser.parse_text("namespace a\n\n@t\nstring S\n")
  let root = @traversal.NodeRef::of_result(r).unwrap()
  let log = []
  @traversal.walk(root, n => {
    log.push(n.category())
    if n.category() == "trait" {
      SkipChildren
    } else {
      Continue
    }
  })
  inspect(log.join(" "), content="file namespace name shape trait name")
  let count = @traversal.fold(root, 0, (a, _) => (a + 1, Continue))
  inspect(count, content="7")
  // Bottom up: each node with the results of its children.
  let leaves = @traversal.reduce(root, (_, rs : ArrayView[Int32]) => {
    if rs.length() == 0 {
      1
    } else {
      rs.iter().fold(init=0, (a, b) => a + b)
    }
  })
  inspect(leaves, content="3")
  // reduce_pruned can skip a subtree, or stop with None.
  let pruned = @traversal.reduce_pruned(
    root,
    n => if n.category() == "trait" { SkipChildren } else { Continue },
    (_, rs : ArrayView[Int32]) => 1 + rs.iter().fold(init=0, (a, b) => a + b),
  )
  debug_inspect(pruned, content="Some(6)")
}

#Events

///|
test "pull events" {
  let r = @parser.parse_text("namespace a\n\nstring S\n")
  let root = @traversal.NodeRef::of_result(r).unwrap()
  let reader = @traversal.EventReader::new(root)
  let log = []
  while reader.next() is Some(e) {
    match e {
      Enter(e) => {
        log.push("+\{e.path}")
        if e.category == "namespace" {
          reader.skip_children()
        }
      }
      Leave(_) => ()
    }
  }
  inspect(
    log.join(" "),
    content="+ +namespace[0] +shapes[0] +shapes[0].name[0]",
  )
}

///|
struct TraitIds(Array[String])

///|
impl @traversal.Visitor for TraitIds with fn visit_trait(self, n) {
  if n is Trait(t) {
    self.0.push(t.id.value.to_string())
  }
  SkipChildren
}

///|
test "a visitor" {
  let r = @parser.parse_text(
    "namespace a\n\n@required\n@length(min: 1)\nstring S\n",
  )
  let ids = TraitIds([])
  @traversal.accept(@traversal.NodeRef::of_result(r).unwrap(), ids)
  debug_inspect(ids.0, content="[\"required\", \"length\"]")
}

///|
struct Paths(Array[String])

///|
impl @traversal.Handler for Paths with fn on_enter(self, e) {
  self.0.push(e.path.to_string())
  if e.category == "shape" {
    SkipChildren
  } else {
    Continue
  }
}

///|
test "push events into a handler" {
  let r = @parser.parse_text("namespace a\n\nstring S\n")
  let root = @traversal.NodeRef::of_result(r).unwrap()
  let paths = Paths([])
  @traversal.push_events(@traversal.EventReader::new(root), paths)
  debug_inspect(
    paths.0,
    content="[\"\", \"namespace[0]\", \"namespace[0].name[0]\", \"shapes[0]\"]",
  )
}

#Tree, cursor and paths

///|
test "tree, cursor and path" {
  let text =
    #|namespace a
    #|
    #|structure Foo {
    #|    x: String
    #|}
    #|
  let tree = @traversal.Tree::new(@parser.parse_text(text)).unwrap()
  let at = @span.Offset::new(text.find("x:").unwrap()).unwrap()
  let name = tree.node_at(at).unwrap()
  inspect(tree.node_path(name).unwrap(), content="shapes[0].members[0].name[0]")
  let c = @traversal.TreeCursor::new(tree.root())
  inspect(c.goto_node_at(at), content="true")
  inspect(c.path(), content="shapes[0].members[0].name[0]")
}

#Kind table