pulumi/pkg/codegen/docs/gen_test.go

647 lines
18 KiB
Go
Raw Permalink Normal View History

// Copyright 2016-2020, Pulumi Corporation.
//
// 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.
// Pulling out some of the repeated strings tokens into constants would harm readability, so we just ignore the
// goconst linter's warning.
//
sdk/go: Remove 'nolint' directives from package docs Go treats comments that match the following regex as directives. //[a-z0-9]+:[a-z0-9] Comments that are directives don't show in an entity's documentation. https://github.com/golang/go/commit/5a550b695117f07a4f2454039a4871250cd3ed09#diff-f56160fd9fcea272966a8a1d692ad9f49206fdd8dbcbfe384865a98cd9bc2749R165 Our code has `//nolint` directives that now show in the API Reference. This is because these directives are in one of the following forms, which don't get this special treatment. // nolint:foo //nolint: foo This change fixes all such directives found by the regex: `// nolint|//nolint: `. See bottom of commit for command used for the fix. Verification: Here's the output of `go doc` on some entities before and after this change. Before ``` % go doc github.com/pulumi/pulumi/sdk/v3/go/pulumi | head -n8 package pulumi // import "github.com/pulumi/pulumi/sdk/v3/go/pulumi" nolint: lll, interfacer nolint: lll, interfacer const EnvOrganization = "PULUMI_ORGANIZATION" ... var ErrPlugins = errors.New("pulumi: plugins requested") ``` After ``` % go doc github.com/pulumi/pulumi/sdk/v3/go/pulumi | head -n8 package pulumi // import "github.com/pulumi/pulumi/sdk/v3/go/pulumi" const EnvOrganization = "PULUMI_ORGANIZATION" ... var ErrPlugins = errors.New("pulumi: plugins requested") func BoolRef(v bool) *bool func Float64Ref(v float64) *float64 func IntRef(v int) *int func IsSecret(o Output) bool ``` Before ``` % go doc github.com/pulumi/pulumi/sdk/v3/go/pulumi URN_ package pulumi // import "github.com/pulumi/pulumi/sdk/v3/go/pulumi" func URN_(o string) ResourceOption URN_ is an optional URN of a previously-registered resource of this type to read from the engine. nolint: revive ``` After: ``` % go doc github.com/pulumi/pulumi/sdk/v3/go/pulumi URN_ package pulumi // import "github.com/pulumi/pulumi/sdk/v3/go/pulumi" func URN_(o string) ResourceOption URN_ is an optional URN of a previously-registered resource of this type to read from the engine. ``` Note that golangci-lint offers a 'nolintlint' linter that finds such miuses of nolint, but it also finds other issues so I've deferred that to a follow up PR. Resolves #11785 Related: https://github.com/golangci/golangci-lint/issues/892 [git-generate] FILES=$(mktemp) rg -l '// nolint|//nolint: ' | tee "$FILES" | xargs perl -p -i -e ' s|// nolint|//nolint|g; s|//nolint: |//nolint:|g; ' rg '.go$' < "$FILES" | xargs gofmt -w -s
2023-01-06 00:07:45 +00:00
//nolint:lll, goconst
package docs
import (
"fmt"
"testing"
"github.com/pulumi/pulumi/pkg/v3/codegen/schema"
"github.com/pulumi/pulumi/pkg/v3/codegen/testing/test"
"github.com/stretchr/testify/assert"
)
const (
unitTestTool = "Pulumi Resource Docs Unit Test"
providerPackage = "prov"
codeFence = "```"
)
all: Reformat with gofumpt Per team discussion, switching to gofumpt. [gofumpt][1] is an alternative, stricter alternative to gofmt. It addresses other stylistic concerns that gofmt doesn't yet cover. [1]: https://github.com/mvdan/gofumpt See the full list of [Added rules][2], but it includes: - Dropping empty lines around function bodies - Dropping unnecessary variable grouping when there's only one variable - Ensuring an empty line between multi-line functions - simplification (`-s` in gofmt) is always enabled - Ensuring multi-line function signatures end with `) {` on a separate line. [2]: https://github.com/mvdan/gofumpt#Added-rules gofumpt is stricter, but there's no lock-in. All gofumpt output is valid gofmt output, so if we decide we don't like it, it's easy to switch back without any code changes. gofumpt support is built into the tooling we use for development so this won't change development workflows. - golangci-lint includes a gofumpt check (enabled in this PR) - gopls, the LSP for Go, includes a gofumpt option (see [installation instrutions][3]) [3]: https://github.com/mvdan/gofumpt#installation This change was generated by running: ```bash gofumpt -w $(rg --files -g '*.go' | rg -v testdata | rg -v compilation_error) ``` The following files were manually tweaked afterwards: - pkg/cmd/pulumi/stack_change_secrets_provider.go: one of the lines overflowed and had comments in an inconvenient place - pkg/cmd/pulumi/destroy.go: `var x T = y` where `T` wasn't necessary - pkg/cmd/pulumi/policy_new.go: long line because of error message - pkg/backend/snapshot_test.go: long line trying to assign three variables in the same assignment I have included mention of gofumpt in the CONTRIBUTING.md.
2023-03-03 16:36:39 +00:00
var simpleProperties = map[string]schema.PropertySpec{
"stringProp": {
Description: "A string prop.",
TypeSpec: schema.TypeSpec{
Type: "string",
},
all: Reformat with gofumpt Per team discussion, switching to gofumpt. [gofumpt][1] is an alternative, stricter alternative to gofmt. It addresses other stylistic concerns that gofmt doesn't yet cover. [1]: https://github.com/mvdan/gofumpt See the full list of [Added rules][2], but it includes: - Dropping empty lines around function bodies - Dropping unnecessary variable grouping when there's only one variable - Ensuring an empty line between multi-line functions - simplification (`-s` in gofmt) is always enabled - Ensuring multi-line function signatures end with `) {` on a separate line. [2]: https://github.com/mvdan/gofumpt#Added-rules gofumpt is stricter, but there's no lock-in. All gofumpt output is valid gofmt output, so if we decide we don't like it, it's easy to switch back without any code changes. gofumpt support is built into the tooling we use for development so this won't change development workflows. - golangci-lint includes a gofumpt check (enabled in this PR) - gopls, the LSP for Go, includes a gofumpt option (see [installation instrutions][3]) [3]: https://github.com/mvdan/gofumpt#installation This change was generated by running: ```bash gofumpt -w $(rg --files -g '*.go' | rg -v testdata | rg -v compilation_error) ``` The following files were manually tweaked afterwards: - pkg/cmd/pulumi/stack_change_secrets_provider.go: one of the lines overflowed and had comments in an inconvenient place - pkg/cmd/pulumi/destroy.go: `var x T = y` where `T` wasn't necessary - pkg/cmd/pulumi/policy_new.go: long line because of error message - pkg/backend/snapshot_test.go: long line trying to assign three variables in the same assignment I have included mention of gofumpt in the CONTRIBUTING.md.
2023-03-03 16:36:39 +00:00
},
"boolProp": {
Description: "A bool prop.",
TypeSpec: schema.TypeSpec{
Type: "boolean",
},
all: Reformat with gofumpt Per team discussion, switching to gofumpt. [gofumpt][1] is an alternative, stricter alternative to gofmt. It addresses other stylistic concerns that gofmt doesn't yet cover. [1]: https://github.com/mvdan/gofumpt See the full list of [Added rules][2], but it includes: - Dropping empty lines around function bodies - Dropping unnecessary variable grouping when there's only one variable - Ensuring an empty line between multi-line functions - simplification (`-s` in gofmt) is always enabled - Ensuring multi-line function signatures end with `) {` on a separate line. [2]: https://github.com/mvdan/gofumpt#Added-rules gofumpt is stricter, but there's no lock-in. All gofumpt output is valid gofmt output, so if we decide we don't like it, it's easy to switch back without any code changes. gofumpt support is built into the tooling we use for development so this won't change development workflows. - golangci-lint includes a gofumpt check (enabled in this PR) - gopls, the LSP for Go, includes a gofumpt option (see [installation instrutions][3]) [3]: https://github.com/mvdan/gofumpt#installation This change was generated by running: ```bash gofumpt -w $(rg --files -g '*.go' | rg -v testdata | rg -v compilation_error) ``` The following files were manually tweaked afterwards: - pkg/cmd/pulumi/stack_change_secrets_provider.go: one of the lines overflowed and had comments in an inconvenient place - pkg/cmd/pulumi/destroy.go: `var x T = y` where `T` wasn't necessary - pkg/cmd/pulumi/policy_new.go: long line because of error message - pkg/backend/snapshot_test.go: long line trying to assign three variables in the same assignment I have included mention of gofumpt in the CONTRIBUTING.md.
2023-03-03 16:36:39 +00:00
},
}
// newTestPackageSpec returns a new fake package spec for a Provider used for testing.
func newTestPackageSpec() schema.PackageSpec {
pythonMapCase := map[string]schema.RawMessage{
"python": schema.RawMessage(`{"mapCase":false}`),
}
return schema.PackageSpec{
Name: providerPackage,
Version: "0.0.1",
Description: "A fake provider package used for testing.",
Meta: &schema.MetadataSpec{
ModuleFormat: "(.*)(?:/[^/]*)",
},
Types: map[string]schema.ComplexTypeSpec{
// Package-level types.
"prov:/getPackageResourceOptions:getPackageResourceOptions": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: "Options object for the package-level function getPackageResource.",
Type: "object",
Properties: simpleProperties,
},
},
// Module-level types.
"prov:module/getModuleResourceOptions:getModuleResourceOptions": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: "Options object for the module-level function getModuleResource.",
Type: "object",
Properties: simpleProperties,
},
},
"prov:module/ResourceOptions:ResourceOptions": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: "The resource options object.",
Type: "object",
Properties: map[string]schema.PropertySpec{
"stringProp": {
Description: "A string prop.",
Language: pythonMapCase,
TypeSpec: schema.TypeSpec{
Type: "string",
},
},
"boolProp": {
Description: "A bool prop.",
Language: pythonMapCase,
TypeSpec: schema.TypeSpec{
Type: "boolean",
},
},
"recursiveType": {
Description: "I am a recursive type.",
Language: pythonMapCase,
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions:ResourceOptions",
},
},
},
},
},
"prov:module/ResourceOptions2:ResourceOptions2": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: "The resource options object.",
Type: "object",
Properties: map[string]schema.PropertySpec{
"uniqueProp": {
Description: "This is a property unique to this type.",
Language: pythonMapCase,
TypeSpec: schema.TypeSpec{
Type: "number",
},
},
},
},
},
},
Provider: schema.ResourceSpec{
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: fmt.Sprintf("The provider type for the %s package.", providerPackage),
Type: "object",
},
InputProperties: map[string]schema.PropertySpec{
"stringProp": {
Description: "A stringProp for the provider resource.",
TypeSpec: schema.TypeSpec{
Type: "string",
},
},
},
},
Resources: map[string]schema.ResourceSpec{
"prov:module2/resource2:Resource2": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: `This is a module-level resource called Resource.
{{% examples %}}
## Example Usage
{{% example %}}
### Basic Example
` + codeFence + `typescript
// Some TypeScript code.
` + codeFence + `
` + codeFence + `python
# Some Python code.
` + codeFence + `
{{% /example %}}
{{% example %}}
### Custom Sub-Domain Example
` + codeFence + `typescript
// Some typescript code
` + codeFence + `
` + codeFence + `python
# Some Python code.
` + codeFence + `
{{% /example %}}
{{% /examples %}}
## Import
The import docs would be here
` + codeFence + `sh
$ pulumi import prov:module/resource:Resource test test
` + codeFence + `
`,
},
InputProperties: map[string]schema.PropertySpec{
"integerProp": {
Description: "This is integerProp's description.",
TypeSpec: schema.TypeSpec{
Type: "integer",
},
},
"stringProp": {
Description: "This is stringProp's description.",
TypeSpec: schema.TypeSpec{
Type: "string",
},
},
"boolProp": {
Description: "A bool prop.",
TypeSpec: schema.TypeSpec{
Type: "boolean",
},
},
"optionsProp": {
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions:ResourceOptions",
},
},
"options2Prop": {
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions2:ResourceOptions2",
},
},
"recursiveType": {
Description: "I am a recursive type.",
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions:ResourceOptions",
},
},
},
},
"prov:module/resource:Resource": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: `This is a module-level resource called Resource.
{{% examples %}}
## Example Usage
{{% example %}}
### Basic Example
` + codeFence + `typescript
// Some TypeScript code.
` + codeFence + `
` + codeFence + `python
# Some Python code.
` + codeFence + `
{{% /example %}}
{{% example %}}
### Custom Sub-Domain Example
` + codeFence + `typescript
// Some typescript code
` + codeFence + `
` + codeFence + `python
# Some Python code.
` + codeFence + `
{{% /example %}}
{{% /examples %}}
## Import
The import docs would be here
` + codeFence + `sh
$ pulumi import prov:module/resource:Resource test test
` + codeFence + `
`,
},
InputProperties: map[string]schema.PropertySpec{
"integerProp": {
Description: "This is integerProp's description.",
TypeSpec: schema.TypeSpec{
Type: "integer",
},
},
"stringProp": {
Description: "This is stringProp's description.",
TypeSpec: schema.TypeSpec{
Type: "string",
},
},
"boolProp": {
Description: "A bool prop.",
TypeSpec: schema.TypeSpec{
Type: "boolean",
},
},
"optionsProp": {
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions:ResourceOptions",
},
},
"options2Prop": {
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions2:ResourceOptions2",
},
},
"recursiveType": {
Description: "I am a recursive type.",
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/ResourceOptions:ResourceOptions",
},
},
},
},
"prov:/packageLevelResource:PackageLevelResource": {
ObjectTypeSpec: schema.ObjectTypeSpec{
Description: "This is a package-level resource.",
},
InputProperties: map[string]schema.PropertySpec{
"prop": {
Description: "An input property.",
TypeSpec: schema.TypeSpec{
Type: "string",
},
},
},
},
},
Functions: map[string]schema.FunctionSpec{
// Package-level Functions.
"prov:/getPackageResource:getPackageResource": {
Description: "A package-level function.",
Inputs: &schema.ObjectTypeSpec{
Description: "Inputs for getPackageResource.",
Type: "object",
Properties: map[string]schema.PropertySpec{
"options": {
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:/getPackageResourceOptions:getPackageResourceOptions",
},
},
},
},
Outputs: &schema.ObjectTypeSpec{
Description: "Outputs for getPackageResource.",
Properties: simpleProperties,
Type: "object",
},
},
// Module-level Functions.
"prov:module/getModuleResource:getModuleResource": {
Description: "A module-level function.",
Inputs: &schema.ObjectTypeSpec{
Description: "Inputs for getModuleResource.",
Type: "object",
Properties: map[string]schema.PropertySpec{
"options": {
TypeSpec: schema.TypeSpec{
Ref: "#/types/prov:module/getModuleResource:getModuleResource",
},
},
},
},
Outputs: &schema.ObjectTypeSpec{
Description: "Outputs for getModuleResource.",
Properties: simpleProperties,
Type: "object",
},
},
},
}
}
func getResourceFromModule(resource string, mod *modContext) *schema.Resource {
for _, r := range mod.resources {
if resourceName(r) != resource {
continue
}
return r
}
return nil
}
func getFunctionFromModule(function string, mod *modContext) *schema.Function {
for _, f := range mod.functions {
if tokenToName(f.Token) != function {
continue
}
return f
}
return nil
}
func TestFunctionHeaders(t *testing.T) {
t.Parallel()
dctx := newDocGenContext()
testPackageSpec := newTestPackageSpec()
schemaPkg, err := schema.ImportSpec(testPackageSpec, nil)
assert.NoError(t, err, "importing spec")
tests := []struct {
ExpectedTitleTag string
FunctionName string
ModuleName string
ExpectedMetaDesc string
}{
{
FunctionName: "getPackageResource",
// Empty string indicates the package-level root module.
ModuleName: "",
ExpectedTitleTag: "prov.getPackageResource",
ExpectedMetaDesc: "Documentation for the prov.getPackageResource function with examples, input properties, output properties, and supporting types.",
},
{
FunctionName: "getModuleResource",
ModuleName: "module",
ExpectedTitleTag: "prov.module.getModuleResource",
ExpectedMetaDesc: "Documentation for the prov.module.getModuleResource function with examples, input properties, output properties, and supporting types.",
},
}
modules := dctx.generateModulesFromSchemaPackage(unitTestTool, schemaPkg)
for _, test := range tests {
test := test
t.Run(test.FunctionName, func(t *testing.T) {
t.Parallel()
mod, ok := modules[test.ModuleName]
if !ok {
t.Fatalf("could not find the module %s in modules map", test.ModuleName)
}
f := getFunctionFromModule(test.FunctionName, mod)
if f == nil {
t.Fatalf("could not find %s in modules", test.FunctionName)
}
h := mod.genFunctionHeader(f)
assert.Equal(t, test.ExpectedTitleTag, h.TitleTag)
assert.Equal(t, test.ExpectedMetaDesc, h.MetaDesc)
})
}
}
func TestResourceDocHeader(t *testing.T) {
t.Parallel()
dctx := newDocGenContext()
testPackageSpec := newTestPackageSpec()
schemaPkg, err := schema.ImportSpec(testPackageSpec, nil)
assert.NoError(t, err, "importing spec")
tests := []struct {
Name string
ExpectedTitleTag string
ResourceName string
ModuleName string
ExpectedMetaDesc string
}{
{
Name: "PackageLevelResourceHeader",
ResourceName: "PackageLevelResource",
// Empty string indicates the package-level root module.
ModuleName: "",
ExpectedTitleTag: "prov.PackageLevelResource",
ExpectedMetaDesc: "Documentation for the prov.PackageLevelResource resource with examples, input properties, output properties, lookup functions, and supporting types.",
},
{
Name: "ModuleLevelResourceHeader",
ResourceName: "Resource",
ModuleName: "module",
ExpectedTitleTag: "prov.module.Resource",
ExpectedMetaDesc: "Documentation for the prov.module.Resource resource with examples, input properties, output properties, lookup functions, and supporting types.",
},
}
modules := dctx.generateModulesFromSchemaPackage(unitTestTool, schemaPkg)
for _, test := range tests {
test := test
t.Run(test.Name, func(t *testing.T) {
t.Parallel()
mod, ok := modules[test.ModuleName]
if !ok {
t.Fatalf("could not find the module %s in modules map", test.ModuleName)
}
r := getResourceFromModule(test.ResourceName, mod)
if r == nil {
t.Fatalf("could not find %s in modules", test.ResourceName)
}
h := mod.genResourceHeader(r)
assert.Equal(t, test.ExpectedTitleTag, h.TitleTag)
assert.Equal(t, test.ExpectedMetaDesc, h.MetaDesc)
})
}
}
func TestExamplesProcessing(t *testing.T) {
t.Parallel()
testPackageSpec := newTestPackageSpec()
dctx := newDocGenContext()
description := testPackageSpec.Resources["prov:module/resource:Resource"].Description
docInfo := dctx.decomposeDocstring(description)
examplesSection := docInfo.examples
importSection := docInfo.importDetails
assert.NotEmpty(t, importSection)
// The resource under test has two examples and both have TS and Python examples.
assert.Equal(t, 2, len(examplesSection))
assert.Equal(t, "### Basic Example", examplesSection[0].Title)
assert.Equal(t, "### Custom Sub-Domain Example", examplesSection[1].Title)
expectedLangSnippets := []string{"typescript", "python"}
otherLangSnippets := []string{"csharp", "go"}
for _, e := range examplesSection {
for _, lang := range expectedLangSnippets {
_, ok := e.Snippets[lang]
assert.True(t, ok, "Could not find %s snippet", lang)
}
for _, lang := range otherLangSnippets {
snippet, ok := e.Snippets[lang]
assert.True(t, ok, "Expected to find default placeholders for other languages")
assert.Contains(t, "Coming soon!", snippet)
}
}
}
func generatePackage(tool string, pkg *schema.Package, extraFiles map[string][]byte) (map[string][]byte, error) {
dctx := newDocGenContext()
dctx.initialize(tool, pkg)
return dctx.generatePackage(tool, pkg)
}
func TestGeneratePackage(t *testing.T) {
t.Parallel()
test.TestSDKCodegen(t, &test.SDKCodegenOptions{
Language: "docs",
GenPackage: generatePackage,
TestCases: test.PulumiPulumiSDKTests,
})
}
2022-10-04 01:06:38 +00:00
func TestDecomposeDocstring(t *testing.T) {
2022-10-04 01:07:48 +00:00
t.Parallel()
2022-10-04 01:06:38 +00:00
awsVpcDocs := "Provides a VPC resource.\n" +
"\n" +
"{{% examples %}}\n" +
"## Example Usage\n" +
"{{% example %}}\n" +
"\n" +
"Basic usage:\n" +
"\n" +
"```typescript\n" +
"Basic usage: typescript\n" +
"```\n" +
"```python\n" +
"Basic usage: python\n" +
"```\n" +
"```csharp\n" +
"Basic usage: csharp\n" +
"```\n" +
"```go\n" +
"Basic usage: go\n" +
"```\n" +
"```java\n" +
"Basic usage: java\n" +
"```\n" +
"```yaml\n" +
"Basic usage: yaml\n" +
"```\n" +
"\n" +
"Basic usage with tags:\n" +
"\n" +
"```typescript\n" +
"Basic usage with tags: typescript\n" +
"```\n" +
"```python\n" +
"Basic usage with tags: python\n" +
"```\n" +
"```csharp\n" +
"Basic usage with tags: csharp\n" +
"```\n" +
"```go\n" +
"Basic usage with tags: go\n" +
"```\n" +
"```java\n" +
"Basic usage with tags: java\n" +
"```\n" +
"```yaml\n" +
"Basic usage with tags: yaml\n" +
"```\n" +
"\n" +
"VPC with CIDR from AWS IPAM:\n" +
"\n" +
"```typescript\n" +
"VPC with CIDR from AWS IPAM: typescript\n" +
"```\n" +
"```python\n" +
"VPC with CIDR from AWS IPAM: python\n" +
"```\n" +
"```csharp\n" +
"VPC with CIDR from AWS IPAM: csharp\n" +
"```\n" +
"```java\n" +
"VPC with CIDR from AWS IPAM: java\n" +
"```\n" +
"```yaml\n" +
"VPC with CIDR from AWS IPAM: yaml\n" +
"```\n" +
"{{% /example %}}\n" +
"{{% /examples %}}\n" +
"\n" +
"## Import\n" +
"\n" +
"VPCs can be imported using the `vpc id`, e.g.,\n" +
"\n" +
"```sh\n" +
" $ pulumi import aws:ec2/vpc:Vpc test_vpc vpc-a01106c2\n" +
"```\n" +
"\n" +
" "
dctx := newDocGenContext()
info := dctx.decomposeDocstring(awsVpcDocs)
assert.Equal(t, docInfo{
description: "Provides a VPC resource.\n",
examples: []exampleSection{
{
Title: "Basic usage",
Snippets: map[string]string{
"csharp": "```csharp\nBasic usage: csharp\n```\n",
"go": "```go\nBasic usage: go\n```\n",
"java": "```java\nBasic usage: java\n```\n",
"python": "```python\nBasic usage: python\n```\n",
"typescript": "\n```typescript\nBasic usage: typescript\n```\n",
"yaml": "```yaml\nBasic usage: yaml\n```\n",
},
},
{
Title: "Basic usage with tags",
Snippets: map[string]string{
"csharp": "```csharp\nBasic usage with tags: csharp\n```\n",
"go": "```go\nBasic usage with tags: go\n```\n",
"java": "```java\nBasic usage with tags: java\n```\n",
"python": "```python\nBasic usage with tags: python\n```\n",
"typescript": "\n```typescript\nBasic usage with tags: typescript\n```\n",
"yaml": "```yaml\nBasic usage with tags: yaml\n```\n",
},
},
{
Title: "VPC with CIDR from AWS IPAM",
Snippets: map[string]string{
"csharp": "```csharp\nVPC with CIDR from AWS IPAM: csharp\n```\n",
2022-10-04 17:24:06 +00:00
"go": "Coming soon!",
2022-10-04 01:06:38 +00:00
"java": "```java\nVPC with CIDR from AWS IPAM: java\n```\n",
"python": "```python\nVPC with CIDR from AWS IPAM: python\n```\n",
"typescript": "\n```typescript\nVPC with CIDR from AWS IPAM: typescript\n```\n",
"yaml": "```yaml\nVPC with CIDR from AWS IPAM: yaml\n```\n",
},
},
},
all: Reformat with gofumpt Per team discussion, switching to gofumpt. [gofumpt][1] is an alternative, stricter alternative to gofmt. It addresses other stylistic concerns that gofmt doesn't yet cover. [1]: https://github.com/mvdan/gofumpt See the full list of [Added rules][2], but it includes: - Dropping empty lines around function bodies - Dropping unnecessary variable grouping when there's only one variable - Ensuring an empty line between multi-line functions - simplification (`-s` in gofmt) is always enabled - Ensuring multi-line function signatures end with `) {` on a separate line. [2]: https://github.com/mvdan/gofumpt#Added-rules gofumpt is stricter, but there's no lock-in. All gofumpt output is valid gofmt output, so if we decide we don't like it, it's easy to switch back without any code changes. gofumpt support is built into the tooling we use for development so this won't change development workflows. - golangci-lint includes a gofumpt check (enabled in this PR) - gopls, the LSP for Go, includes a gofumpt option (see [installation instrutions][3]) [3]: https://github.com/mvdan/gofumpt#installation This change was generated by running: ```bash gofumpt -w $(rg --files -g '*.go' | rg -v testdata | rg -v compilation_error) ``` The following files were manually tweaked afterwards: - pkg/cmd/pulumi/stack_change_secrets_provider.go: one of the lines overflowed and had comments in an inconvenient place - pkg/cmd/pulumi/destroy.go: `var x T = y` where `T` wasn't necessary - pkg/cmd/pulumi/policy_new.go: long line because of error message - pkg/backend/snapshot_test.go: long line trying to assign three variables in the same assignment I have included mention of gofumpt in the CONTRIBUTING.md.
2023-03-03 16:36:39 +00:00
importDetails: "\n\nVPCs can be imported using the `vpc id`, e.g.,\n\n```sh\n $ pulumi import aws:ec2/vpc:Vpc test_vpc vpc-a01106c2\n```\n",
},
2022-10-04 01:06:38 +00:00
info)
}