rename

Author: jba

jsonschema/resolve.go

@@ -26,14 +26,14 @@ type Resolved struct {
 	// map from $ids to their schemas
 	resolvedURIs map[string]*Schema
 	// map from schemas to additional info computed during resolution
-	resolvedInfo map[*Schema]*resolvedInfo
+	resolvedInfos map[*Schema]*resolvedInfo
 }
 
 func newResolved(s *Schema) *Resolved {
 	return &Resolved{
-		root:         s,
-		resolvedURIs: map[string]*Schema{},
-		resolvedInfo: map[*Schema]*resolvedInfo{},
+		root:          s,
+		resolvedURIs:  map[string]*Schema{},
+		resolvedInfos: map[*Schema]*resolvedInfo{},
 	}
 }
 
@@ -89,7 +89,7 @@ func (r *Resolved) schemaString(s *Schema) string {
 	if s.ID != "" {
 		return s.ID
 	}
-	info := r.resolvedInfo[s]
+	info := r.resolvedInfos[s]
 	if info.path != "" {
 		return info.path
 	}
@@ -187,7 +187,7 @@ func (r *resolver) resolve(s *Schema, baseURI *url.URL) (*Resolved, error) {
 	}
 	rs := newResolved(s)
 
-	if err := s.check(rs.resolvedInfo); err != nil {
+	if err := s.check(rs.resolvedInfos); err != nil {
 		return nil, err
 	}
 
@@ -199,7 +199,7 @@ func (r *resolver) resolve(s *Schema, baseURI *url.URL) (*Resolved, error) {
 	// which may differ if the schema has an $id.
 	// We must set the map before calling resolveRefs, or ref cycles will cause unbounded recursion.
 	r.loaded[baseURI.String()] = rs
-	r.loaded[rs.resolvedInfo[s].uri.String()] = rs
+	r.loaded[rs.resolvedInfos[s].uri.String()] = rs
 
 	if err := r.resolveRefs(rs); err != nil {
 		return nil, err
@@ -385,8 +385,8 @@ func (s *Schema) checkLocal(report func(error), infos map[*Schema]*resolvedInfo)
 func resolveURIs(rs *Resolved, baseURI *url.URL) error {
 	var resolve func(s, base *Schema) error
 	resolve = func(s, base *Schema) error {
-		info := rs.resolvedInfo[s]
-		baseInfo := rs.resolvedInfo[base]
+		info := rs.resolvedInfos[s]
+		baseInfo := rs.resolvedInfos[base]
 
 		// ids are scoped to the root.
 		if s.ID != "" {
@@ -405,7 +405,7 @@ func resolveURIs(rs *Resolved, baseURI *url.URL) error {
 			}
 			rs.resolvedURIs[info.uri.String()] = s
 			base = s // needed for anchors
-			baseInfo = rs.resolvedInfo[base]
+			baseInfo = rs.resolvedInfos[base]
 		}
 		info.base = base
 
@@ -436,7 +436,7 @@ func resolveURIs(rs *Resolved, baseURI *url.URL) error {
 	}
 
 	// Set the root URI to the base for now. If the root has an $id, this will change.
-	rs.resolvedInfo[rs.root].uri = baseURI
+	rs.resolvedInfos[rs.root].uri = baseURI
 	// The original base, even if changed, is still a valid way to refer to the root.
 	rs.resolvedURIs[baseURI.String()] = rs.root
 
@@ -448,7 +448,7 @@ func resolveURIs(rs *Resolved, baseURI *url.URL) error {
 // that needs to be loaded.
 func (r *resolver) resolveRefs(rs *Resolved) error {
 	for s := range rs.root.all() {
-		info := rs.resolvedInfo[s]
+		info := rs.resolvedInfos[s]
 		if s.Ref != "" {
 			refSchema, _, err := r.resolveRef(rs, s, s.Ref)
 			if err != nil {
@@ -484,8 +484,8 @@ func (r *resolver) resolveRef(rs *Resolved, s *Schema, ref string) (_ *Schema, d
 		return nil, "", err
 	}
 	// URI-resolve the ref against the current base URI to get a complete URI.
-	base := rs.resolvedInfo[s].base
-	refURI = rs.resolvedInfo[base].uri.ResolveReference(refURI)
+	base := rs.resolvedInfos[s].base
+	refURI = rs.resolvedInfos[base].uri.ResolveReference(refURI)
 	// The non-fragment part of a ref URI refers to the base URI of some schema.
 	// This part is the same for dynamic refs too: their non-fragment part resolves
 	// lexically.
@@ -517,9 +517,9 @@ func (r *resolver) resolveRef(rs *Resolved, s *Schema, ref string) (_ *Schema, d
 			assert(referencedSchema != nil, "nil referenced schema")
 			// Copy the resolvedInfos from lrs into rs, without overwriting
 			// (hence we can't use maps.Insert).
-			for s, i := range lrs.resolvedInfo {
-				if rs.resolvedInfo[s] == nil {
-					rs.resolvedInfo[s] = i
+			for s, i := range lrs.resolvedInfos {
+				if rs.resolvedInfos[s] == nil {
+					rs.resolvedInfos[s] = i
 				}
 			}
 		}
@@ -531,7 +531,7 @@ func (r *resolver) resolveRef(rs *Resolved, s *Schema, ref string) (_ *Schema, d
 	// A JSON Pointer is either the empty string or begins with a '/',
 	// whereas anchors are always non-empty strings that don't contain slashes.
 	if frag != "" && !strings.HasPrefix(frag, "/") {
-		resInfo := rs.resolvedInfo[referencedSchema]
+		resInfo := rs.resolvedInfos[referencedSchema]
 		info, found := resInfo.anchors[frag]
 
 		if !found {

jsonschema/resolve_test.go

@@ -91,13 +91,13 @@ func TestPaths(t *testing.T) {
 		{root.PrefixItems[1].Items, "/prefixItems/1/items"},
 	}
 	rs := newResolved(root)
-	if err := root.checkStructure(rs.resolvedInfo); err != nil {
+	if err := root.checkStructure(rs.resolvedInfos); err != nil {
 		t.Fatal(err)
 	}
 
 	var got []item
 	for s := range root.all() {
-		got = append(got, item{s, rs.resolvedInfo[s].path})
+		got = append(got, item{s, rs.resolvedInfos[s].path})
 	}
 	if !slices.Equal(got, want) {
 		t.Errorf("\ngot  %v\nwant %v", got, want)
@@ -133,7 +133,7 @@ func TestResolveURIs(t *testing.T) {
 			}
 
 			rs := newResolved(root)
-			if err := root.check(rs.resolvedInfo); err != nil {
+			if err := root.check(rs.resolvedInfos); err != nil {
 				t.Fatal(err)
 			}
 			if err := resolveURIs(rs, base); err != nil {
@@ -170,7 +170,7 @@ func TestResolveURIs(t *testing.T) {
 				t.Errorf("IDs:\ngot  %+v\n\nwant %+v", got, wantIDs)
 			}
 			for s := range root.all() {
-				info := rs.resolvedInfo[s]
+				info := rs.resolvedInfos[s]
 				if want := wantAnchors[s]; want != nil {
 					if got := info.anchors; !maps.Equal(got, want) {
 						t.Errorf("anchors:\ngot  %+v\n\nwant %+v", got, want)
@@ -207,7 +207,7 @@ func TestRefCycle(t *testing.T) {
 
 	check := func(s *Schema, key string) {
 		t.Helper()
-		if rs.resolvedInfo[s].resolvedRef != schemas[key] {
+		if rs.resolvedInfos[s].resolvedRef != schemas[key] {
 			t.Errorf("%s resolvedRef != schemas[%q]", s.json(), key)
 		}
 	}

jsonschema/validate.go

@@ -90,7 +90,7 @@ func (st *state) validate(instance reflect.Value, schema *Schema, callerAnns *an
 		instance = instance.Elem()
 	}
 
-	schemaInfo := st.rs.resolvedInfo[schema]
+	schemaInfo := st.rs.resolvedInfos[schema]
 
 	// type: https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-6.1.1
 	if schema.Type != "" || schema.Types != nil {
@@ -214,8 +214,8 @@ func (st *state) validate(instance reflect.Value, schema *Schema, callerAnns *an
 			// For an example, search for "detached" in testdata/draft2020-12/dynamicRef.json.
 			var dynamicSchema *Schema
 			for _, s := range st.stack {
-				base := st.rs.resolvedInfo[s].base
-				info, ok := st.rs.resolvedInfo[base].anchors[schemaInfo.dynamicRefAnchor]
+				base := st.rs.resolvedInfos[s].base
+				info, ok := st.rs.resolvedInfos[base].anchors[schemaInfo.dynamicRefAnchor]
 				if ok && info.dynamic {
 					dynamicSchema = info.schema
 					break
@@ -557,7 +557,7 @@ func (st *state) resolveDynamicRef(schema *Schema) (*Schema, error) {
 	if schema.DynamicRef == "" {
 		return nil, nil
 	}
-	info := st.rs.resolvedInfo[schema]
+	info := st.rs.resolvedInfos[schema]
 	// The ref behaves lexically or dynamically, but not both.
 	assert((info.resolvedDynamicRef == nil) != (info.dynamicRefAnchor == ""),
 		"DynamicRef not statically resolved properly")
@@ -575,8 +575,8 @@ func (st *state) resolveDynamicRef(schema *Schema) (*Schema, error) {
 	// on the stack.
 	// For an example, search for "detached" in testdata/draft2020-12/dynamicRef.json.
 	for _, s := range st.stack {
-		base := st.rs.resolvedInfo[s].base
-		info, ok := st.rs.resolvedInfo[base].anchors[info.dynamicRefAnchor]
+		base := st.rs.resolvedInfos[s].base
+		info, ok := st.rs.resolvedInfos[base].anchors[info.dynamicRefAnchor]
 		if ok && info.dynamic {
 			return info.schema, nil
 		}
@@ -615,7 +615,7 @@ func (rs *Resolved) ApplyDefaults(instancep any) error {
 func (st *state) applyDefaults(instancep reflect.Value, schema *Schema) (err error) {
 	defer util.Wrapf(&err, "applyDefaults: schema %s, instance %v", st.rs.schemaString(schema), instancep)
 
-	schemaInfo := st.rs.resolvedInfo[schema]
+	schemaInfo := st.rs.resolvedInfos[schema]
 	instance := instancep.Elem()
 	if instance.Kind() == reflect.Map || instance.Kind() == reflect.Struct {
 		if instance.Kind() == reflect.Map {