add LoadSchema APIs to the root package

At this point it's just wiring up dsl.Parse and dmt.Compile.
We can start using it in bindnode tests as well.

Fixes #188.

Author: mvdan

Diff for: examples_test.go

@@ -5,8 +5,10 @@ import (
 	"os"
 	"strings"
 
+	"github.com/ipld/go-ipld-prime"
 	"github.com/ipld/go-ipld-prime/codec/dagjson"
 	"github.com/ipld/go-ipld-prime/node/basicnode"
+	"github.com/ipld/go-ipld-prime/schema"
 )
 
 // Example_createDataAndMarshal shows how you can feed data into a NodeBuilder,
@@ -51,3 +53,23 @@ func Example_unmarshalData() {
 	// the data decoded was a map kind
 	// the length of the node is 2
 }
+
+func ExampleLoadSchema() {
+	ts, err := ipld.LoadSchema("sample.ipldsch", strings.NewReader(`
+		type Root struct {
+			foo Int
+			bar nullable String
+		}
+		`))
+	if err != nil {
+		panic(err)
+	}
+	typeRoot := ts.TypeByName("Root").(*schema.TypeStruct)
+	for _, field := range typeRoot.Fields() {
+		fmt.Printf("field name=%q nullable=%t type=%v\n",
+			field.Name(), field.IsNullable(), field.Type().Name())
+	}
+	// Output:
+	// field name="foo" nullable=false type=Int
+	// field name="bar" nullable=true type=String
+}

Diff for: node/bindnode/infer_test.go

@@ -10,12 +10,11 @@ import (
 	qt "github.com/frankban/quicktest"
 	"github.com/ipfs/go-cid"
 
+	"github.com/ipld/go-ipld-prime"
 	"github.com/ipld/go-ipld-prime/codec/dagjson"
 	"github.com/ipld/go-ipld-prime/datamodel"
 	"github.com/ipld/go-ipld-prime/node/bindnode"
 	"github.com/ipld/go-ipld-prime/schema"
-	schemadmt "github.com/ipld/go-ipld-prime/schema/dmt"
-	schemadsl "github.com/ipld/go-ipld-prime/schema/dsl"
 )
 
 type anyScalar struct {
@@ -144,22 +143,6 @@ var prototypeTests = []struct {
 	},
 }
 
-func loadSchema(t *testing.T, src string) schema.Type {
-	t.Helper()
-
-	dmt, err := schemadsl.Parse("", strings.NewReader(src))
-	qt.Assert(t, err, qt.IsNil)
-
-	var ts schema.TypeSystem
-	ts.Init()
-	err = schemadmt.Compile(&ts, dmt)
-	qt.Assert(t, err, qt.IsNil)
-
-	typ := ts.TypeByName("Root")
-	qt.Assert(t, typ, qt.Not(qt.IsNil))
-	return typ
-}
-
 func compactJSON(t *testing.T, pretty string) string {
 	var buf bytes.Buffer
 	err := json.Compact(&buf, []byte(pretty))
@@ -195,7 +178,10 @@ func TestPrototype(t *testing.T) {
 			t.Run(test.name+suffix, func(t *testing.T) {
 				t.Parallel()
 
-				schemaType := loadSchema(t, test.schemaSrc)
+				ts, err := ipld.LoadSchemaBytes([]byte(test.schemaSrc))
+				qt.Assert(t, err, qt.IsNil)
+				schemaType := ts.TypeByName("Root")
+				qt.Assert(t, schemaType, qt.Not(qt.IsNil))
 
 				if onlySchema {
 					test.ptrType = nil

Diff for: schema.go

@@ -0,0 +1,43 @@
+package ipld
+
+import (
+	"bytes"
+	"io"
+	"os"
+
+	"github.com/ipld/go-ipld-prime/schema"
+	schemadmt "github.com/ipld/go-ipld-prime/schema/dmt"
+	schemadsl "github.com/ipld/go-ipld-prime/schema/dsl"
+)
+
+// LoadSchemaBytes is a shortcut for LoadSchema for the common case where
+// the schema is available as a buffer or a string, such as via go:embed.
+func LoadSchemaBytes(src []byte) (*schema.TypeSystem, error) {
+	return LoadSchema("", bytes.NewReader(src))
+}
+
+// LoadSchemaBytes is a shortcut for LoadSchema for the common case where
+// the schema is a file on disk.
+func LoadSchemaFile(path string) (*schema.TypeSystem, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return LoadSchema(path, f)
+}
+
+// LoadSchema parses an IPLD Schema in its DSL form
+// and compiles its types into a standalone TypeSystem.
+func LoadSchema(name string, r io.Reader) (*schema.TypeSystem, error) {
+	sch, err := schemadsl.Parse(name, r)
+	if err != nil {
+		return nil, err
+	}
+	ts := new(schema.TypeSystem)
+	ts.Init()
+	if err := schemadmt.Compile(ts, sch); err != nil {
+		return nil, err
+	}
+	return ts, nil
+}