Merge branch 'main' into improve-yaml-to-json

bundler/bundler_test.go

@@ -150,7 +150,7 @@ components:
 	assert.ErrorIs(t, unwrap[0], ErrInvalidModel)
 	unwrapNext := utils.UnwrapErrors(unwrap[1])
 	require.Len(t, unwrapNext, 2)
-	assert.Equal(t, "component 'bork' does not exist in the specification", unwrapNext[0].Error())
+	assert.Equal(t, "component `bork` does not exist in the specification", unwrapNext[0].Error())
 	assert.Equal(t, "cannot resolve reference `bork`, it's missing: $bork [5:7]", unwrapNext[1].Error())
 
 	logEntries := strings.Split(byteBuf.String(), "\n")

datamodel/high/base/schema_proxy.go

@@ -72,6 +72,14 @@ func CreateSchemaProxyRef(ref string) *SchemaProxy {
 	return &SchemaProxy{refStr: ref, lock: &sync.Mutex{}}
 }
 
+// GetValueNode returns the value node of the SchemaProxy.
+func (sp *SchemaProxy) GetValueNode() *yaml.Node {
+	if sp.schema != nil {
+		return sp.schema.ValueNode
+	}
+	return nil
+}
+
 // Schema will create a new Schema instance using NewSchema from the low-level SchemaProxy backing this high-level one.
 // If there is a problem building the Schema, then this method will return nil. Use GetBuildError to gain access
 // to that building error.

datamodel/high/base/schema_proxy_test.go

@@ -69,6 +69,20 @@ func TestCreateSchemaProxy(t *testing.T) {
 	sp := CreateSchemaProxy(&Schema{Description: "iAmASchema"})
 	assert.Equal(t, "iAmASchema", sp.rendered.Description)
 	assert.False(t, sp.IsReference())
+	assert.Nil(t, sp.GetValueNode())
+}
+
+func TestCreateSchemaProxy_NoNilValue(t *testing.T) {
+	sp := CreateSchemaProxy(&Schema{Description: "iAmASchema"})
+	sp.Schema()
+
+	// jerry rig the test.
+	nodeRef := low.NodeReference[*lowbase.SchemaProxy]{}
+	nodeRef.ValueNode = &yaml.Node{}
+	sp.schema = &nodeRef
+
+	assert.Equal(t, "iAmASchema", sp.rendered.Description)
+	assert.NotNil(t, sp.GetValueNode())
 }
 
 func TestCreateSchemaProxyRef(t *testing.T) {

datamodel/high/node_builder.go

@@ -443,7 +443,7 @@ func (n *NodeBuilder) AddYAMLNode(parent *yaml.Node, entry *nodes.NodeEntry) *ya
 					lr := lut.(low.IsReferenced)
 					ut := reflect.ValueOf(lr)
 					if !ut.IsNil() {
-						if lut.(low.IsReferenced).IsReference() {
+						if lr != nil && lr.IsReference() {
 							if !n.Resolve {
 								valueNode = n.renderReference(lut.(low.IsReferenced))
 								break

datamodel/high/v3/document.go

@@ -155,6 +155,11 @@ func (d *Document) GoLow() *low.Document {
 	return d.low
 }
 
+// GoLowUntyped returns the low-level Document that was used to create the high level one, however, it's untyped.
+func (d *Document) GoLowUntyped() any {
+	return d.low
+}
+
 // Render will return a YAML representation of the Document object as a byte slice.
 func (d *Document) Render() ([]byte, error) {
 	return yaml.Marshal(d)

datamodel/high/v3/document_test.go

@@ -87,6 +87,7 @@ func TestNewDocument_Info(t *testing.T) {
 	assert.Equal(t, "1.2", highDoc.Info.Version)
 	assert.Equal(t, "https://pb33f.io/schema", highDoc.JsonSchemaDialect)
 
+	assert.NotNil(t, highDoc.GoLowUntyped())
 	wentLow := highDoc.GoLow()
 	assert.Equal(t, 1, wentLow.Version.ValueNode.Line)
 	assert.Equal(t, 3, wentLow.Info.Value.Title.KeyNode.Line)

datamodel/low/base/contact.go

@@ -23,14 +23,14 @@ type Contact struct {
 	KeyNode  *yaml.Node
 	RootNode *yaml.Node
 	*low.Reference
+	low.NodeMap
 }
 
-// Build is not implemented for Contact (there is nothing to build).
-func (c *Contact) Build(_ context.Context, keyNode, root *yaml.Node, _ *index.SpecIndex) error {
+func (c *Contact) Build(ctx context.Context, keyNode, root *yaml.Node, _ *index.SpecIndex) error {
 	c.KeyNode = keyNode
 	c.RootNode = root
 	c.Reference = new(low.Reference)
-	// not implemented.
+	c.Nodes = low.ExtractNodes(ctx, root)
 	return nil
 }
 

datamodel/low/base/context.go

@@ -0,0 +1,30 @@
+// Copyright 2023-2024 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+
+package base
+
+import (
+	"golang.org/x/net/context"
+	"sync"
+)
+
+// ModelContext is a struct that holds various persistent data structures for the model
+// that passes through the entire model building process.
+type ModelContext struct {
+	SchemaCache *sync.Map
+}
+
+// GetModelContext will return the ModelContext from a context.Context object
+// if it is available, otherwise it will return nil.
+func GetModelContext(ctx context.Context) *ModelContext {
+	if ctx == nil {
+		return nil
+	}
+	if ctx.Value("modelCtx") == nil {
+		return nil
+	}
+	if c, ok := ctx.Value("modelCtx").(*ModelContext); ok {
+		return c
+	}
+	return nil
+}

datamodel/low/base/context_test.go

@@ -0,0 +1,23 @@
+// Copyright 2023-2024 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+
+package base
+
+import (
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/net/context"
+	"testing"
+)
+
+func TestGetModelContext(t *testing.T) {
+
+	assert.Nil(t, GetModelContext(nil))
+	assert.Nil(t, GetModelContext(context.Background()))
+
+	ctx := context.WithValue(context.Background(), "modelCtx", &ModelContext{})
+	assert.NotNil(t, GetModelContext(ctx))
+
+	ctx = context.WithValue(context.Background(), "modelCtx", "wrong")
+	assert.Nil(t, GetModelContext(ctx))
+
+}

datamodel/low/base/discriminator.go

@@ -5,6 +5,7 @@ package base
 
 import (
 	"crypto/sha256"
+	"gopkg.in/yaml.v3"
 	"strings"
 
 	"github.com/pb33f/libopenapi/datamodel/low"
@@ -23,7 +24,20 @@ import (
 type Discriminator struct {
 	PropertyName low.NodeReference[string]
 	Mapping      low.NodeReference[*orderedmap.Map[low.KeyReference[string], low.ValueReference[string]]]
+	KeyNode      *yaml.Node
+	RootNode     *yaml.Node
 	low.Reference
+	low.NodeMap
+}
+
+// GetRootNode will return the root yaml node of the Discriminator object
+func (d *Discriminator) GetRootNode() *yaml.Node {
+	return d.RootNode
+}
+
+// GetKeyNode will return the key yaml node of the Discriminator object
+func (d *Discriminator) GetKeyNode() *yaml.Node {
+	return d.KeyNode
 }
 
 // FindMappingValue will return a ValueReference containing the string mapping value

datamodel/low/base/discriminator_test.go

@@ -46,6 +46,11 @@ propertyName: freshCakes`
 	var rDoc Discriminator
 	_ = low.BuildModel(lNode.Content[0], &lDoc)
 	_ = low.BuildModel(rNode.Content[0], &rDoc)
+	lDoc.RootNode = &lNode
+	lDoc.KeyNode = &rNode
 
 	assert.Equal(t, lDoc.Hash(), rDoc.Hash())
+	assert.NotNil(t, lDoc.GetRootNode())
+	assert.NotNil(t, lDoc.GetKeyNode())
+
 }

datamodel/low/base/example.go

@@ -28,6 +28,7 @@ type Example struct {
 	KeyNode       *yaml.Node
 	RootNode      *yaml.Node
 	*low.Reference
+	low.NodeMap
 }
 
 // FindExtension returns a ValueReference containing the extension value, if found.
@@ -67,12 +68,13 @@ func (ex *Example) Hash() [32]byte {
 }
 
 // Build extracts extensions and example value
-func (ex *Example) Build(_ context.Context, keyNode, root *yaml.Node, _ *index.SpecIndex) error {
+func (ex *Example) Build(ctx context.Context, keyNode, root *yaml.Node, _ *index.SpecIndex) error {
 	ex.KeyNode = keyNode
 	root = utils.NodeAlias(root)
 	ex.RootNode = root
 	utils.CheckForMergeNodes(root)
 	ex.Reference = new(low.Reference)
+	ex.Nodes = low.ExtractNodes(ctx, root)
 	ex.Extensions = low.ExtractExtensions(root)
 	_, ln, vn := utils.FindKeyNodeFull(ValueLabel, root.Content)
 
@@ -82,6 +84,15 @@ func (ex *Example) Build(_ context.Context, keyNode, root *yaml.Node, _ *index.S
 			KeyNode:   ln,
 			ValueNode: vn,
 		}
+
+		// extract nodes for all value nodes down the tree.
+		expChildNodes := low.ExtractNodesRecursive(ctx, vn)
+		expChildNodes.Range(func(k, v interface{}) bool {
+			if arr, ko := v.([]*yaml.Node); ko {
+				ex.Nodes.Store(k, arr)
+			}
+			return true
+		})
 		return nil
 	}
 	return nil

datamodel/low/base/external_doc.go

@@ -28,6 +28,7 @@ type ExternalDoc struct {
 	KeyNode     *yaml.Node
 	RootNode    *yaml.Node
 	*low.Reference
+	low.NodeMap
 }
 
 // FindExtension returns a ValueReference containing the extension value, if found.
@@ -46,12 +47,13 @@ func (ex *ExternalDoc) GetKeyNode() *yaml.Node {
 }
 
 // Build will extract extensions from the ExternalDoc instance.
-func (ex *ExternalDoc) Build(_ context.Context, keyNode, root *yaml.Node, idx *index.SpecIndex) error {
+func (ex *ExternalDoc) Build(ctx context.Context, keyNode, root *yaml.Node, idx *index.SpecIndex) error {
 	ex.KeyNode = keyNode
 	root = utils.NodeAlias(root)
 	ex.RootNode = root
 	utils.CheckForMergeNodes(root)
 	ex.Reference = new(low.Reference)
+	ex.Nodes = low.ExtractNodes(ctx, root)
 	ex.Extensions = low.ExtractExtensions(root)
 	return nil
 }

datamodel/low/base/info.go

@@ -35,6 +35,7 @@ type Info struct {
 	KeyNode        *yaml.Node
 	RootNode       *yaml.Node
 	*low.Reference
+	low.NodeMap
 }
 
 // FindExtension attempts to locate an extension with the supplied key
@@ -64,6 +65,7 @@ func (i *Info) Build(ctx context.Context, keyNode, root *yaml.Node, idx *index.S
 	i.RootNode = root
 	utils.CheckForMergeNodes(root)
 	i.Reference = new(low.Reference)
+	i.Nodes = low.ExtractNodes(ctx, root)
 	i.Extensions = low.ExtractExtensions(root)
 
 	// extract contact

datamodel/low/base/license.go

@@ -25,6 +25,7 @@ type License struct {
 	KeyNode    *yaml.Node
 	RootNode   *yaml.Node
 	*low.Reference
+	low.NodeMap
 }
 
 // Build out a license, complain if both a URL and identifier are present as they are mutually exclusive
@@ -34,6 +35,8 @@ func (l *License) Build(ctx context.Context, keyNode, root *yaml.Node, idx *inde
 	l.RootNode = root
 	utils.CheckForMergeNodes(root)
 	l.Reference = new(low.Reference)
+	no := low.ExtractNodes(ctx, root)
+	l.Nodes = no
 	if l.URL.Value != "" && l.Identifier.Value != "" {
 		return fmt.Errorf("license cannot have both a URL and an identifier, they are mutually exclusive")
 	}