WIP

Author: ohler55

assets/coverage-badge.svg

@@ -22,15 +22,32 @@ var (
 func StartCoverage() {
 	Provenance = true
 	coverage = true
-	// Just in case the function is called again the function info is reset.
-	coverageFuncs = coverageFuncs[:0]
 }
 
 // StopCoverage stops collecting coverage data. Existing data is not changed.
 func StopCoverage() {
 	coverage = false
 }
 
+// Coverage returns the current state of coverage.
+func Coverage() bool {
+	return coverage
+}
+
+// ResetCoverage resets all the function use counts to zero. If a hard reset
+// then the coverage function list is also zeroed out.
+func ResetCoverage(hard bool) {
+	if hard {
+		coverageFuncs = coverageFuncs[:0]
+	} else {
+		for _, f := range coverageFuncs {
+			if p := f.Provenance(); p != nil {
+				p.count = 0
+			}
+		}
+	}
+}
+
 // WriteCoverage writes a coverage file. The file is a Lisp file containing
 // one list. The list starts with a property list of filenames and file
 // checksums. Each provenance element in the list contains filepath,

coverage.go

@@ -5,17 +5,37 @@
 ---------------------
 
 - add provenance
+ - documentation function should replace _ and __ as needed and wrap lines
+ - lisp functions
+  - reset-coverage (hard)
+  - write-coverage (filename &optional destination)
+   - nil should return string mostly for testing or for progress analysis
+ - test with defun
+ - what to do with repl defined functions?
+  - maybe keep counter of editor.evalForm() calls then REPL-<counter> as filename
+
 
  - use for stack trace
   - for tracing, maybe just add filename:line:col as a prefix and keep current the same otherwise
    - for non-file loaded skip that part (just use a few spaces for indent)
    - maybe just filepath base without .lisp then firstLine and firstColumn
-   - options for tracing as globals?
-    - just provenance
-    - just functions (current)
-    - both
+   - options for error stack as globals?
+    - *stack-trace-format*
+     - :provenance (default)
+      - provenance if available and function otherwise
+     - :provenance-long (full file path)
+     - :function
+     - :both
+     - :both-long
    - in AppendFull
+ -
+
  - coverage app
+  - start with writing colorized file(s)
+   - lisp code
+   - where to put the code?
+    - lisp dir in slip?
+  - later could be interactive
   - lisp app for processing and coverage
   - add file checksum function to support lisp coverage
   - functions for terminal support?

docs/notes.md

@@ -276,6 +276,22 @@ func init() {
 				Export: true,
 				Doc:    "are the command line arguments.",
 			},
+			"*provenance*": {
+				Get:    getProvenance,
+				Set:    setProvenance,
+				Export: true,
+				Doc: `If *provenance* is true function provenance information is collected.
+Function provenance is used in stack trace output as we as in coverage reports. If used it
+should be set to true at before loading files.`,
+			},
+			"*coverage*": {
+				Get:    getCoverage,
+				Set:    setCoverage,
+				Export: true,
+				Doc: `If *coverage* is true counts of the number of calls to functions with
+provenance information are collected for use when a call to write-coverage is made. If used
+it should be set to true at before loading files.`,
+			},
 		})
 	for _, f := range []*flavors.Flavor{
 		defLogger(),
@@ -443,3 +459,29 @@ func getAppArgs() slip.Object {
 	}
 	return args
 }
+
+func getProvenance() (state slip.Object) {
+	if slip.Provenance {
+		state = slip.True
+	}
+	return
+}
+
+func setProvenance(value slip.Object) {
+	slip.Provenance = value != nil
+}
+
+func getCoverage() (state slip.Object) {
+	if slip.Coverage() {
+		state = slip.True
+	}
+	return
+}
+
+func setCoverage(value slip.Object) {
+	if value == nil {
+		slip.StopCoverage()
+	} else {
+		slip.StartCoverage()
+	}
+}

pkg/gi/pkg.go

@@ -125,10 +125,13 @@ func SetConfigDir(dir string) {
 		if Trace {
 			fmt.Printf("Loading %q.\n", cfgPath)
 		}
-		pathname := slip.String(filepath.Join(slip.WorkingDir, cfgPath))
-		code, listProvs := slip.ReadProv(buf, &scope, string(pathname), nil)
-		_ = slip.CurrentPackage.Set("*load-pathname*", pathname)
-		_ = slip.CurrentPackage.Set("*load-truename*", pathname)
+		pathname := cfgPath
+		if cfgPath[0] != '/' {
+			pathname = filepath.Join(slip.WorkingDir, cfgPath)
+		}
+		code, listProvs := slip.ReadProv(buf, &scope, pathname, nil)
+		_ = slip.CurrentPackage.Set("*load-pathname*", slip.String(pathname))
+		_ = slip.CurrentPackage.Set("*load-truename*", slip.String(pathname))
 		code.CompileWithProvenance(listProvs)
 		code.Eval(&scope, nil) // TBD consider load-verbose and load-print
 	} else {
@@ -141,7 +144,10 @@ func SetConfigDir(dir string) {
 		}
 	}
 	if buf, err = os.ReadFile(customPath); err == nil {
-		pathname := slip.String(filepath.Join(slip.WorkingDir, customPath))
+		if customPath[0] != '/' {
+			customPath = filepath.Join(slip.WorkingDir, customPath)
+		}
+		pathname := slip.String(customPath)
 		_ = slip.CurrentPackage.Set("*load-pathname*", pathname)
 		_ = slip.CurrentPackage.Set("*load-truename*", pathname)
 		if Trace {

pkg/repl/repl.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2026, Peter Ohler, All rights reserved.
+
+package gi_test
+
+import (
+	"testing"
+
+	"github.com/ohler55/slip/sliptest"
+)
+
+func TestGlobalProvenance(t *testing.T) {
+	(&sliptest.Function{
+		Source: `(let ((orig *provenance*)
+                       result)
+                   (setq *provenance* nil)
+                   (addf result *provenance*)
+                   (setq *provenance* t)
+                   (addf result *provenance*)
+                   (setq *provenance* orig)
+                   result)`,
+		Expect: "(nil t)",
+	}).Test(t)
+}
+
+func TestGlobalCoverage(t *testing.T) {
+	(&sliptest.Function{
+		Source: `(let ((orig *coverage*)
+                       result)
+                   (setq *coverage* nil)
+                   (addf result *coverage*)
+                   (setq *coverage* t)
+                   (addf result *coverage*)
+                   (setq *coverage* orig)
+                   result)`,
+		Expect: "(nil t)",
+	}).Test(t)
+}