Function runEvaluate

examples/examples_test.go:88–131

Helpers

(t *testing.T, program string)

// Helpers

func runEvaluate(t *testing.T, program string) []factstore.TemporalFact {
	unit, err := parse.Unit(strings.NewReader(program))
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}

	programInfo, err := analysis.AnalyzeOneUnit(unit, nil)
	if err != nil {
		t.Fatalf("Analyze failed: %v", err)
	}

	store := factstore.NewTemporalStore()
	err = engine.EvalProgram(programInfo, factstore.NewTemporalFactStoreAdapter(store),
		engine.WithTemporalStore(store))
	if err != nil {
		t.Fatalf("Eval failed: %v", err)
	}

	var facts []factstore.TemporalFact
	// Collect all facts
	// We iterate over all predicates
	for pred := range programInfo.Decls {
		query := ast.Atom{Predicate: pred}
		// Creating a dummy query atom with variables is hard without knowing arity/types easily
		// But store.GetAllFacts takes a query atom.
		// Let's just assume we can query everything.
		// Actually, GetAllFacts isn't exposed on the interface easily like that?
		// store.GetAllFacts takes a callback.
		// We'll construct a query with variables.
		args := make([]ast.BaseTerm, pred.Arity)
		for i := 0; i < pred.Arity; i++ {
			args[i] = ast.Variable{Symbol: "X"} // Same var ok? No, better unique.
		}
		query.Args = args

		store.GetAllFacts(query, func(tf factstore.TemporalFact) error {
			facts = append(facts, tf)
			return nil
		})
	}
	// Also for match(Name), which is not temporal in sequence test
	// Ideally we check EDB/IDB predicates.
	return facts
}

func containsFact(facts []factstore.TemporalFact, prefix string) bool {
	for _, f := range facts {