jsonschema: #51 - split into multiple files (#70)

* jsonschema: #51 - split into multiple files

This change splits the encoder logic into a separate file per supported
schema.FieldValidator type. It also provides some minor clenaups to the
documentation and adds some FIXME statements.

Functions / type defintions are declared in the order in which they are
called, which should make the code "read like an article from top to
bottom".

* jsonschema: #51 Cosnsistent function names

This commit renames all encoder functions to have consistent names.

Author: smyrman

schema/encoding/doc.go

@@ -0,0 +1,2 @@
+// Package encoding is the intended hierarchy location for encoding Schema to other formats.
+package encoding

schema/encoding/encoding.go

@@ -0,0 +1,28 @@
+package jsonschema
+
+import (
+	"io"
+	"strconv"
+
+	"github.com/rs/rest-layer/schema"
+)
+
+func encodeArray(w io.Writer, v *schema.Array) error {
+	ew := errWriter{w: w}
+
+	ew.writeString(`"type": "array"`)
+	if v.MinLen > 0 {
+		ew.writeFormat(`, "minItems": %s`, strconv.FormatInt(int64(v.MinLen), 10))
+	}
+	if v.MaxLen > 0 {
+		ew.writeFormat(`, "maxItems": %s`, strconv.FormatInt(int64(v.MaxLen), 10))
+	}
+	if v.ValuesValidator != nil {
+		ew.writeString(`, "items": {`)
+		if ew.err == nil {
+			ew.err = encodeValidator(w, v.ValuesValidator)
+		}
+		ew.writeString("}")
+	}
+	return ew.err
+}

schema/encoding/jsonschema/array.go

@@ -0,0 +1,13 @@
+package jsonschema
+
+import (
+	"io"
+
+	"github.com/rs/rest-layer/schema"
+)
+
+func encodeBool(w io.Writer, v *schema.Bool) error {
+	ew := errWriter{w: w}
+	ew.writeString(`"type": "boolean"`)
+	return ew.err
+}

schema/encoding/jsonschema/bool.go

@@ -0,0 +1,4 @@
+// Package jsonschema provides JSON Schema Draft 4 encoding support for schema.Schema. Note that the current
+// implementation is incomlete, and not all FieldValidator types are yet supported. Custom validators are also not
+// supported at the momenet.
+package jsonschema

schema/encoding/jsonschema/doc.go

@@ -0,0 +1,67 @@
+package jsonschema
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/rs/rest-layer/schema"
+)
+
+// Encoder writes the JSON Schema representation of a schema.Schema to an output stream. Note that only a sub-set of the
+// FieldValidator types in the schema package is supported at the moment. Custom validators are also not yet handled.
+// Attempting to encode a schema containing such fields will result in a ErrNotImplemented error.
+type Encoder struct {
+	io.Writer
+}
+
+// NewEncoder returns a new JSONSchema Encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{w}
+}
+
+// Encode writes the JSON Schema representation of s to the stream, followed by a newline character.
+func (e *Encoder) Encode(s *schema.Schema) error {
+	ew := errWriter{w: e.Writer}
+	ew.writeString("{")
+	if ew.err == nil {
+		ew.err = encodeSchema(e.Writer, s)
+	}
+	ew.writeString("}\n")
+	return ew.err
+}
+
+// Wrap IO writer so we can consolidate error handling in a single place. Also track properties written so we know when
+// to emit a separator.
+type errWriter struct {
+	w   io.Writer // writer instance
+	err error     // track errors
+}
+
+// Write ensures compatibility with the io.Writer interface.
+func (ew errWriter) Write(p []byte) (int, error) {
+	if ew.err != nil {
+		return 0, ew.err
+	}
+	return ew.w.Write(p)
+}
+
+func (ew errWriter) writeFormat(format string, a ...interface{}) {
+	if ew.err != nil {
+		return
+	}
+	_, ew.err = fmt.Fprintf(ew.w, format, a...)
+}
+
+func (ew errWriter) writeString(s string) {
+	if ew.err != nil {
+		return
+	}
+	_, ew.err = ew.w.Write([]byte(s))
+}
+
+func (ew errWriter) writeBytes(b []byte) {
+	if ew.err != nil {
+		return
+	}
+	_, ew.err = ew.w.Write(b)
+}

schema/encoding/jsonschema/encoder.go

@@ -0,0 +1,44 @@
+package jsonschema
+
+import (
+	"io"
+	"math"
+	"strconv"
+	"strings"
+
+	"github.com/rs/rest-layer/schema"
+)
+
+func encodeFloat(w io.Writer, v *schema.Float) error {
+	ew := errWriter{w: w}
+
+	ew.writeString(`"type": "number"`)
+	if len(v.Allowed) > 0 {
+		var allowed []string
+		for _, value := range v.Allowed {
+			allowed = append(allowed, strconv.FormatFloat(value, 'E', -1, 64))
+		}
+		ew.writeFormat(`, "enum": [%s]`, strings.Join(allowed, ","))
+	}
+	if ew.err == nil {
+		ew.err = boundariesToJSONSchema(w, v.Boundaries)
+	}
+	return ew.err
+}
+
+// boundariesToJSONSchema writes JSON Schema keys and values based on b, prefixed by a comma and without curly braces,
+// to w. The prefixing comma is only written if at least one key/value pair is also written.
+func boundariesToJSONSchema(w io.Writer, b *schema.Boundaries) error {
+	if b == nil {
+		return nil
+	}
+	ew := errWriter{w: w}
+
+	if !math.IsNaN(b.Min) && !math.IsInf(b.Min, -1) {
+		ew.writeFormat(`, "minimum": %s`, strconv.FormatFloat(b.Min, 'E', -1, 64))
+	}
+	if !math.IsNaN(b.Max) && !math.IsInf(b.Max, 1) {
+		ew.writeFormat(`, "maximum": %s`, strconv.FormatFloat(b.Max, 'E', -1, 64))
+	}
+	return ew.err
+}

schema/encoding/jsonschema/float.go

@@ -0,0 +1,26 @@
+package jsonschema
+
+import (
+	"io"
+	"strconv"
+	"strings"
+
+	"github.com/rs/rest-layer/schema"
+)
+
+func encodeInteger(w io.Writer, v *schema.Integer) error {
+	ew := errWriter{w: w}
+
+	ew.writeString(`"type": "integer"`)
+	if len(v.Allowed) > 0 {
+		var allowed []string
+		for _, value := range v.Allowed {
+			allowed = append(allowed, strconv.FormatInt(int64(value), 10))
+		}
+		ew.writeFormat(`, "enum": [%s]`, strings.Join(allowed, ","))
+	}
+	if ew.err == nil {
+		ew.err = boundariesToJSONSchema(w, v.Boundaries)
+	}
+	return ew.err
+}