Create DeducedType for schemafree types

Some types don't have a schema (CRDs), and so we're creating the schema
on the fly for these values. We also build the infrastructure to create
these types easily and similarly to how we handled existing types.

Author: Antoine Pelisse

typed/parser.go

@@ -114,3 +114,34 @@ func (p *parseableType) FromUnstructured(in interface{}) (TypedValue, error) {
 	}
 	return AsTyped(v, &p.parser.Schema, p.typename)
 }
+
+// DeducedParseableType is a ParseableType that deduces the type from
+// the content of the object.
+type DeducedParseableType struct{}
+
+var _ ParseableType = DeducedParseableType{}
+
+// IsValid always returns true for a DeducedParseableType.
+func (p DeducedParseableType) IsValid() bool {
+	return true
+}
+
+// FromYAML parses a yaml string into an object and deduces the type for
+// that object.
+func (p DeducedParseableType) FromYAML(object YAMLObject) (TypedValue, error) {
+	v, err := value.FromYAML([]byte(object))
+	if err != nil {
+		return TypedValue{}, err
+	}
+	return AsTypedDeduced(v), nil
+}
+
+// FromUnstructured converts a go interface to a TypedValue. It will return an
+// error if the input object uses un-handled types.
+func (p DeducedParseableType) FromUnstructured(in interface{}) (TypedValue, error) {
+	v, err := value.FromUnstructured(in)
+	if err != nil {
+		return TypedValue{}, err
+	}
+	return AsTypedDeduced(v), nil
+}

typed/typed.go

@@ -47,6 +47,17 @@ func AsTyped(v value.Value, s *schema.Schema, typeName string) (TypedValue, erro
 	return tv, nil
 }
 
+// AsTypedDeduced is going to generate it's own type definition based on
+// the content of the object. This is useful for CRDs that don't have a
+// validation field.
+func AsTypedDeduced(v value.Value) TypedValue {
+	return TypedValue{
+		value: v,
+		typeRef: schema.TypeRefFromValue(v),
+		schema: nil,
+	}
+}
+
 // AsValue removes the type from the TypedValue and only keeps the value.
 func (tv TypedValue) AsValue() *value.Value {
 	return &tv.value