func (d *Document) SpecFilePath() string {
	return d.specFilePath
}
SpecFilePath returns the file path of the spec if one is defined
package loads
import (
	"bytes"
	"encoding/gob"
	"encoding/json"
	"fmt"
	"github.com/go-openapi/analysis"
	"github.com/go-openapi/spec"
	"github.com/go-openapi/swag"
)
func init() {
	gob.Register(map[string]interface{}{})
	gob.Register([]interface{}{})
}
type Document struct {
	Analyzer     *analysis.Spec
	spec         *spec.Swagger
	specFilePath string
	origSpec     *spec.Swagger
	schema       *spec.Schema
	raw          json.RawMessage
	pathLoader   *loader
}
func JSONSpec(path string, options ...LoaderOption) (*Document, error) {
	data, err := JSONDoc(path)
	if err != nil {
		return nil, err
	}
	return Analyzed(data, "", options...)
}
func Embedded(orig, flat json.RawMessage, options ...LoaderOption) (*Document, error) {
	var origSpec, flatSpec spec.Swagger
	if err := json.Unmarshal(orig, &origSpec); err != nil {
		return nil, err
	}
	if err := json.Unmarshal(flat, &flatSpec); err != nil {
		return nil, err
	}
	return &Document{
		raw:        orig,
		origSpec:   &origSpec,
		spec:       &flatSpec,
		pathLoader: loaderFromOptions(options),
	}, nil
}
func Spec(path string, options ...LoaderOption) (*Document, error) {
	ldr := loaderFromOptions(options)
	b, err := ldr.Load(path)
	if err != nil {
		return nil, err
	}
	document, err := Analyzed(b, "", options...)
	if err != nil {
		return nil, err
	}
	if document != nil {
		document.specFilePath = path
		document.pathLoader = ldr
	}
	return document, err
}
func Analyzed(data json.RawMessage, version string, options ...LoaderOption) (*Document, error) {
	if version == "" {
		version = "2.0"
	}
	if version != "2.0" {
		return nil, fmt.Errorf("spec version %q is not supported", version)
	}
	raw, err := trimData(data)  
	if err != nil {
		return nil, err
	}
	swspec := new(spec.Swagger)
	if err = json.Unmarshal(raw, swspec); err != nil {
		return nil, err
	}
	origsqspec, err := cloneSpec(swspec)
	if err != nil {
		return nil, err
	}
	d := &Document{
		Analyzer:   analysis.New(swspec),
		schema:     spec.MustLoadSwagger20Schema(),
		spec:       swspec,
		raw:        raw,
		origSpec:   origsqspec,
		pathLoader: loaderFromOptions(options),
	}
	return d, nil
}
func trimData(in json.RawMessage) (json.RawMessage, error) {
	trimmed := bytes.TrimSpace(in)
	if len(trimmed) == 0 {
		return in, nil
	}
	if trimmed[0] == '{' || trimmed[0] == '[' {
		return trimmed, nil
	}
	yml, err := swag.BytesToYAMLDoc(trimmed)
	if err != nil {
		return nil, fmt.Errorf("analyzed: %v", err)
	}
	d, err := swag.YAMLToJSON(yml)
	if err != nil {
		return nil, fmt.Errorf("analyzed: %v", err)
	}
	return d, nil
}
func (d *Document) Expanded(options ...*spec.ExpandOptions) (*Document, error) {
	swspec := new(spec.Swagger)
	if err := json.Unmarshal(d.raw, swspec); err != nil {
		return nil, err
	}
	var expandOptions *spec.ExpandOptions
	if len(options) > 0 {
		expandOptions = options[0]
	} else {
		expandOptions = &spec.ExpandOptions{
			RelativeBase: d.specFilePath,
		}
	}
	if expandOptions.PathLoader == nil {
		if d.pathLoader != nil {
			expandOptions.PathLoader = d.pathLoader.Load
		} else {
			expandOptions.PathLoader = loaders.Load
		}
	}
	if err := spec.ExpandSpec(swspec, expandOptions); err != nil {
		return nil, err
	}
	dd := &Document{
		Analyzer:     analysis.New(swspec),
		spec:         swspec,
		specFilePath: d.specFilePath,
		schema:       spec.MustLoadSwagger20Schema(),
		raw:          d.raw,
		origSpec:     d.origSpec,
	}
	return dd, nil
}
func (d *Document) BasePath() string {
	return d.spec.BasePath
}
func (d *Document) Version() string {
	return d.spec.Swagger
}
func (d *Document) Schema() *spec.Schema {
	return d.schema
}
func (d *Document) Spec() *spec.Swagger {
	return d.spec
}
func (d *Document) Host() string {
	return d.spec.Host
}
func (d *Document) Raw() json.RawMessage {
	return d.raw
}
func (d *Document) OrigSpec() *spec.Swagger {
	return d.origSpec
}
func (d *Document) ResetDefinitions() *Document {
	defs := make(map[string]spec.Schema, len(d.origSpec.Definitions))
	for k, v := range d.origSpec.Definitions {
		defs[k] = v
	}
	d.spec.Definitions = defs
	return d
}
func (d *Document) Pristine() *Document {
	dd, _ := Analyzed(d.Raw(), d.Version())
	dd.pathLoader = d.pathLoader
	return dd
}