Initial commit

Allez les bleus ! 🇫🇷

Author: dolmen

.gitignore

@@ -0,0 +1,5 @@
+/openapi-preprocessor
+/*.yaml
+/*.yml
+/*.json
+/*.pl

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

io.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+func loadURL(u *url.URL) (map[string]interface{}, error) {
+	if u.Scheme != "file" {
+		return nil, fmt.Errorf("unsupported %q URL scheme", u.Scheme)
+	}
+
+	return loadFile(filepath.FromSlash(u.Path))
+}
+
+func loadFile(pth string) (map[string]interface{}, error) {
+	f, err := os.Open(pth)
+	if err != nil {
+		return nil, err
+	}
+	var load func(io.Reader) (map[string]interface{}, error)
+	switch filepath.Ext(pth) {
+	case ".json":
+		load = loadJSON
+	case ".yaml", ".yml":
+		load = loadYAML
+	default:
+		return nil, errors.New("unsupported file extension")
+	}
+	return load(f)
+}
+
+func loadYAML(r io.Reader) (map[string]interface{}, error) {
+	data, err := loadAny(yaml.NewDecoder(r))
+	if err != nil {
+		return nil, err
+	}
+	return fixMaps(data).(map[string]interface{}), err
+}
+
+func fixMaps(v interface{}) interface{} {
+	switch v := v.(type) {
+	case nil, bool, string, int, int64, float64:
+	case []interface{}:
+		for i, item := range v {
+			v[i] = fixMaps(item)
+		}
+	case map[interface{}]interface{}:
+		m := make(map[string]interface{}, len(v))
+		for key, val := range v {
+			m[fmt.Sprint(key)] = fixMaps(val)
+		}
+		return m
+	case map[string]interface{}:
+		for key, value := range v {
+			v[key] = fixMaps(value)
+		}
+	}
+	return v
+}
+
+func loadJSON(r io.Reader) (map[string]interface{}, error) {
+	return loadAny(json.NewDecoder(r))
+}
+
+func loadAny(decoder interface{ Decode(interface{}) error }) (map[string]interface{}, error) {
+	var data map[string]interface{}
+	err := decoder.Decode(&data)
+	if err != nil {
+		return nil, err
+	}
+	if data == nil {
+		return nil, errors.New("unexpected empty object")
+	}
+	return data, err
+}

main.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"path/filepath"
+)
+
+func main() {
+	code, err := _main()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		if code == 0 {
+			code = 1
+		}
+	}
+	os.Exit(code)
+}
+
+func _main() (int, error) {
+	log.SetPrefix("")
+	log.SetFlags(0)
+
+	if len(os.Args) < 2 {
+		return 1, fmt.Errorf("usage: %s <file>", os.Args[0])
+	}
+
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetIndent("", "  ")
+
+	return 0, processFile(os.Args[1], enc.Encode)
+}
+
+func processFile(pth string, encode func(interface{}) error) error {
+	pth, err := filepath.Abs(pth)
+	if err != nil {
+		return err
+	}
+
+	spec, err := loadFile(pth)
+	if err != nil {
+		return err
+	}
+
+	var tmp interface{}
+	tmp = spec
+
+	err = ExpandRefs(&tmp, &url.URL{
+		Scheme: "file",
+		Path:   filepath.ToSlash(pth),
+	})
+	if err != nil {
+		return err
+	}
+
+	return encode(tmp)
+}

refs.go

@@ -0,0 +1,376 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/mohae/deepcopy"
+
+	"github.com/dolmen-go/jsonptr"
+)
+
+type setter func(interface{})
+
+// visitRefs visits $ref and allows to change them.
+func visitRefs(root interface{}, ptr jsonptr.Pointer, visitor func(jsonptr.Pointer, string) (string, error)) (err error) {
+	switch root := root.(type) {
+	case map[string]interface{}:
+		ptr = ptr.Copy()
+		for k, v := range root {
+			ptr.Property(k)
+			if k == "$ref" {
+				if str, isString := v.(string); isString {
+					root[k], err = visitor(ptr, str)
+					if err != nil {
+						return
+					}
+				}
+			}
+			ptr.Up()
+		}
+	case []string:
+		ptr = ptr.Copy()
+		for i, v := range root {
+			ptr.Index(i)
+			visitRefs(v, ptr, visitor)
+			ptr.Up()
+		}
+	}
+	return
+}
+
+type refResolver struct {
+	rootURL string
+	docs    map[string]*interface{}
+}
+
+func (resolver *refResolver) resolve(link string, relativeTo *url.URL) (interface{}, setter, *url.URL, error) {
+	u, err := url.Parse(link)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	if !u.IsAbs() {
+		u = relativeTo.ResolveReference(u)
+	}
+
+	if *u == *relativeTo {
+		return nil, nil, nil, errors.New("circular link")
+	}
+
+	rootURL := *u
+	rootURL.Fragment = ""
+	rootURLStr := rootURL.String()
+
+	rdoc, loaded := resolver.docs[rootURLStr]
+	if !loaded {
+		//log.Println("Loading", &rootURL)
+		doc, err := loadURL(&rootURL)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		var itf interface{}
+		itf = doc
+		rdoc = &itf
+		resolver.docs[rootURLStr] = rdoc
+	}
+
+	if u.Fragment == "" {
+		return *rdoc, func(newDoc interface{}) {
+			*rdoc = newDoc
+		}, &rootURL, nil
+	}
+
+	ptr, err := jsonptr.Parse(u.Fragment)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	// FIXME we could reduce the number of evals of JSON pointers...
+
+	frag, err := ptr.In(*rdoc)
+	if err != nil {
+		// If the can't be immediately resolved, this may be because
+		// of a $inline in the way
+
+		p := ptr[:1]
+		for {
+			doc, err := p.In(*rdoc)
+			if err == nil {
+				break
+			}
+			if obj, isMap := doc.(map[string]interface{}); isMap {
+				if _, isInline := obj["$inline"]; isInline {
+					u2 := rootURL
+					u2.Fragment = p.String()
+					var target interface{}
+
+					err := resolver.expand(doc, func(newDoc interface{}) {
+						target = newDoc
+					}, &u2, nil, map[string]bool{})
+					if err != nil {
+						return nil, nil, nil, err
+					}
+
+					p.Set(rdoc, target)
+				}
+			}
+			if len(p) == len(ptr) {
+				// Failed to resolve the fragment
+				return nil, nil, nil, err
+			}
+		}
+
+		frag, _ = ptr.In(*rdoc)
+	}
+
+	return frag, func(newDoc interface{}) {
+		ptr.Set(rdoc, newDoc)
+	}, &rootURL, nil
+}
+
+func (resolver *refResolver) expand(doc interface{}, set setter, docURL *url.URL, imp map[string]string, visited map[string]bool) error {
+	u := docURL.String()
+	//log.Println(u, docURL.Fragment)
+	if visited[u] {
+		return nil
+	}
+	visited[u] = true
+
+	if doc, isSlice := doc.([]interface{}); isSlice {
+		u2 := *docURL
+		for i, v := range doc {
+			switch v.(type) {
+			case []interface{}, map[string]interface{}:
+				u2.Fragment = fmt.Sprintf("%s/%d", docURL.Fragment, i)
+				err := resolver.expand(v, func(newDoc interface{}) {
+					doc[i] = newDoc
+				}, &u2, imp, visited)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	obj, isObject := doc.(map[string]interface{})
+	if !isObject || obj == nil {
+		return nil
+	}
+
+	if ref, isRef := obj["$ref"]; isRef {
+		//log.Printf("$ref: %s => %s", docURL, ref)
+		link, isString := ref.(string)
+		if !isString {
+			return fmt.Errorf("%s: $ref must be a string", docURL)
+		}
+		if len(obj) > 1 {
+			return fmt.Errorf("%s: $ref must be alone (use $merge instead)", docURL)
+		}
+
+		doc, set, u, err := resolver.resolve(link, docURL)
+		if err != nil {
+			return err
+		}
+		//log.Printf("%#v", doc)
+		resolver.expand(doc, func(newDoc interface{}) {
+			doc = newDoc
+			set(newDoc)
+		}, u, imp, visited)
+		if err != nil {
+			return err
+		}
+
+		if imp != nil {
+			fragment := docURL.Fragment
+			u2 := *u
+			u2.Fragment = ""
+			u2str := u2.String()
+			if u2str != resolver.rootURL {
+				if src := imp[fragment]; src != "" && src != u2str {
+					return fmt.Errorf("import fragment %s from both %s and %s", link, src, u2str)
+				}
+				imp[fragment] = u2str
+			}
+		}
+
+		return nil
+	}
+
+	// An extension to build an object from mixed local data and
+	// imported data
+	if link, isMerge := obj["$merge"]; isMerge {
+		var links []string
+		switch link := link.(type) {
+		case string:
+			if len(obj) == 1 {
+				return fmt.Errorf("%s: merging with nothing?", docURL)
+			}
+			links = []string{link}
+		case []interface{}:
+			links = make([]string, len(link))
+			for i, v := range link {
+				l, isString := v.(string)
+				if !isString {
+					return fmt.Errorf("%s/%d: must be a string", docURL, i)
+				}
+				links[i] = l
+			}
+		default:
+			return fmt.Errorf("%s: must be a string or array of strings", docURL)
+		}
+		delete(obj, "$merge")
+
+		s := docURL.String()
+		delete(visited, s)
+		err := resolver.expand(doc, func(newDoc interface{}) {
+			doc = newDoc
+			set(newDoc)
+		}, docURL, imp, visited)
+		visited[s] = true
+		if err != nil {
+			return err
+		}
+
+		for i, link := range links {
+			target, set, u, err := resolver.resolve(link, docURL)
+			if err != nil {
+				return err
+			}
+			err = resolver.expand(doc, func(newDoc interface{}) {
+				target = newDoc
+				set(newDoc)
+			}, u, imp, visited)
+			if err != nil {
+				return err
+			}
+
+			objTarget, isObj := target.(map[string]interface{})
+			if !isObj {
+				if len(links) == 1 {
+					return fmt.Errorf("%s/$merge: link must point to object", docURL)
+				}
+				return fmt.Errorf("%s/$merge/%d: link must point to object", docURL, i)
+			}
+			for k, v := range objTarget {
+				if _, exists := obj[k]; exists {
+					// TODO warn
+					continue
+				}
+				obj[k] = v
+			}
+		}
+
+		return nil
+	}
+
+	if link, isInline := obj["$inline"]; isInline {
+
+		target, setTarget, u, err := resolver.resolve(link.(string), docURL)
+		if err != nil {
+			return err
+		}
+		err = resolver.expand(doc, func(newDoc interface{}) {
+			target = newDoc
+			setTarget(newDoc)
+		}, u, imp, visited)
+		if err != nil {
+			return err
+		}
+
+		if len(obj) == 1 {
+			set(target)
+			return nil
+		}
+
+		delete(obj, "$inline")
+		target = deepcopy.Copy(target)
+
+		switch target.(type) {
+		case map[string]interface{}:
+			for _, k := range sortedKeys(obj) {
+				v := obj[k]
+				//log.Println(k)
+				u := *docURL
+				u.Fragment = u.Fragment + "/" + jsonptr.EscapeString(k)
+				resolver.expand(v, func(newDoc interface{}) {
+					v = newDoc
+				}, &u, imp, visited)
+				if err := jsonptr.Set(&target, "/"+k, v); err != nil {
+					return fmt.Errorf("%s/%s: %v", docURL, k, err)
+				}
+			}
+		case []interface{}:
+			// TODO
+			return fmt.Errorf("%s: inlining of array not yet implemented", docURL)
+		default:
+			return fmt.Errorf("%s: inlined scalar value can't be patched", docURL)
+		}
+
+		set(target)
+		// doc = target
+		return nil
+	}
+
+	for _, k := range sortedKeys(obj) {
+		//log.Println("Key:", k)
+		u := *docURL
+		u.Fragment = u.Fragment + "/" + jsonptr.EscapeString(k)
+		resolver.expand(obj[k], func(newDoc interface{}) {
+			obj[k] = newDoc
+		}, &u, imp, visited)
+	}
+
+	return nil
+}
+
+func ExpandRefs(rdoc *interface{}, docURL *url.URL) error {
+	if len(docURL.Fragment) > 0 {
+		panic("URL fragment unexpected for initial document")
+	}
+
+	docURLstr := docURL.String()
+	resolver := refResolver{
+		rootURL: docURL.String(),
+		docs: map[string]*interface{}{
+			docURLstr: rdoc,
+		},
+	}
+
+	toInject := make(map[string]string)
+
+	err := resolver.expand(*rdoc, func(newDoc interface{}) {
+		*rdoc = newDoc
+	}, docURL, toInject, make(map[string]bool))
+
+	if err != nil {
+		return err
+	}
+
+	// Inject content in external documents pointed by $ref.
+	// The inject path is the same as the path in the source doc.
+	for ptr, u := range toInject {
+		// log.Println(ptr, u)
+
+		if _, err := jsonptr.Get(*rdoc, ptr); err != nil {
+			return fmt.Errorf("%s: content replaced from %s", ptr, u)
+		}
+		target, _ := jsonptr.Get(*resolver.docs[u], ptr)
+		_ = jsonptr.Set(rdoc, ptr, target)
+	}
+
+	// As some $ref pointed to external documents we have to fix them
+	if len(resolver.docs) > 1 {
+		_ = visitRefs(*rdoc, nil, func(ptr jsonptr.Pointer, ref string) (string, error) {
+			i := strings.IndexByte(ref, '#')
+			if i > 0 {
+				ref = ref[i:]
+			}
+			return ref, nil
+		})
+	}
+
+	return err
+}

refs_test.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestExpandRefs(t *testing.T) {
+	dir, err := os.Open("testdata")
+	if err != nil {
+		log.Fatal(err)
+	}
+	all, err := dir.Readdir(-1)
+	dir.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	sort.SliceStable(all, func(i, j int) bool {
+		return all[i].Name() < all[j].Name()
+	})
+
+	for _, f := range all {
+		if !f.IsDir() {
+			continue
+		}
+		name := f.Name()
+		if name[0] < '0' || name[0] > '9' {
+			continue
+		}
+		t.Run(name, func(t *testing.T) {
+			testExpandRefs(t, "testdata/"+name)
+		})
+	}
+}
+
+func testExpandRefs(t *testing.T, path string) {
+	var inputPath string
+	for _, ext := range []string{".yml", ".yaml", ".json"} {
+		p := path + "/input" + ext
+		t.Log(p)
+		_, err := os.Stat(p)
+		if err == nil {
+			inputPath = p
+			break
+		}
+		if os.IsNotExist(err) {
+			continue
+		}
+		log.Fatalf("%s: %v", p, err)
+	}
+	if inputPath == "" {
+		t.Fatal("no input file")
+	}
+
+	expected, err := loadFile(filepath.Join(filepath.FromSlash(path), "result.json"))
+	if err != nil {
+		t.Fatalf("%s/result.json: %v", path, err)
+	}
+
+	var out interface{}
+	err = processFile(inputPath, func(result interface{}) error {
+		out = result
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(out, expected) {
+		t.Errorf("output doesn't match")
+	}
+}

testdata/10-ref-ext/input.yml

@@ -0,0 +1,10 @@
+---
+swagger: "2.0"
+info:
+  $ref: ../common/info.yml#/info
+paths:
+  /:
+    get:
+      responses:
+        404:
+          description: Not found.

testdata/10-ref-ext/result.json

@@ -0,0 +1,18 @@
+{
+  "info": {
+    "title": "Test",
+    "version": "0.0.0"
+  },
+  "paths": {
+    "/": {
+      "get": {
+        "responses": {
+          "404": {
+            "description": "Not found."
+          }
+        }
+      }
+    }
+  },
+  "swagger": "2.0"
+}

testdata/40-inline/indirect.yml

@@ -0,0 +1,11 @@
+---
+swagger: "2.0"
+info:
+  $inline: indirect.yml#/info
+  version: "0.0.1"
+paths:
+  /:
+    get:
+      responses:
+        404:
+          description: Not found.

testdata/40-inline/input.yml

@@ -0,0 +1,18 @@
+{
+  "info": {
+    "title": "Test",
+    "version": "0.0.1"
+  },
+  "paths": {
+    "/": {
+      "get": {
+        "responses": {
+          "404": {
+            "description": "Not found."
+          }
+        }
+      }
+    }
+  },
+  "swagger": "2.0"
+}

testdata/40-inline/result.json

@@ -0,0 +1,11 @@
+---
+swagger: "2.0"
+info:
+  $inline: ../common/info.yml#/info
+  version: "0.0.1"
+paths:
+  /:
+    get:
+      responses:
+        404:
+          description: Not found.

testdata/41-inline-indirect/input.yml

@@ -0,0 +1,3 @@
+info:
+  title: "Test"
+  version: "0.0.0"

testdata/common/info.yml

@@ -0,0 +1,12 @@
+package main
+
+import "sort"
+
+func sortedKeys(obj map[string]interface{}) (keys []string) {
+	keys = make([]string, 0, len(obj))
+	for k := range obj {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return
+}