added more testing and handling for crazy refs.

Anything it does not know what to do with, it will inline.

Author: daveshanley

bundler/bundler.go

@@ -7,6 +7,7 @@ package bundler
 import (
 	"context"
 	"errors"
+	"path/filepath"
 	"slices"
 	"strings"
 	"sync"
@@ -136,22 +137,38 @@ func compose(model *v3.Document, compositionConfig *BundleCompositionConfig) ([]
 		processedNodes.Set(ref.ref.FullDefinition, ref)
 	}
 
-	rootIndex := rolodex.GetRootIndex()
-	remapIndex(rootIndex, processedNodes)
-
 	slices.SortFunc(indexes, func(i, j *index.SpecIndex) int {
 		if i.GetSpecAbsolutePath() < j.GetSpecAbsolutePath() {
 			return 1
 		}
 		return 0
 	})
 
+	rootIndex := rolodex.GetRootIndex()
+	remapIndex(rootIndex, processedNodes)
+
 	for _, idx := range indexes {
 		remapIndex(idx, processedNodes)
 	}
 
 	// anything that could not be recomposed and needs inlining
 	for _, pr := range cf.inlineRequired {
+		if pr.refPointer != "" {
+
+			// if the ref is a pointer to an external pointer, then we need to stitch it.
+			uri := strings.Split(pr.refPointer, "#/")
+			if len(uri) == 2 {
+				if uri[0] != "" {
+					if !filepath.IsAbs(uri[0]) && !strings.HasPrefix(uri[0], "http") {
+						// if the uri is not absolute, then we need to make it absolute.
+						uri[0] = filepath.Join(filepath.Dir(pr.idx.GetSpecAbsolutePath()), uri[0])
+					}
+					pointerRef := pr.idx.FindComponent(context.Background(), strings.Join(uri, "#/"))
+					pr.seqRef.Node.Content = pointerRef.Node.Content
+					continue
+				}
+			}
+		}
 		pr.seqRef.Node.Content = pr.ref.Node.Content
 	}
 
@@ -164,7 +181,6 @@ func compose(model *v3.Document, compositionConfig *BundleCompositionConfig) ([]
 func bundle(model *v3.Document) ([]byte, error) {
 	rolodex := model.Rolodex
 	indexes := rolodex.GetIndexes()
-	// indexMap := make(map[string]*index.SpecIndex)
 	// compact function.
 	compact := func(idx *index.SpecIndex, root bool) {
 		mappedReferences := idx.GetMappedReferences()

bundler/bundler_composer.go

@@ -15,11 +15,12 @@ import (
 )
 
 type processRef struct {
-	idx      *index.SpecIndex
-	ref      *index.Reference
-	seqRef   *index.Reference
-	name     string
-	location []string
+	idx        *index.SpecIndex
+	ref        *index.Reference
+	seqRef     *index.Reference
+	refPointer string
+	name       string
+	location   []string
 }
 
 type handleIndexConfig struct {

bundler/bundler_composer_test.go

@@ -109,7 +109,7 @@ func TestCheckReferenceAndBubbleUp(t *testing.T) {
 
 func TestRenameReference(t *testing.T) {
 	// test the rename reference function
-	assert.Equal(t, "#/_oh_#/_yeah", renameRef("#/_oh_#/_yeah", nil))
+	assert.Equal(t, "#/_oh_#/_yeah", renameRef(nil, "#/_oh_#/_yeah", nil))
 }
 
 func TestBuildSchema(t *testing.T) {
@@ -143,6 +143,6 @@ func TestBundlerComposed_StrangeRefs(t *testing.T) {
 
 	// windows needs a different byte count
 	if runtime.GOOS != "windows" {
-		assert.Len(t, bytes, 3075)
+		assert.Len(t, bytes, 3397)
 	}
 }

bundler/composer_functions.go

@@ -141,26 +141,38 @@ func checkForCollision[T any](schemaName, delimiter string, pr *processRef, comp
 func remapIndex(idx *index.SpecIndex, processedNodes *orderedmap.Map[string, *processRef]) {
 	seq := idx.GetRawReferencesSequenced()
 	for _, sequenced := range seq {
-		rewireRef(sequenced, sequenced.FullDefinition, processedNodes)
+		rewireRef(idx, sequenced, sequenced.FullDefinition, processedNodes)
 	}
+
 	mapped := idx.GetMappedReferences()
-	reMapped := make(map[string]*index.Reference)
+
 	for _, mRef := range mapped {
-		rewireRef(mRef, mRef.FullDefinition, processedNodes)
-		reMapped[mRef.FullDefinition] = mRef
+		origDef := mRef.FullDefinition
+		rewireRef(idx, mRef, mRef.FullDefinition, processedNodes)
+		mapped[mRef.FullDefinition] = mRef
+		mapped[origDef] = mRef
 	}
-	idx.SetMappedReferences(reMapped)
 }
 
-func renameRef(def string, processedNodes *orderedmap.Map[string, *processRef]) string {
+func renameRef(idx *index.SpecIndex, def string, processedNodes *orderedmap.Map[string, *processRef]) string {
 	if strings.Contains(def, "#/") {
 
 		defSplit := strings.Split(def, "#/")
 		if len(defSplit) != 2 {
 			return def
 		}
 		split := strings.Split(defSplit[1], "/")
-		return fmt.Sprintf("#/%s/%s", strings.Join(split[:len(split)-1], "/"), processedNodes.GetOrZero(def).name)
+		if ref := processedNodes.GetOrZero(def); ref != nil {
+			return fmt.Sprintf("#/%s/%s", strings.Join(split[:len(split)-1], "/"), ref.name)
+		}
+		if ref, ok := idx.GetMappedReferences()[def]; ok {
+			ext := filepath.Ext(ref.Name)
+			name := ref.Name
+			if ext != "" {
+				name = strings.Replace(ref.Name, ext, "", 1)
+			}
+			return fmt.Sprintf("#/%s/%s", strings.Join(split[:len(split)-1], "/"), name)
+		}
 	}
 
 	// handle root file imports.
@@ -173,16 +185,29 @@ func renameRef(def string, processedNodes *orderedmap.Map[string, *processRef])
 	return name
 }
 
-func rewireRef(ref *index.Reference, fullDef string, processedNodes *orderedmap.Map[string, *processRef]) {
+func rewireRef(idx *index.SpecIndex, ref *index.Reference, fullDef string, processedNodes *orderedmap.Map[string, *processRef]) {
 	isRef, _, _ := utils.IsNodeRefValue(ref.Node)
-	rename := renameRef(fullDef, processedNodes)
+
+	// extract the pr from the processed nodes.
+	if pr := processedNodes.GetOrZero(fullDef); pr != nil {
+		if kk, _, _ := utils.IsNodeRefValue(pr.ref.Node); kk {
+			if pr.refPointer == "" {
+				pr.refPointer = pr.ref.Node.Content[1].Value
+			}
+		}
+	}
+
+	rename := renameRef(idx, fullDef, processedNodes)
 	if isRef {
+
 		if ref.Node.Content[1].Value != rename {
 			ref.Node.Content[1].Value = rename
 		}
-		ref.FullDefinition = ref.Node.Content[1].Value
+		ref.FullDefinition = rename
+		ref.Definition = rename
 	} else {
 		ref.FullDefinition = rename
+		ref.Definition = rename
 	}
 }
 

datamodel/low/extraction_functions.go

@@ -93,7 +93,7 @@ func LocateRefNodeWithContext(ctx context.Context, root *yaml.Node, idx *index.S
 				// until we hit something that isn't a ref.
 				if jh, _, _ := utils.IsNodeRefValue(found[rv].Node); jh {
 					// if this node is circular, stop drop and roll.
-					if !IsCircular(found[rv].Node, idx) {
+					if !IsCircular(found[rv].Node, idx) && found[rv].Node != root {
 						return LocateRefNodeWithContext(ctx, found[rv].Node, idx)
 					} else {
 

index/rolodex_file_loader.go

@@ -218,8 +218,8 @@ func (l *LocalFile) GetContent() string {
 // GetContentAsYAMLNode returns the content of the file as a *yaml.Node. If something went wrong
 // then an error is returned.
 func (l *LocalFile) GetContentAsYAMLNode() (*yaml.Node, error) {
-	if l.parsed != nil {
-		return l.parsed, nil
+	if l.index != nil && l.index.root != nil {
+		return l.index.root, nil
 	}
 
 	// Lock before proceeding with parsing or modifications
@@ -232,9 +232,6 @@ func (l *LocalFile) GetContentAsYAMLNode() (*yaml.Node, error) {
 		return l.parsed, nil
 	}
 
-	if l.index != nil && l.index.root != nil {
-		return l.index.root, nil
-	}
 	if l.data == nil {
 		return nil, fmt.Errorf("no data to parse for file: %s", l.fullPath)
 	}