Address #665

There is now much more explicit information available when loading custom functions and the rules loaded is accurate.

Author: daveshanley

cmd/shared_functions.go

@@ -124,8 +124,19 @@ func LoadCustomFunctions(functionsFlag string, silence bool) (map[string]model.R
 			pterm.Println()
 			return nil, err
 		}
+		
+		customFunctions := pm.GetCustomFunctions()
 		pterm.Info.Printf("Loaded %d custom function(s) successfully.\n", pm.LoadedFunctionCount())
-		return pm.GetCustomFunctions(), nil
+		
+		if !silence && len(customFunctions) > 0 {
+			pterm.Info.Println("Available custom functions:")
+			for funcName := range customFunctions {
+				pterm.Printf("  - %s\n", pterm.LightCyan(funcName))
+			}
+			pterm.Println()
+		}
+		
+		return customFunctions, nil
 	}
 	return nil, nil
 }

motor/rule_applicator.go

@@ -964,6 +964,38 @@ func buildResults(ctx ruleContext, ruleAction model.RuleAction, nodes []*yaml.No
 			}
 
 		}
+	} else {
+		// Function not found - report detailed error
+		if !ctx.silenceLogs {
+			// Build list of available custom functions for debugging
+			var availableCustomFuncs []string
+			if ctx.customFunctions != nil {
+				for funcName := range ctx.customFunctions {
+					availableCustomFuncs = append(availableCustomFuncs, funcName)
+				}
+			}
+			
+			if len(availableCustomFuncs) > 0 {
+				pterm.Error.Printf("Rule '%s' uses unknown function '%s'. Available custom functions: %v\n", 
+					ctx.rule.Id, ruleAction.Function, availableCustomFuncs)
+			} else {
+				pterm.Error.Printf("Rule '%s' uses unknown function '%s'. No custom functions loaded. Use --functions flag to load custom functions.\n", 
+					ctx.rule.Id, ruleAction.Function)
+			}
+		}
+		
+		// Add error result to make the missing function visible in reports
+		lock.Lock()
+		*ctx.ruleResults = append(*ctx.ruleResults, model.RuleFunctionResult{
+			Message:      fmt.Sprintf("Unknown function '%s' in rule '%s'", ruleAction.Function, ctx.rule.Id),
+			Rule:         ctx.rule,
+			StartNode:    &yaml.Node{},
+			EndNode:      &yaml.Node{},
+			RuleId:       ctx.rule.Id,
+			RuleSeverity: "error",
+			Path:         fmt.Sprint(ctx.rule.Given),
+		})
+		lock.Unlock()
 	}
 	return ctx.ruleResults
 }

motor/rule_applicator_test.go

@@ -2225,7 +2225,7 @@ paths:
 	results := ApplyRulesToRuleSet(rse)
 
 	assert.Len(t, results.Results, 1)
-	assert.Equal(t, "more than a single path exists, there are 3", results.Results[0].Message)
+	assert.Equal(t, "More than a single path exists, found 3 paths", results.Results[0].Message)
 }
 
 func TestApplyRules_TestRules_Custom_JS_Function_CustomDoc_CoreFunction_FunctionOptions(t *testing.T) {

plugin/plugin_loader.go

@@ -67,20 +67,29 @@ func LoadFunctions(path string, silence bool) (*Manager, error) {
 
 			// found something
 			if !silence {
-				pterm.Info.Printf("Located custom javascript function: '%s'\n", function.GetSchema().Name)
+				pterm.Info.Printf("Located custom javascript function: '%s' from file: %s\n", function.GetSchema().Name, fPath)
 			}
 			// check if the function is valid
 			sErr := function.CheckScript()
 
 			if sErr != nil {
 				pterm.Error.Printf("Failed to load function '%s': %s\n", fName, sErr.Error())
+				continue // Skip registering invalid functions
+			} else {
+				if !silence {
+					pterm.Success.Printf("Successfully validated JavaScript function: '%s'\n", fName)
+				}
 			}
 
 			// register core functions with this custom function.
 			RegisterCoreFunctions(function)
 
 			// register this function with the plugin manager
 			pm.RegisterFunction(fName, function)
+			
+			if !silence {
+				pterm.Info.Printf("Registered custom function: '%s' -> available for use in rulesets\n", fName)
+			}
 		}
 	}
 	return pm, nil

plugin/sample/js/check_single_path.js

@@ -1,10 +1,25 @@
+function getSchema() {
+    return {
+        "name": "checkSinglePath",
+        "description": "Checks that there is only a single path defined in the OpenAPI spec"
+    };
+}
+
 function runRule(input) {
+    // input should be the paths object from the OpenAPI spec
+    if (!input || typeof input !== 'object') {
+        return [];
+    }
+    
     const numPaths = Object.keys(input).length;
     if (numPaths > 1) {
         return [
             {
-                message: 'more than a single path exists, there are ' + numPaths
+                message: 'More than a single path exists, found ' + numPaths + ' paths'
             }
         ];
     }
+    
+    // Return empty array when rule passes (no violations)
+    return [];
 }

rulesets/examples/sample-plugin-ruleset.yaml

@@ -8,14 +8,14 @@ rules:
     formats: [oas2, oas3]
     given: $
     then:
-      function: uselessFunc
+      function: useless_func
     howToFix: You can't, it's just an example.
   sample-paths-rule:
     description: Load a custom function that checks for a single path
     severity: error
     recommended: true
     formats: [ oas2, oas3 ]
-    given: $
+    given: $.paths
     then:
-      function: checkSinglePathExists
+      function: check_single_path
     howToFix: use a spec with only a single path defined.