Add imports

d2ast/d2ast.go

@@ -63,6 +63,7 @@ var _ Node = &DoubleQuotedString{}
 var _ Node = &SingleQuotedString{}
 var _ Node = &BlockString{}
 var _ Node = &Substitution{}
+var _ Node = &Import{}
 
 var _ Node = &Array{}
 var _ Node = &Map{}
@@ -277,6 +278,7 @@ var _ MapNode = &Comment{}
 var _ MapNode = &BlockComment{}
 var _ MapNode = &Key{}
 var _ MapNode = &Substitution{}
+var _ MapNode = &Import{}
 
 // ArrayNode is implemented by nodes that may be children of Arrays.
 type ArrayNode interface {
@@ -288,6 +290,7 @@ type ArrayNode interface {
 var _ ArrayNode = &Comment{}
 var _ ArrayNode = &BlockComment{}
 var _ ArrayNode = &Substitution{}
+var _ ArrayNode = &Import{}
 
 // Value is implemented by nodes that may be values of a key.
 type Value interface {
@@ -334,6 +337,7 @@ func (s *DoubleQuotedString) node() {}
 func (s *SingleQuotedString) node() {}
 func (s *BlockString) node()        {}
 func (s *Substitution) node()       {}
+func (i *Import) node()             {}
 func (a *Array) node()              {}
 func (m *Map) node()                {}
 func (k *Key) node()                {}
@@ -351,6 +355,7 @@ func (s *DoubleQuotedString) Type() string { return "double quoted string" }
 func (s *SingleQuotedString) Type() string { return "single quoted string" }
 func (s *BlockString) Type() string        { return s.Tag + " block string" }
 func (s *Substitution) Type() string       { return "substitution" }
+func (i *Import) Type() string             { return "import" }
 func (a *Array) Type() string              { return "array" }
 func (m *Map) Type() string                { return "map" }
 func (k *Key) Type() string                { return "map key" }
@@ -368,6 +373,7 @@ func (s *DoubleQuotedString) GetRange() Range { return s.Range }
 func (s *SingleQuotedString) GetRange() Range { return s.Range }
 func (s *BlockString) GetRange() Range        { return s.Range }
 func (s *Substitution) GetRange() Range       { return s.Range }
+func (i *Import) GetRange() Range             { return i.Range }
 func (a *Array) GetRange() Range              { return a.Range }
 func (m *Map) GetRange() Range                { return m.Range }
 func (k *Key) GetRange() Range                { return k.Range }
@@ -379,6 +385,7 @@ func (c *Comment) mapNode()      {}
 func (c *BlockComment) mapNode() {}
 func (k *Key) mapNode()          {}
 func (s *Substitution) mapNode() {}
+func (i *Import) mapNode()       {}
 
 func (c *Comment) arrayNode()            {}
 func (c *BlockComment) arrayNode()       {}
@@ -390,6 +397,7 @@ func (s *DoubleQuotedString) arrayNode() {}
 func (s *SingleQuotedString) arrayNode() {}
 func (s *BlockString) arrayNode()        {}
 func (s *Substitution) arrayNode()       {}
+func (i *Import) arrayNode()             {}
 func (a *Array) arrayNode()              {}
 func (m *Map) arrayNode()                {}
 
@@ -402,6 +410,7 @@ func (s *SingleQuotedString) value() {}
 func (s *BlockString) value()        {}
 func (a *Array) value()              {}
 func (m *Map) value()                {}
+func (i *Import) value()             {}
 
 func (n *Null) scalar()               {}
 func (b *Boolean) scalar()            {}
@@ -722,11 +731,19 @@ type Substitution struct {
 	Path   []*StringBox `json:"path"`
 }
 
+type Import struct {
+	Range Range `json:"range"`
+
+	Spread bool         `json:"spread"`
+	Path   []*StringBox `json:"path"`
+}
+
 // MapNodeBox is used to box MapNode for JSON persistence.
 type MapNodeBox struct {
 	Comment      *Comment      `json:"comment,omitempty"`
 	BlockComment *BlockComment `json:"block_comment,omitempty"`
 	Substitution *Substitution `json:"substitution,omitempty"`
+	Import       *Import       `json:"import,omitempty"`
 	MapKey       *Key          `json:"map_key,omitempty"`
 }
 
@@ -739,6 +756,8 @@ func MakeMapNodeBox(n MapNode) MapNodeBox {
 		box.BlockComment = n
 	case *Substitution:
 		box.Substitution = n
+	case *Import:
+		box.Import = n
 	case *Key:
 		box.MapKey = n
 	}
@@ -753,6 +772,8 @@ func (mb MapNodeBox) Unbox() MapNode {
 		return mb.BlockComment
 	case mb.Substitution != nil:
 		return mb.Substitution
+	case mb.Import != nil:
+		return mb.Import
 	case mb.MapKey != nil:
 		return mb.MapKey
 	default:
@@ -765,6 +786,7 @@ type ArrayNodeBox struct {
 	Comment            *Comment            `json:"comment,omitempty"`
 	BlockComment       *BlockComment       `json:"block_comment,omitempty"`
 	Substitution       *Substitution       `json:"substitution,omitempty"`
+	Import             *Import             `json:"import,omitempty"`
 	Null               *Null               `json:"null,omitempty"`
 	Boolean            *Boolean            `json:"boolean,omitempty"`
 	Number             *Number             `json:"number,omitempty"`
@@ -785,6 +807,8 @@ func MakeArrayNodeBox(an ArrayNode) ArrayNodeBox {
 		ab.BlockComment = an
 	case *Substitution:
 		ab.Substitution = an
+	case *Import:
+		ab.Import = an
 	case *Null:
 		ab.Null = an
 	case *Boolean:
@@ -815,6 +839,8 @@ func (ab ArrayNodeBox) Unbox() ArrayNode {
 		return ab.BlockComment
 	case ab.Substitution != nil:
 		return ab.Substitution
+	case ab.Import != nil:
+		return ab.Import
 	case ab.Null != nil:
 		return ab.Null
 	case ab.Boolean != nil:
@@ -849,6 +875,7 @@ type ValueBox struct {
 	BlockString        *BlockString        `json:"block_string,omitempty"`
 	Array              *Array              `json:"array,omitempty"`
 	Map                *Map                `json:"map,omitempty"`
+	Import             *Import             `json:"import,omitempty"`
 }
 
 func (vb ValueBox) Unbox() Value {
@@ -871,6 +898,8 @@ func (vb ValueBox) Unbox() Value {
 		return vb.Array
 	case vb.Map != nil:
 		return vb.Map
+	case vb.Import != nil:
+		return vb.Import
 	default:
 		return nil
 	}
@@ -897,6 +926,8 @@ func MakeValueBox(v Value) ValueBox {
 		vb.Array = v
 	case *Map:
 		vb.Map = v
+	case *Import:
+		vb.Import = v
 	}
 	return vb
 }
@@ -990,8 +1021,8 @@ type InterpolationBox struct {
 // & is only special if it begins a key.
 // - is only special if followed by another - in a key.
 // ' " and | are only special if they begin an unquoted key or value.
-var UnquotedKeySpecials = string([]rune{'#', ';', '\n', '\\', '{', '}', '[', ']', '\'', '"', '|', ':', '.', '-', '<', '>', '*', '&', '(', ')'})
-var UnquotedValueSpecials = string([]rune{'#', ';', '\n', '\\', '{', '}', '[', ']', '\'', '"', '|', '$'})
+var UnquotedKeySpecials = string([]rune{'#', ';', '\n', '\\', '{', '}', '[', ']', '\'', '"', '|', ':', '.', '-', '<', '>', '*', '&', '(', ')', '@'})
+var UnquotedValueSpecials = string([]rune{'#', ';', '\n', '\\', '{', '}', '[', ']', '\'', '"', '|', '$', '@'})
 
 // RawString returns s in a AST String node that can format s in the most aesthetically
 // pleasing way.
@@ -1040,8 +1071,26 @@ func RawString(s string, inKey bool) String {
 	return FlatUnquotedString(s)
 }
 
+func RawStringBox(s string, inKey bool) *StringBox {
+	return MakeValueBox(RawString(s, inKey)).StringBox()
+}
+
 func hasSurroundingWhitespace(s string) bool {
 	r, _ := utf8.DecodeRuneInString(s)
 	r2, _ := utf8.DecodeLastRuneInString(s)
 	return unicode.IsSpace(r) || unicode.IsSpace(r2)
 }
+
+func (s *Substitution) IDA() (ida []string) {
+	for _, el := range s.Path {
+		ida = append(ida, el.Unbox().ScalarString())
+	}
+	return ida
+}
+
+func (i *Import) IDA() (ida []string) {
+	for _, el := range i.Path[1:] {
+		ida = append(ida, el.Unbox().ScalarString())
+	}
+	return ida
+}

d2cli/main.go

@@ -322,6 +322,7 @@ func compile(ctx context.Context, ms *xmain.State, plugin d2plugin.Plugin, rende
 		Ruler:      ruler,
 		ThemeID:    renderOpts.ThemeID,
 		FontFamily: fontFamily,
+		InputPath:  inputPath,
 	}
 	if renderOpts.Sketch {
 		opts.FontFamily = go2.Pointer(d2fonts.HandDrawn)

d2compiler/compile.go

@@ -4,7 +4,9 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"io/fs"
 	"net/url"
+	"os"
 	"strconv"
 	"strings"
 
@@ -21,21 +23,30 @@ import (
 
 type CompileOptions struct {
 	UTF16 bool
+	// FS is the file system used for resolving imports in the d2 text.
+	// It should correspond to the root path.
+	FS fs.FS
 }
 
-func Compile(path string, r io.RuneReader, opts *CompileOptions) (*d2graph.Graph, error) {
+func Compile(p string, r io.RuneReader, opts *CompileOptions) (*d2graph.Graph, error) {
 	if opts == nil {
 		opts = &CompileOptions{}
 	}
+	if opts.FS == nil {
+		opts.FS = os.DirFS("/")
+	}
 
-	ast, err := d2parser.Parse(path, r, &d2parser.ParseOptions{
+	ast, err := d2parser.Parse(p, r, &d2parser.ParseOptions{
 		UTF16: opts.UTF16,
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	ir, err := d2ir.Compile(ast)
+	ir, err := d2ir.Compile(ast, &d2ir.CompileOptions{
+		UTF16: opts.UTF16,
+		FS:    opts.FS,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -50,7 +61,9 @@ func Compile(path string, r io.RuneReader, opts *CompileOptions) (*d2graph.Graph
 }
 
 func compileIR(ast *d2ast.Map, m *d2ir.Map) (*d2graph.Graph, error) {
-	c := &compiler{}
+	c := &compiler{
+		err: &d2parser.ParseError{},
+	}
 
 	g := d2graph.NewGraph()
 	g.AST = ast
@@ -116,7 +129,7 @@ func (c *compiler) compileBoardsField(g *d2graph.Graph, ir *d2ir.Map, fieldName
 }
 
 type compiler struct {
-	err d2parser.ParseError
+	err *d2parser.ParseError
 }
 
 func (c *compiler) errorf(n d2ast.Node, f string, v ...interface{}) {

d2format/format.go

@@ -62,6 +62,8 @@ func (p *printer) node(n d2ast.Node) {
 		p.blockString(n)
 	case *d2ast.Substitution:
 		p.substitution(n)
+	case *d2ast.Import:
+		p._import(n)
 	case *d2ast.Array:
 		p.array(n)
 	case *d2ast.Map:
@@ -203,6 +205,14 @@ func (p *printer) substitution(s *d2ast.Substitution) {
 	p.sb.WriteByte('}')
 }
 
+func (p *printer) _import(i *d2ast.Import) {
+	if i.Spread {
+		p.sb.WriteString("...")
+	}
+	p.sb.WriteString("@")
+	p.path(i.Path)
+}
+
 func (p *printer) array(a *d2ast.Array) {
 	p.sb.WriteByte('[')
 	if !a.Range.OneLine() {

d2format/format_test.go

@@ -617,6 +617,22 @@ y
 x <= y
 `,
 			exp: `x <- = y
+`,
+		},
+		{
+			name: "import/1",
+			in: `
+x: @file.d2
+`,
+			exp: `x: @file
+`,
+		},
+		{
+			name: "import/2",
+			in: `
+x: @file."d2"
+`,
+			exp: `x: @file."d2"
 `,
 		},
 	}