go/hcl
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
143a545916
hcl/hclwrite/format_test.go

776 lines
8.0 KiB
Go
Raw Normal View History

Rename the ancillary packages from "zcl" to "hcl". The main "zcl" package requires a bit more care because of how many callers it has and because of its two subpackages, so we'll take care of that one separately.
2017-09-11 23:00:31 +00:00
package hclwrite
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
import (
"fmt"
"testing"
"reflect"
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
"github.com/davecgh/go-spew/spew"
Unfold the "hcl" directory up into the root The main HCL package is more visible this way, and so it's easier than having to pick it out from dozens of other package directories.
2019-09-09 23:08:19 +00:00
"github.com/hashicorp/hcl/v2/hclsyntax"
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
)
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
func TestFormat(t *testing.T) {
tests := []struct {
input string
want string
}{
{
``,
``,
},
{
`a=1`,
`a = 1`,
},
zclwrite: format shouldn't add spaces around attribute access dots
2017-06-24 16:08:49 +00:00
{
`a=b.c`,
`a = b.c`,
},
hclwrite: Format shouldn't introduce spaces before index brackets This is another heuristic because the "[" syntax is also the tuple constructor start marker, but this takes care of the common cases of indexing keywords and bracketed expressions. This fixes #29.
2018-05-23 23:56:29 +00:00
{
`a=b[c]`,
`a = b[c]`,
},
{
`a=b()[c]`,
`a = b()[c]`,
},
{
`a=["hello"][0]`,
`a = ["hello"][0]`,
},
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
{
`( a+2 )`,
`(a + 2)`,
},
{
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
`( a*2 )`,
`(a * 2)`,
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
},
{
`( a+-2 )`,
`(a + -2)`,
},
{
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
`( a*-2 )`,
`(a * -2)`,
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
},
{
`(-2+1)`,
`(-2 + 1)`,
},
{
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
`foo(1, -2,a*b, b,c)`,
`foo(1, -2, a * b, b, c)`,
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
},
hclwrite: No spaces before ... marker in argument lists or for exprs
2019-05-15 22:32:00 +00:00
{
`foo(a,b...)`,
`foo(a, b...)`,
},
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
{
`a="hello ${ name }"`,
`a = "hello ${name}"`,
},
{
`a="hello ${~ name ~}"`,
`a = "hello ${~name~}"`,
},
hclwrite: fix space being added between interpolated items closes #65 - add missing edge case for two interpolated items next to each other - add tests for both quote and heredoc cases
2019-01-16 10:33:06 +00:00
{
`a="${b}${c}${ d } ${e}"`,
`a = "${b}${c}${d} ${e}"`,
},
hclwrite: Do not add spaces before template control sequences
2019-08-09 21:00:04 +00:00
{
`"%{if true}${var.foo}%{endif}"`,
`"%{if true}${var.foo}%{endif}"`,
},
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
{
`b{}`,
`b {}`,
},
{
`
"${
hello
}"
`,
`
"${
hello
}"
`,
},
{
`
foo(
1,
- 2,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
a*b,
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
b,
c,
)
`,
`
foo(
1,
-2,
zclsyntax: permit dashes in identifiers While this does create some ambiguity with arithmetic on variables, like a-b, this is permitted by HCL and so we'll permit it for zcl too, at the expense of requiring spaces to be used around minus signs for correct interpretation.
2017-06-24 16:12:24 +00:00
a * b,
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
b,
c,
)
`,
},
hclwrite: Formatter to put spaces before colons The symmetrical spaces around colons in conditionals are important for familiarity with C-like languages, so we'll instead accept spaces around colons in our HCL2-unique "for expression" construct.
2018-12-14 23:53:02 +00:00
{
`a?b:c`,
`a ? b : c`,
},
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
{
`[ [ ] ]`,
`[[]]`,
},
hclwrite: add space between "in" keyword and expr in for expression Our normal ruleset thinks that the "in" keyword here is a variable reference and so writes it as "in[y]". Since there's never any reason for a variable to appear immediately after another variable, we can check for a preceding identifier as a heuristic to recognize whether in is probably being used as a keyword rather than as a variable. This is not exact, but the only time this should be a false positive is if there were a syntax error in the input, and we don't make any guarantees about the result in that case anyway. This fixes #52.
2018-12-14 22:19:04 +00:00
{
hclwrite: Formatter to put spaces before colons The symmetrical spaces around colons in conditionals are important for familiarity with C-like languages, so we'll instead accept spaces around colons in our HCL2-unique "for expression" construct.
2018-12-14 23:53:02 +00:00
`[for x in y : x]`,
`[for x in y : x]`,
hclwrite: add space between "in" keyword and expr in for expression Our normal ruleset thinks that the "in" keyword here is a variable reference and so writes it as "in[y]". Since there's never any reason for a variable to appear immediately after another variable, we can check for a preceding identifier as a heuristic to recognize whether in is probably being used as a keyword rather than as a variable. This is not exact, but the only time this should be a false positive is if there were a syntax error in the input, and we don't make any guarantees about the result in that case anyway. This fixes #52.
2018-12-14 22:19:04 +00:00
},
{
hclwrite: Formatter to put spaces before colons The symmetrical spaces around colons in conditionals are important for familiarity with C-like languages, so we'll instead accept spaces around colons in our HCL2-unique "for expression" construct.
2018-12-14 23:53:02 +00:00
`[for x in [y] : x]`,
`[for x in [y] : x]`,
hclwrite: add space between "in" keyword and expr in for expression Our normal ruleset thinks that the "in" keyword here is a variable reference and so writes it as "in[y]". Since there's never any reason for a variable to appear immediately after another variable, we can check for a preceding identifier as a heuristic to recognize whether in is probably being used as a keyword rather than as a variable. This is not exact, but the only time this should be a false positive is if there were a syntax error in the input, and we don't make any guarantees about the result in that case anyway. This fixes #52.
2018-12-14 22:19:04 +00:00
},
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
{
`
[
[
a
]
]
`,
`
[
[
a
]
]
`,
},
{
`
[[
a
]]
`,
`
[[
a
]]
`,
},
{
`
[[
[
a
]
]]
`,
`
[[
[
a
]
]]
`,
},
{
// degenerate case with asymmetrical brackets
`
[[
[
a
]]
]
`,
`
[[
[
a
]]
]
`,
},
{
`
b {
a = 1
}
`,
`
b {
a = 1
}
hcl/hclsyntax: Accept single-line block definitions This relaxes our previous spec to include a special form from HCL 1: foo { bar = baz } Although we normally require each argument to be on a line of its own, as a special case we allow a block to be defined with a single nested argument all on one line. Only one nested argument definition is allowed, and a nested block definition like "foo { bar {} }" is also disallowed in order to force the more-readable split of bar {} onto a line of its own. This is a pragmatic addition for broader compatibility with HCL 1-oriented input. This single-line usage is not considered idiomatic HCL 2 and may in future be undone by the formatter, though for now it is left as-is aside from the spacing around the braces. This also changes the behavior of the source code formatter to include spaces on both sides of braces. This mimicks the formatting behavior of HCL 1 for this situation, and (subjectively) reads better even for other one-line braced expressions like object constructors and object for expressions.
2018-12-14 21:45:03 +00:00
`,
},
{
`
b {a = 1}
`,
`
b { a = 1 }
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
`,
},
{
`
a = 1
bungle = 2
`,
`
a = 1
bungle = 2
`,
},
{
`
a = 1
bungle = 2
`,
`
a = 1
bungle = 2
`,
},
{
`
a = 1 # foo
bungle = 2
`,
`
a = 1 # foo
bungle = 2
`,
},
{
`
a = 1 # foo
bungle = "bonce" # baz
`,
`
a = 1 # foo
bungle = "bonce" # baz
`,
},
{
`
# here we go
a = 1 # foo
bungle = "bonce" # baz
`,
`
# here we go
a = 1 # foo
bungle = "bonce" # baz
`,
},
{
`
foo {} # here we go
a = 1 # foo
bungle = "bonce" # baz
`,
`
foo {} # here we go
a = 1 # foo
bungle = "bonce" # baz
`,
},
{
`
a = 1 # foo
bungle = "bonce" # baz
zebra = "striped" # baz
`,
`
a = 1 # foo
bungle = "bonce" # baz
zebra = "striped" # baz
`,
},
{
`
a = 1 # foo
bungle = (
"bonce"
) # baz
zebra = "striped" # baz
`,
`
a = 1 # foo
bungle = (
"bonce"
) # baz
zebra = "striped" # baz
`,
},
{
`
a="apple"# foo
bungle=(# woo parens
"bonce"
)# baz
zebra="striped"# baz
`,
`
a = "apple" # foo
bungle = ( # woo parens
"bonce"
) # baz
zebra = "striped" # baz
`,
},
{
`
𝒜 = 1 # foo
bungle = "🇬🇧" # baz
zebra = "striped" # baz
`,
`
𝒜 = 1 # foo
bungle = "🇬🇧" # baz
zebra = "striped" # baz
Add additional comment test cases Some of these fail in HCL1 fmt
2018-10-31 13:21:11 +00:00
`,
},
{
`
foo {
# ...
}
`,
`
foo {
# ...
}
`,
},
{
`
foo = {
# ...
}
`,
`
foo = {
# ...
}
`,
},
{
`
foo = [
# ...
]
`,
`
foo = [
# ...
]
`,
},
{
`
foo = [{
# ...
}]
`,
`
foo = [{
# ...
}]
`,
},
{
`
foo {
bar {
# ...
}
}
`,
`
foo {
bar {
# ...
}
}
`,
},
{
`
foo {
bar = {
# ...
}
}
`,
`
foo {
bar = {
# ...
}
}
`,
},
{
`
foo {
bar = [
# ...
]
}
`,
`
foo {
bar = [
# ...
]
}
hclwrite: Suspend indentation adjustment inside heredocs Leading whitespace is significant in heredocs, so we'll avoid making any indentation adjustments for lines between OHeredoc and CHeredoc. This fixes #31.
2018-12-14 22:46:44 +00:00
`,
},
{
`
foo {
bar = <<EOT
Foo bar baz
EOT
}
`,
`
foo {
bar = <<EOT
Foo bar baz
EOT
}
`,
},
{
`
foo {
bar = <<-EOT
Foo bar baz
EOT
}
`,
`
foo {
bar = <<-EOT
Foo bar baz
EOT
}
`,
},
{
`
foo {
bar = <<-EOT
Foo bar baz
EOT
}
`,
`
foo {
bar = <<-EOT
Foo bar baz
EOT
}
`,
},
{
`
foo {
bar = <<-EOT
blahblahblah = x
EOT
}
`,
`
foo {
bar = <<-EOT
blahblahblah = x
EOT
}
`,
},
{
`
foo {
bar = <<-EOT
${{ blahblahblah = x }}
EOT
}
`,
`
foo {
bar = <<-EOT
${ { blahblahblah = x } }
EOT
}
hclwrite: fix space being added between interpolated items closes #65 - add missing edge case for two interpolated items next to each other - add tests for both quote and heredoc cases
2019-01-16 10:33:06 +00:00
`,
},
{
`
foo {
bar = <<-EOT
${a}${b}${ c } ${d}
EOT
}
`,
`
foo {
bar = <<-EOT
${a}${b}${c} ${d}
EOT
}
hclwrite: heredoc tokens are in line.lead, not line.assign (#95)
2019-03-15 20:19:41 +00:00
`,
},
{
`
foo {
bar = <<EOT
Foo bar baz
EOT
}
baz {
default="string"
}
`,
`
foo {
bar = <<EOT
Foo bar baz
EOT
}
baz {
default = "string"
}
hclwrite: Fix improper indent calculation inside heredocs (#107)
2019-07-22 19:57:18 +00:00
`,
},
{
`
foo {
bar = <<EOT
Foo bar baz
EOT
baz = <<EOT
Foo bar baz
EOT
}
bar {
foo = "bar"
}
`,
`
foo {
bar = <<EOT
Foo bar baz
EOT
baz = <<EOT
Foo bar baz
EOT
}
bar {
foo = "bar"
}
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
`,
},
hclwrite: Fix heredocs never close during format Waiting for TokenCHeredoc never ends since scanTokens() does not produce TokenNewlines inside heredocs. Related Issue: hashicorp/terraform#21434
2019-07-25 00:18:11 +00:00
{
`
module "foo" {
foo = <<EOF
5
EOF
}
module "x" {
a = "b"
abcde = "456"
}`,
`
module "foo" {
foo = <<EOF
5
EOF
}
module "x" {
a = "b"
abcde = "456"
}`,
},
zclwrite: "format" implementation This tweaks the number of spaces before each token to create a consistent layout. It doesn't (yet?) attempt to add or remove line breaks or otherwise mess with the non-space characters in the code. The main goal here is to get things to line up. zcl syntax is simple enough that there's not much latitude for super-weird usage, and so if someone does manage to write something weird (asymmetric breaking of brackets between lines, etc) we won't try to fix it here.
2017-06-10 21:11:47 +00:00
}
for i, test := range tests {
t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
tokens := lexConfig([]byte(test.input))
format(tokens)
t.Logf("tokens %s\n", spew.Sdump(tokens))
got := string(tokens.Bytes())
if got != test.want {
t.Errorf("wrong result\ninput:\n%s\ngot:\n%s\nwant:\n%s", test.input, got, test.want)
}
})
}
}
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
func TestLinesForFormat(t *testing.T) {
tests := []struct {
tokens Tokens
want []formatLine
}{
{
Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{},
},
},
},
{
Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
},
},
{
Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
&Token{Type: hclsyntax.TokenNewline},
&Token{Type: hclsyntax.TokenNumberLit},
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
&Token{Type: hclsyntax.TokenNewline},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenNumberLit},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
},
},
{
Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
&Token{Type: hclsyntax.TokenComment, Bytes: []byte("#foo\n")},
&Token{Type: hclsyntax.TokenNumberLit},
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
comment: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenComment, Bytes: []byte("#foo\n")},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenNumberLit},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
},
},
{
Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
&Token{Type: hclsyntax.TokenEqual},
&Token{Type: hclsyntax.TokenNumberLit},
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
assign: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenEqual},
&Token{Type: hclsyntax.TokenNumberLit},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
},
},
{
Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
&Token{Type: hclsyntax.TokenEqual},
&Token{Type: hclsyntax.TokenNumberLit},
&Token{Type: hclsyntax.TokenComment, Bytes: []byte("#foo\n")},
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenIdent},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
assign: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenEqual},
&Token{Type: hclsyntax.TokenNumberLit},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
comment: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenComment, Bytes: []byte("#foo\n")},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
{
lead: Tokens{},
},
},
},
{
Tokens{
// A comment goes into a comment cell only if it is after
// some non-comment tokens, since whole-line comments must
// stay flush with the indent level.
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenComment, Bytes: []byte("#foo\n")},
&Token{Type: hclsyntax.TokenEOF},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
[]formatLine{
{
lead: Tokens{
Move the zcl package and its two parsing subpackages to "hcl" names This is a super-invasive update since the "zcl" package in particular is referenced all over. There are probably still a few zcl references hanging around in comments, etc but this takes care of most of it.
2017-09-11 23:40:37 +00:00
&Token{Type: hclsyntax.TokenComment, Bytes: []byte("#foo\n")},
zclwrite: line/cell splitting for "format" Our approach here is to split the input into lines and then to split each line into up to three cells which, when present, should have their leftmost characters aligned (eventually) by the formatter.
2017-06-10 14:47:15 +00:00
},
},
{
lead: Tokens{},
},
},
},
}
for i, test := range tests {
t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
got := linesForFormat(test.tokens)
if !reflect.DeepEqual(got, test.want) {
t.Errorf("wrong result\ngot: %#v\nwant: %#v", got, test.want)
}
})
}
}
Reference in New Issue Copy Permalink