1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
package main
import (
"encoding/json"
"fmt"
"os"
"os/exec"
"path/filepath"
"time"
"github.com/spf13/cobra"
)
func newADRCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "adr",
Short: "Generate an Architecture Decision Record",
DisableAutoGenTag: true,
}
cmd.AddCommand(newADRAddCmd())
return cmd
}
func newADRAddCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "add",
Short: "Add an Architecture Decision Record",
RunE: adrAddRunE,
DisableAutoGenTag: true,
}
cmd.Flags().String("title", "", "sets the title of the record")
cmd.Flags().String("status", "", "sets the status of the record")
cmd.Flags().String("context", "", "sets the context of the record")
cmd.Flags().String("proposed-design", "", "sets the proposed design of the record")
cmd.Flags().String("decision", "", "sets the decision of the record")
cmd.Flags().String("consequences", "", "sets the consequences of the record")
cmd.Flags().IntSlice("related-adrs", nil, "sets the related adrs of the record")
return cmd
}
//nolint:gocyclo
func adrAddRunE(cmd *cobra.Command, args []string) (err error) {
var adrs string
if adrs, err = getPFlagPath(cmd.Flags(), cmdFlagRoot, cmdFlagDocs, cmdFlagDocsContent, cmdFlagDocsADR); err != nil {
return err
}
c := filepath.Join(adrs, ".adr.config.json")
var raw []byte
if raw, err = os.ReadFile(c); err != nil {
return fmt.Errorf("error opening adr config: %w", err)
}
var config ArchitectureDesignRecordConfig
if err = json.Unmarshal(raw, &config); err != nil {
return fmt.Errorf("error parsing adr config: %w", err)
}
data := &ArchitectureDesignRecordTmpl{
ADR: config.NextID,
Weight: 1000 + config.NextID,
Date: time.Now().Format(dateFmtYAML),
DateISO: time.Now().Format(time.DateOnly),
DateHuman: time.Now().Format("January 2, 2006"),
}
if data.Title, err = cmd.Flags().GetString("title"); err != nil {
return err
}
if data.Status, err = cmd.Flags().GetString("status"); err != nil {
return err
}
if data.Context, err = cmd.Flags().GetString("context"); err != nil {
return err
}
if data.ProposedDesign, err = cmd.Flags().GetString("proposed-design"); err != nil {
return err
}
if data.Decision, err = cmd.Flags().GetString("decision"); err != nil {
return err
}
if data.Consequences, err = cmd.Flags().GetString("consequences"); err != nil {
return err
}
if data.RelatedADRs, err = cmd.Flags().GetIntSlice("related-adrs"); err != nil {
return err
}
for _, related := range data.RelatedADRs {
if related >= config.NextID {
return fmt.Errorf("related adr %d does not exist yet", related)
}
}
fp := filepath.Join(adrs, fmt.Sprintf("%d.md", data.ADR))
var f *os.File
if f, err = os.Create(fp); err != nil {
return fmt.Errorf("error opening file for adr: %w", err)
}
defer f.Close()
if err = tmplADR.Execute(f, data); err != nil {
return fmt.Errorf("error executing template: %w", err)
}
config.NextID += 1
if raw, err = json.Marshal(config); err != nil {
return fmt.Errorf("error serializing config: %w", err)
}
if err = os.WriteFile(c, raw, 0600); err != nil {
return fmt.Errorf("error writing config: %w", err)
}
gitadd := exec.Command("git", "add", fp)
return gitadd.Run()
}
type ArchitectureDesignRecordConfig struct {
NextID int `json:"next_id"`
}
type ArchitectureDesignRecordTmpl struct {
ADR int
Weight int
Date string
DateISO string
DateHuman string
Title string
Status string
Context string
ProposedDesign string
Decision string
Consequences string
RelatedADRs []int
}
|
