More initial dev

types/schemas.go

@@ -0,0 +1,180 @@
+package types
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	"github.com/rancher/norman/name"
+	"github.com/rancher/norman/types/convert"
+)
+
+type SchemaCollection struct {
+	Data []Schema
+}
+
+type Schemas struct {
+	schemasByPath map[string]map[string]*Schema
+	mappers       map[string]map[string]Mapper
+	versions      []APIVersion
+	schemas       []*Schema
+	errors        []error
+}
+
+func NewSchemas() *Schemas {
+	return &Schemas{
+		schemasByPath: map[string]map[string]*Schema{},
+		mappers:       map[string]map[string]Mapper{},
+	}
+}
+
+func (s *Schemas) Err() error {
+	return NewErrors(s.errors)
+}
+
+func (s *Schemas) AddSchema(schema *Schema) *Schemas {
+	schema.Type = "schema"
+	if schema.ID == "" {
+		s.errors = append(s.errors, fmt.Errorf("ID is not set on schema: %v", schema))
+		return s
+	}
+	if schema.Version.Path == "" || schema.Version.Group == "" || schema.Version.Version == "" {
+		s.errors = append(s.errors, fmt.Errorf("version is not set on schema: %s", schema.ID))
+		return s
+	}
+	if schema.PluralName == "" {
+		schema.PluralName = name.GuessPluralName(schema.ID)
+	}
+	if schema.CodeName == "" {
+		schema.CodeName = convert.Capitalize(schema.ID)
+	}
+
+	schemas, ok := s.schemasByPath[schema.Version.Path]
+	if !ok {
+		schemas = map[string]*Schema{}
+		s.schemasByPath[schema.Version.Path] = schemas
+		s.versions = append(s.versions, schema.Version)
+	}
+
+	if _, ok := schemas[schema.ID]; !ok {
+		schemas[schema.ID] = schema
+		s.schemas = append(s.schemas, schema)
+	}
+
+	return s
+}
+
+func (s *Schemas) AddMapper(version *APIVersion, schemaID string, mapper Mapper) *Schemas {
+	mappers, ok := s.mappers[version.Path]
+	if !ok {
+		mappers = map[string]Mapper{}
+		s.mappers[version.Path] = mappers
+	}
+
+	if _, ok := mappers[schemaID]; !ok {
+		mappers[schemaID] = mapper
+	}
+
+	return s
+}
+
+func (s *Schemas) SchemasForVersion(version APIVersion) map[string]*Schema {
+	return s.schemasByPath[version.Path]
+}
+
+func (s *Schemas) Versions() []APIVersion {
+	return s.versions
+}
+
+func (s *Schemas) Schemas() []*Schema {
+	return s.schemas
+}
+
+func (s *Schemas) mapper(version *APIVersion, name string) Mapper {
+	var (
+		path string
+	)
+
+	if strings.Contains(name, "/") {
+		idx := strings.LastIndex(name, "/")
+		path = name[0:idx]
+		name = name[idx+1:]
+	} else if version != nil {
+		path = version.Path
+	} else {
+		path = "core"
+	}
+
+	mappers, ok := s.mappers[path]
+	if !ok {
+		return nil
+	}
+
+	mapper := mappers[name]
+	if mapper != nil {
+		return mapper
+	}
+
+	return nil
+}
+
+func (s *Schemas) Schema(version *APIVersion, name string) *Schema {
+	var (
+		path string
+	)
+
+	if strings.Contains(name, "/") {
+		idx := strings.LastIndex(name, "/")
+		path = name[0:idx]
+		name = name[idx+1:]
+	} else if version != nil {
+		path = version.Path
+	} else {
+		path = "core"
+	}
+
+	schemas, ok := s.schemasByPath[path]
+	if !ok {
+		return nil
+	}
+
+	schema := schemas[name]
+	if schema != nil {
+		return schema
+	}
+
+	for _, check := range schemas {
+		if strings.EqualFold(check.ID, name) || strings.EqualFold(check.PluralName, name) {
+			return check
+		}
+	}
+
+	return nil
+}
+
+type multiErrors struct {
+	errors []error
+}
+
+func NewErrors(errors []error) error {
+	if len(errors) == 0 {
+		return nil
+	} else if len(errors) == 1 {
+		return errors[0]
+	}
+	return &multiErrors{
+		errors: errors,
+	}
+}
+
+func (m *multiErrors) Error() string {
+	buf := bytes.NewBuffer(nil)
+	for _, err := range m.errors {
+		if buf.Len() > 0 {
+			buf.WriteString(", ")
+		}
+		buf.WriteString(err.Error())
+	}
+
+	return buf.String()
+}