From 43a67dc92320673800ca13489d6d3f7e134c583f Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Sat, 17 Feb 2024 11:24:35 -0500 Subject: [PATCH 1/8] Removing custom config --- config/config.go | 11 ------- formats/gotemplate/gotemplate.go | 20 +++++-------- formats/gotemplate/gotemplate_test.go | 43 ++++++++++++++------------- formats/registry.go | 2 +- 4 files changed, 32 insertions(+), 44 deletions(-) delete mode 100644 config/config.go diff --git a/config/config.go b/config/config.go deleted file mode 100644 index f6ec8c1..0000000 --- a/config/config.go +++ /dev/null @@ -1,11 +0,0 @@ -package config - -// type FormatterOpts map[string]interface{} -type FormatterOpts map[string]interface{} - -/* -type FormatterOptsV2 interface { - Set(string, interface{}) error - Get(string) (interface{}, error) -} -*/ diff --git a/formats/gotemplate/gotemplate.go b/formats/gotemplate/gotemplate.go index 0e1a400..062f63a 100644 --- a/formats/gotemplate/gotemplate.go +++ b/formats/gotemplate/gotemplate.go @@ -5,27 +5,21 @@ import ( "errors" "text/template" - "github.com/drewstinnett/gout/v2/config" "github.com/drewstinnett/gout/v2/formats" ) type Formatter struct { - // Template string - Opts config.FormatterOpts + Template string + // Opts config.FormatterOpts } // type TemplateField struct{} func (w Formatter) Format(v interface{}) ([]byte, error) { - var tp string - if t, ok := w.Opts["template"]; !ok { - tp = `{{ printf "%+v" . }}` - } else { - if tp, ok = t.(string); !ok { - return nil, errors.New("Found a template option, but it's not a string") - } + if w.Template == "" { + return nil, errors.New("no Template set for gotemplate") } var doc bytes.Buffer - tmpl, err := template.New("item").Parse(tp) + tmpl, err := template.New("item").Parse(w.Template) if err != nil { return nil, err } @@ -38,6 +32,8 @@ func (w Formatter) Format(v interface{}) ([]byte, error) { func init() { formats.Add("gotemplate", func() formats.Formatter { - return &Formatter{} + return &Formatter{ + Template: `{{ printf "%+v" . }}`, + } }) } diff --git a/formats/gotemplate/gotemplate_test.go b/formats/gotemplate/gotemplate_test.go index bfd054c..fc47d88 100644 --- a/formats/gotemplate/gotemplate_test.go +++ b/formats/gotemplate/gotemplate_test.go @@ -3,25 +3,38 @@ package gotemplate import ( "testing" - "github.com/drewstinnett/gout/v2/config" "github.com/stretchr/testify/require" ) func TestGTOFormatterFormat(t *testing.T) { - f := Formatter{} - v := struct { + f := Formatter{ + Template: `{{ printf "%+v" . }}`, + } + got, err := f.Format(struct { Title string Year int }{ Title: "Ghostbusters", Year: 1985, - } - got, err := f.Format(v) + }) require.NoError(t, err) require.NotNil(t, got) require.Equal(t, "{Title:Ghostbusters Year:1985}", string(got)) } +func TestEmptyTemplate(t *testing.T) { + f := Formatter{} + got, err := f.Format(struct { + Title string + Year int + }{ + Title: "Ghostbusters", + Year: 1985, + }) + require.EqualError(t, err, "foo") + require.Nil(t, got) +} + func TestGTOFormatter(t *testing.T) { v := struct { Title string @@ -31,9 +44,7 @@ func TestGTOFormatter(t *testing.T) { Year: 1985, } f := Formatter{ - Opts: map[string]interface{}{ - "template": "{{ .Title }}", - }, + Template: "{{ .Title }}", } got, err := f.Format(v) require.NoError(t, err) @@ -50,9 +61,7 @@ func TestGTOFormatterTemplateError(t *testing.T) { Year: 1985, } f := Formatter{ - Opts: map[string]interface{}{ - "template": "{{ .NotExistingField }}", - }, + Template: "{{ .NotExistingField }}", } got, err := f.Format(v) require.Error(t, err) @@ -74,9 +83,7 @@ func TestGTOFormatterMultiVal(t *testing.T) { }, } f := Formatter{ - Opts: map[string]interface{}{ - "template": "{{ range . }}{{ .Title }}\n{{ end }}", - }, + Template: "{{ range . }}{{ .Title }}\n{{ end }}", } got, err := f.Format(v) require.NoError(t, err) @@ -93,9 +100,7 @@ func TestGTOWithOptsFormatter(t *testing.T) { Year: 1985, } f := Formatter{ - Opts: config.FormatterOpts{ - "template": "{{ .Title }}", - }, + Template: "{{ .Title }}", } got, err := f.Format(v) require.NoError(t, err) @@ -131,9 +136,7 @@ func TestFormatWithContext(t *testing.T) { Year: 1985, } f := Formatter{ - Opts: config.FormatterOpts{ - "template": "{{ .Title }}", - }, + Template: "{{ .Title }}", } got, err := f.Format(v) require.NoError(t, err) diff --git a/formats/registry.go b/formats/registry.go index 654e1f3..c5aa9d5 100644 --- a/formats/registry.go +++ b/formats/registry.go @@ -15,7 +15,7 @@ func Add(name string, creator Creator) { // Names returns a slice of the names of the formatters func Names() []string { - ret := []string{} + ret := make([]string, 0, len(Formats)) for k := range Formats { ret = append(ret, k) } From c979861345a1e036ef0c344dd021ea4f7955a8e9 Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Sat, 17 Feb 2024 17:49:35 -0500 Subject: [PATCH 2/8] Removing utils --- formats/gotemplate/gotemplate_test.go | 2 +- utils/util.go | 49 ----------- utils/utils_test.go | 117 -------------------------- 3 files changed, 1 insertion(+), 167 deletions(-) delete mode 100644 utils/util.go delete mode 100644 utils/utils_test.go diff --git a/formats/gotemplate/gotemplate_test.go b/formats/gotemplate/gotemplate_test.go index fc47d88..0c2e908 100644 --- a/formats/gotemplate/gotemplate_test.go +++ b/formats/gotemplate/gotemplate_test.go @@ -31,7 +31,7 @@ func TestEmptyTemplate(t *testing.T) { Title: "Ghostbusters", Year: 1985, }) - require.EqualError(t, err, "foo") + require.EqualError(t, err, "no Template set for gotemplate") require.Nil(t, got) } diff --git a/utils/util.go b/utils/util.go deleted file mode 100644 index b8da3eb..0000000 --- a/utils/util.go +++ /dev/null @@ -1,49 +0,0 @@ -package utils - -import ( - "encoding/json" - "fmt" - "reflect" -) - -// GenericUnmarshal Given an arbitrary piece of data, return a slice of json data -func GenericUnmarshal(data interface{}) ([]map[string]interface{}, error) { - j, _ := json.Marshal(data) - var jsonSlice []map[string]interface{} - baseObjType := reflect.ValueOf(data).Kind() - var objType string - if baseObjType == reflect.Struct { - objType = "struct" - } else if baseObjType == reflect.Slice { - objType = "slice" - } else if baseObjType == reflect.Ptr { - objType = reflect.ValueOf(data).Elem().Kind().String() - } - switch objType { - case "struct": - jsonMap := make(map[string]interface{}) - err := json.Unmarshal(j, &jsonMap) - if err != nil { - return nil, err - } - jsonSlice = append(jsonSlice, jsonMap) - case "slice": - err := json.Unmarshal(j, &jsonSlice) - if err != nil { - return nil, err - } - default: - return nil, fmt.Errorf("Unknown type of data for gotemplate: %s", objType) - } - return jsonSlice, nil -} - -// StringInSlice Check if a slice for a string -func StringInSlice(a string, list []string) bool { - for _, b := range list { - if b == a { - return true - } - } - return false -} diff --git a/utils/utils_test.go b/utils/utils_test.go deleted file mode 100644 index 02b1f4d..0000000 --- a/utils/utils_test.go +++ /dev/null @@ -1,117 +0,0 @@ -package utils - -import ( - "encoding/json" - "errors" - "fmt" - "reflect" - "testing" - - "github.com/stretchr/testify/require" -) - -func TestSliceContains(t *testing.T) { - t.Parallel() - s := []string{"foo", "bar", "baz"} - - got := StringInSlice("bar", s) - require.True(t, got) -} - -func TestSliceNotContains(t *testing.T) { - t.Parallel() - s := []string{"foo", "bar", "baz"} - - got := StringInSlice("NeverExists", s) - require.False(t, got) -} - -func TestGenericUnmarshalStruct(t *testing.T) { - type foo struct { - Name string `json:"name"` - Age int `json:"age"` - } - test := foo{ - Name: "Drew", - Age: 25, - } - got, err := genericUnmarshal(test) - require.NoError(t, err) - require.Greater(t, len(got), 0) - - f := fakeValue{ - errors.New("fail"), - } - _, err = genericUnmarshal(f) - require.Error(t, err) -} - -func TestGenericUnmarshalSlice(t *testing.T) { - test := []map[string]string{ - {"foo": "bar"}, - {"baz": "thing"}, - } - got, err := genericUnmarshal(test) - require.NoError(t, err) - require.Greater(t, len(got), 0) -} - -func TestGenericUnmarshalPtr(t *testing.T) { - test := []map[string]string{ - {"foo": "bar"}, - {"baz": "thing"}, - } - got, err := genericUnmarshal(&test) - require.NoError(t, err) - require.Greater(t, len(got), 0) - - f := fakeValue{ - errors.New("fail"), - } - _, err = genericUnmarshal([]fakeValue{f}) - require.Error(t, err) -} - -type fakeValue struct { - err error -} - -func (v fakeValue) MarshalJSON() ([]byte, error) { - if v.err != nil { - return nil, v.err - } - - return []byte(`null`), v.err -} - -// GenericUnmarshal Given an arbitrary piece of data, return a slice of json data -func genericUnmarshal(data interface{}) ([]map[string]interface{}, error) { - j, _ := json.Marshal(data) - var jsonSlice []map[string]interface{} - baseObjType := reflect.ValueOf(data).Kind() - var objType string - if baseObjType == reflect.Struct { - objType = "struct" - } else if baseObjType == reflect.Slice { - objType = "slice" - } else if baseObjType == reflect.Ptr { - objType = reflect.ValueOf(data).Elem().Kind().String() - } - switch objType { - case "struct": - jsonMap := make(map[string]interface{}) - err := json.Unmarshal(j, &jsonMap) - if err != nil { - return nil, err - } - jsonSlice = append(jsonSlice, jsonMap) - case "slice": - err := json.Unmarshal(j, &jsonSlice) - if err != nil { - return nil, err - } - default: - return nil, fmt.Errorf("Unknown type of data for gotemplate: %s", objType) - } - return jsonSlice, nil -} From e66bb9e5f452fbf4b6dc38f9f5dde450834e507b Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Sat, 17 Feb 2024 17:52:04 -0500 Subject: [PATCH 3/8] Removing old files --- formatters.go | 15 --------------- formatters_test.go | 8 -------- 2 files changed, 23 deletions(-) delete mode 100644 formatters.go delete mode 100644 formatters_test.go diff --git a/formatters.go b/formatters.go deleted file mode 100644 index c8518d7..0000000 --- a/formatters.go +++ /dev/null @@ -1,15 +0,0 @@ -package gout - -// BuiltInFormatters is a map of all formatters that we ship -/* -var BuiltInFormatters = map[string]formats.Formatter{ - "json": json.Formatter{}, - "yaml": yaml.Formatter{}, - "plain": plain.Formatter{}, - "toml": toml.Formatter{}, - "csv": csv.Formatter{}, - "xml": xml.Formatter{}, - "gotemplate": gotemplate.Formatter{}, -} - -*/ diff --git a/formatters_test.go b/formatters_test.go deleted file mode 100644 index 8dac72e..0000000 --- a/formatters_test.go +++ /dev/null @@ -1,8 +0,0 @@ -package gout - -/* -func TestBuiltInFormatters(t *testing.T) { - require.Contains(t, BuiltInFormatters, "yaml") - require.NotContains(t, BuiltInFormatters, "never-exist") -} -*/ From 613aee2cd78d87e208438a123719b2f268445b41 Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Mon, 19 Feb 2024 19:26:15 -0500 Subject: [PATCH 4/8] Simplify output plugin --- .golangci.yml | 365 ++++++++++++++++++++++++++++++- doc/README.md | 64 ------ formats/gotemplate/gotemplate.go | 6 +- formats/json/json.go | 24 +- formats/json/json_test.go | 14 -- formats/plain/plain.go | 5 + formats/registry.go | 5 + formats/xml/xml.go | 5 + formats/yaml/yaml.go | 5 + gout.go | 42 +++- gout_test.go | 21 +- 11 files changed, 438 insertions(+), 118 deletions(-) delete mode 100644 doc/README.md diff --git a/.golangci.yml b/.golangci.yml index 8cb08f7..0430f52 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -1,9 +1,364 @@ +# This file contains all available configuration options +# with their default values. + +# options for analysis running +run: + # default concurrency is a available CPU number + # concurrency: 4 + + # timeout for analysis, e.g. 30s, 5m, default is 1m + timeout: 30m + + # exit code when at least one issue was found, default is 1 + issues-exit-code: 1 + + # include test files or not, default is true + tests: true + + # list of build tags, all linters use it. Default is empty list. + # build-tags: + # - mytag + + # which dirs to skip: issues from them won't be reported; + # can use regexp here: generated.*, regexp is applied on full path; + # default value is empty list, but default dirs are skipped independently + # from this option's value (see skip-dirs-use-default). + # skip-dirs: + # - src/external_libs + # - autogenerated_by_my_lib + + # default is true. Enables skipping of directories: + # vendor$, third_party$, testdata$, examples$, Godeps$, builtin$ + skip-dirs-use-default: true + + # which files to skip: they will be analyzed, but issues from them + # won't be reported. Default value is empty list, but there is + # no need to include all autogenerated files, we confidently recognize + # autogenerated files. If it's not please let us know. + skip-files: + - ".*/inventory_easyjson.go" + # - ".*\\.my\\.go$" + # - lib/bad.go + + # by default isn't set. If set we pass it to "go list -mod={option}". From "go help modules": + # If invoked with -mod=readonly, the go command is disallowed from the implicit + # automatic updating of go.mod described above. Instead, it fails when any changes + # to go.mod are needed. This setting is most useful to check that go.mod does + # not need updates, such as in a continuous integration and testing system. + # If invoked with -mod=vendor, the go command assumes that the vendor + # directory holds the correct copies of dependencies and ignores + # the dependency descriptions in go.mod. + # modules-download-mode: readonly|release|vendor + +# output configuration options +output: + # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number" + format: line-number + + # print lines of code with issue, default is true + print-issued-lines: true + + # print linter name in the end of issue text, default is true + print-linter-name: true + +# all available settings of specific linters +linters-settings: + errcheck: + # report about not checking of errors in type assetions: `a := b.(MyStruct)`; + # default is false: such cases aren't reported by default. + check-type-assertions: false + + # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`; + # default is false: such cases aren't reported by default. + check-blank: false + + # [deprecated] comma-separated list of pairs of the form pkg:regex + # the regex is used to ignore names within pkg. (default "fmt:.*"). + # see https://github.com/kisielk/errcheck#the-deprecated-method for details + # ignore: fmt:.*,io/ioutil:^Read.* + + # path to a file containing a list of functions to exclude from checking + # see https://github.com/kisielk/errcheck#excluding-functions for details + # exclude: /path/to/file.txt + + # Disable error checking, as errorcheck detects more errors and is more configurable. + + funlen: + lines: 60 + statements: 40 + + govet: + # report about shadowed variables + check-shadowing: true + + # settings per analyzer + settings: + printf: # analyzer name, run `go tool vet help` to see all analyzers + funcs: # run `go tool vet help printf` to see available settings for `printf` analyzer + - (github.com/golangci/golangci-lint/pkg/logutils.Log).Infof + - (github.com/golangci/golangci-lint/pkg/logutils.Log).Warnf + - (github.com/golangci/golangci-lint/pkg/logutils.Log).Errorf + - (github.com/golangci/golangci-lint/pkg/logutils.Log).Fatalf + + # enable or disable analyzers by name + # enable: + # - atomicalign + # enable-all: false + # disable: + # - shadow + # disable-all: false + gofmt: + # simplify code: gofmt with `-s` option, true by default + simplify: true + goimports: {} + # put imports beginning with prefix after 3rd-party packages; + # it's a comma-separated list of prefixes + # local-prefixes: github.com/org/project + gocyclo: + # minimal code complexity to report, 30 by default (but we recommend 10-20) + min-complexity: 20 + gocognit: + # minimal code complexity to report, 30 by default (but we recommend 10-20) + min-complexity: 20 + maligned: + # print struct with more effective memory layout or not, false by default + suggest-new: true + dupl: + # tokens count to trigger issue, 150 by default + threshold: 100 + goconst: + # minimal length of string constant, 3 by default + min-len: 3 + # minimal occurrences count to trigger, 3 by default + min-occurrences: 3 + depguard: + rules: + main: + files: + - "$all" + - "!$test" + deny: + - pkg: "log$" + desc: "Use log/slog so we can always do structured logging, via the logger" + - pkg: "github.com/rs/zerolog/log" + desc: "Use log/slog so we can always do structured logging, via the logger" + allow: + - '$gostd' + - "github.com/spf13/cobra" + - "github.com/spf13/viper" + - "github.com/spf13/pflag" + - "github.com/mitchellh/go-homedir" + - "github.com/drewstinnett/gout/v2/formats" + tests: + files: + - "$test" + allow: + - '$gostd' + - "github.com/stretchr/testify" + - "github.com/stretchr/testify/require" + - "github.com/drewstinnett/gout/v2/formats" + - _ "github.com/drewstinnett/gout/v2/formats/builtin" + # depguard: + # list-type: blacklist + # include-go-root: false + # packages: + # - github.com/sirupsen/logrus + # packages-with-error-messages: + # # specify an error message to output when a blacklisted package is used + # github.com/sirupsen/logrus: "logging is allowed only by logutils.Log" + misspell: + # Correct spellings using locale preferences for US or UK. + # Default is to use a neutral variety of English. + # Setting locale to US will correct the British spelling of 'colour' to 'color'. + locale: US + ignore-words: + - GitLab + lll: + # max line length, lines longer will be reported. Default is 120. + # '\t' is counted as 1 character by default, and can be changed with the tab-width option + line-length: 120 + # tab width in spaces. Default to 1. + tab-width: 1 + # unused: + # treat code as a program (not a library) and report unused exported identifiers; default is false. + # XXX: if you enable this setting, unused will report a lot of false-positives in text editors: + # if it's called for subdir of a project it can't find funcs usages. All text editor integrations + # with golangci-lint call it on a directory with the changed file. + # check-exported: false + unparam: + # Inspect exported functions, default is false. Set to true if no external program/library imports your code. + # XXX: if you enable this setting, unparam will report a lot of false-positives in text editors: + # if it's called for subdir of a project it can't find external interfaces. All text editor integrations + # with golangci-lint call it on a directory with the changed file. + check-exported: false + nakedret: + # make an issue if func has more lines of code than this setting and it has naked returns; default is 30 + max-func-lines: 30 + prealloc: + # XXX: we don't recommend using this linter before doing performance profiling. + # For most programs usage of prealloc will be a premature optimization. + + # Report preallocation suggestions only on simple loops that have no returns/breaks/continues/gotos in them. + # True by default. + simple: true + range-loops: true # Report preallocation suggestions on range loops, true by default + for-loops: false # Report preallocation suggestions on for loops, false by default + gocritic: + # Which checks should be enabled; can't be combined with 'disabled-checks'; + # See https://go-critic.github.io/overview#checks-overview + # To check which checks are enabled run `GL_DEBUG=gocritic golangci-lint run` + # By default list of stable checks is used. + # enabled-checks: + # - rangeValCopy + + # Which checks should be disabled; can't be combined with 'enabled-checks'; default is empty + # disabled-checks: + # - regexpMust + + # Enable multiple checks by tags, run `GL_DEBUG=gocritic golangci-lint run` to see all tags and checks. + # Empty list by default. See https://github.com/go-critic/go-critic#usage -> section "Tags". + # enabled-tags: + # - performance + + settings: # settings passed to gocritic + captLocal: # must be valid enabled check name + paramsOnly: true + # rangeValCopy: + # sizeThreshold: 32 + godox: + # report any comments starting with keywords, this is useful for TODO or FIXME comments that + # might be left in the code accidentally and should be resolved before merging + keywords: # default keywords are TODO, BUG, and FIXME, these can be overwritten by this setting + - TODO + - BUG + - FIXME + - NOTE + - OPTIMIZE # marks code that should be optimized before merging + - HACK # marks hack-arounds that should be removed before merging + dogsled: + # checks assignments with too many blank identifiers; default is 2 + max-blank-identifiers: 2 + + whitespace: + multi-if: false # Enforces newlines (or comments) after every multi-line if statement + multi-func: false # Enforces newlines (or comments) after every multi-line function signature + wsl: + # If true append is only allowed to be cuddled if appending value is + # matching variables, fields or types on line above. Default is true. + strict-append: true + # Allow calls and assignments to be cuddled as long as the lines have any + # matching variables, fields or types. Default is true. + allow-assign-and-call: true + # Allow multiline assignments to be cuddled. Default is true. + allow-multiline-assign: true + # Allow declarations (var) to be cuddled. + allow-cuddle-declarations: false + # Allow trailing comments in ending of blocks + allow-trailing-comment: false + # Force newlines in end of case at this limit (0 = never). + force-case-trailing-whitespace: 0 + linters: + # please, do not use `enable-all`: it's deprecated and will be removed soon. + # inverted configuration with `enable-all` and `disable` is not scalable during updates of golangci-lint + disable-all: true enable: - - thelper - - gofumpt - - tparallel + - bodyclose + - depguard + - dogsled + - dupl + - errcheck + - funlen + - gocognit + - goconst + - gocritic + - godox + - gofmt + - goimports + - revive + - gosec + - gosimple + - govet + - ineffassign + - misspell + - nakedret + - exportloopref + - staticcheck + - stylecheck + - typecheck - unconvert - unparam - - wastedassign - - revive + - unused + - whitespace + # don't enable: + # - deadcode + # - gochecknoglobals + # - gochecknoinits + # - gocyclo + # - lll + # - maligned + # - prealloc + # - varcheck + +issues: + # List of regexps of issue texts to exclude, empty list by default. + # But independently from this option we use default exclude patterns, + # it can be disabled by `exclude-use-default: false`. To list all + # excluded by default patterns execute `golangci-lint run --help` + # exclude: + # - abcdef + + # Excluding configuration per-path, per-linter, per-text and per-source + exclude-rules: + # Exclude some linters from running on tests files. + - path: _test\.go + linters: + - gocyclo + - errcheck + - dupl + - gosec + - funlen + + # Exclude known linters from partially hard-vendored code, + # which is impossible to exclude via "nolint" comments. + # - path: internal/hmac/ + # text: "weak cryptographic primitive" + # linters: + # - gosec + + # Exclude some staticcheck messages + # - linters: + # - staticcheck + # text: "SA9003:" + + # Exclude lll issues for long lines with go:generate + - linters: + - lll + source: "^//go:generate " + + # Independently from option `exclude` we use default exclude patterns, + # it can be disabled by this option. To list all + # excluded by default patterns execute `golangci-lint run --help`. + # Default value for this option is true. + exclude-use-default: false + + # Maximum issues count per one linter. Set to 0 to disable. Default is 50. + max-issues-per-linter: 0 + + # Maximum count of issues with the same text. Set to 0 to disable. Default is 3. + max-same-issues: 0 + + # Show only new issues: if there are unstaged changes or untracked files, + # only those changes are analyzed, else only changes in HEAD~ are analyzed. + # It's a super-useful option for integration of golangci-lint into existing + # large codebase. It's not practical to fix all existing issues at the moment + # of integration: much better don't allow issues in new code. + # Default is false. + new: false + + # Show only new issues created after git revision `REV` + # This should be passed as flag during individual CI jobs. + # new-from-rev: REV + + # Show only new issues created in git patch with set file path. + # new-from-patch: path/to/patch/file diff --git a/doc/README.md b/doc/README.md deleted file mode 100644 index 613cb64..0000000 --- a/doc/README.md +++ /dev/null @@ -1,64 +0,0 @@ - - -# formatter - -```go -import "github.com/drewstinnett/gout/formatter" -``` - -## Index - -- [func GenericUnmarshal(data interface{}) ([]map[string]interface{}, error)](<#func-genericunmarshal>) -- [func GetFormats() []string](<#func-getformats>) -- [func OutputData(data interface{}, config *Config) ([]byte, error)](<#func-outputdata>) -- [func StringInSlice(a string, list []string) bool](<#func-stringinslice>) -- [type Config](<#type-config>) - - -## func GenericUnmarshal - -```go -func GenericUnmarshal(data interface{}) ([]map[string]interface{}, error) -``` - -GenericUnmarshal Given an arbitrary piece of data\, return a slice of json data - -## func GetFormats - -```go -func GetFormats() []string -``` - -GetFormats Return a list of formats available in formatters\. Useful if you need to check what formatters are available in a standardized way - -## func OutputData - -```go -func OutputData(data interface{}, config *Config) ([]byte, error) -``` - -OutputData Main function to return the data we will be printing to the screen\. This is where the magic happens\! - -## func StringInSlice - -```go -func StringInSlice(a string, list []string) bool -``` - -StringInSlice Check if a slice for a string - -## type Config - -Config Structure to pass to formatters\. Should include enough config to do the output\. You must set the Format here to something like yaml\, json\, plain\, or any other value returned by the GetFormats function - -```go -type Config struct { - Format string - LimitFields []string - Template string -} -``` - - - -Generated by [gomarkdoc]() diff --git a/formats/gotemplate/gotemplate.go b/formats/gotemplate/gotemplate.go index 062f63a..3024178 100644 --- a/formats/gotemplate/gotemplate.go +++ b/formats/gotemplate/gotemplate.go @@ -1,3 +1,6 @@ +/* +Package gotemplate provides a way to template output as a plugin to Gout +*/ package gotemplate import ( @@ -8,12 +11,13 @@ import ( "github.com/drewstinnett/gout/v2/formats" ) +// Formatter is the base object for the gotemplate object type Formatter struct { Template string // Opts config.FormatterOpts } -// type TemplateField struct{} +// Format satisfies the formats.Format interface func (w Formatter) Format(v interface{}) ([]byte, error) { if w.Template == "" { return nil, errors.New("no Template set for gotemplate") diff --git a/formats/json/json.go b/formats/json/json.go index 2218a07..dae838d 100644 --- a/formats/json/json.go +++ b/formats/json/json.go @@ -1,38 +1,26 @@ +/* +Package json provides a json output plugin for Gout +*/ package json import ( - "context" ujson "encoding/json" "github.com/drewstinnett/gout/v2/formats" ) -type Formatter struct { - ctx context.Context -} - -type IndentField struct{} +// Formatter holds the base json stuff +type Formatter struct{} +// Format satiesfiles the formats.Formatter interface func (w Formatter) Format(v interface{}) ([]byte, error) { var i any - if w.ctx != nil { - i = w.ctx.Value(IndentField{}) - } if i == nil { return ujson.Marshal(v) } return ujson.MarshalIndent(v, "", " ") } -func (w Formatter) FormatWithContext(ctx context.Context, v interface{}) ([]byte, error) { - return w.withContext(ctx).Format(v) -} - -func (w *Formatter) withContext(ctx context.Context) *Formatter { - w.ctx = ctx - return w -} - func init() { formats.Add("json", func() formats.Formatter { return &Formatter{} diff --git a/formats/json/json_test.go b/formats/json/json_test.go index 0d6f9d3..a934d01 100644 --- a/formats/json/json_test.go +++ b/formats/json/json_test.go @@ -1,7 +1,6 @@ package json import ( - "context" "testing" "github.com/stretchr/testify/require" @@ -18,16 +17,3 @@ func TestJSONFormatter(t *testing.T) { require.IsType(t, []byte{}, got) require.Equal(t, string(`{"Foo":"bar"}`), string(got)) } - -func TestJSONFormatterWithOpts(t *testing.T) { - f := Formatter{} - ctx := context.WithValue(context.Background(), IndentField{}, "yes") - got, err := f.FormatWithContext(ctx, struct { - Foo string - }{ - Foo: "bar", - }) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string("{\n \"Foo\": \"bar\"\n}"), string(got)) -} diff --git a/formats/plain/plain.go b/formats/plain/plain.go index 23d62fb..54f31d0 100644 --- a/formats/plain/plain.go +++ b/formats/plain/plain.go @@ -1,3 +1,6 @@ +/* +Package plain just prints the variable as %+v +*/ package plain import ( @@ -6,8 +9,10 @@ import ( "github.com/drewstinnett/gout/v2/formats" ) +// Formatter is the base struct for the plain plugin type Formatter struct{} +// Format satisfies the formats.Formatter interface func (w Formatter) Format(v interface{}) ([]byte, error) { return []byte(fmt.Sprintf("%+v\n", v)), nil } diff --git a/formats/registry.go b/formats/registry.go index c5aa9d5..d51c902 100644 --- a/formats/registry.go +++ b/formats/registry.go @@ -1,11 +1,16 @@ +/* +Package formats provides some base extractions for format plugins +*/ package formats import ( "sort" ) +// Creator is a generator for new formatter instances type Creator func() Formatter +// Formats defines a map of labels to Creators var Formats = map[string]Creator{} // Add a new format creator diff --git a/formats/xml/xml.go b/formats/xml/xml.go index b26f5af..6ed7f72 100644 --- a/formats/xml/xml.go +++ b/formats/xml/xml.go @@ -1,3 +1,6 @@ +/* +Package xml provides an XML plugin for Gout +*/ package xml import ( @@ -6,8 +9,10 @@ import ( "github.com/drewstinnett/gout/v2/formats" ) +// Formatter is the base struct for the xml plugin type Formatter struct{} +// Format satisfies the formats.Formatter interface func (w Formatter) Format(v interface{}) ([]byte, error) { return uxml.Marshal(v) } diff --git a/formats/yaml/yaml.go b/formats/yaml/yaml.go index 8099519..28ea159 100644 --- a/formats/yaml/yaml.go +++ b/formats/yaml/yaml.go @@ -1,3 +1,6 @@ +/* +Package yaml provides the yaml plugin for Gout +*/ package yaml import ( @@ -5,8 +8,10 @@ import ( uyaml "gopkg.in/yaml.v3" ) +// Formatter is the base structure that holds the yaml plugin stuff type Formatter struct{} +// Format satisfies the formats.Formatter interface func (w Formatter) Format(v interface{}) ([]byte, error) { return uyaml.Marshal(v) } diff --git a/gout.go b/gout.go index fbdba68..5c40a4a 100644 --- a/gout.go +++ b/gout.go @@ -1,3 +1,6 @@ +/* +Package gout provides a custom G OUTput formatter +*/ package gout import ( @@ -7,8 +10,7 @@ import ( "os" "github.com/drewstinnett/gout/v2/formats" - // Include all the builtin formats by default - _ "github.com/drewstinnett/gout/v2/formats/builtin" + _ "github.com/drewstinnett/gout/v2/formats/builtin" // Include all the builtin formats by default "github.com/drewstinnett/gout/v2/formats/yaml" ) @@ -19,8 +21,15 @@ type Gout struct { writer io.Writer } -// Use this for doing things without explicitely creating a new gout, similar to +// Use this for doing things without explicitly creating a new gout, similar to // viper.Viper +// +// The pattern for usage is something like: +// gout.Print("Hello") +// +// works similarly to: +// custom := New() +// custom.Print("Hello") var gi *Gout func init() { @@ -36,24 +45,42 @@ func Get() *Gout { // will be os.Stdout func SetWriter(i io.Writer) { gi.SetWriter(i) } +// SetWriter sets the writer on a custom Gout instance func (g *Gout) SetWriter(i io.Writer) { g.writer = i } -// SetFormatter sets the Formatter to use for the text. +// SetFormatter sets the built in Gout instance func SetFormatter(f formats.Formatter) { gi.SetFormatter(f) } +// SetFormatter sets the formatter on a custom Gout instance func (g *Gout) SetFormatter(f formats.Formatter) { g.formatter = f } +// SetFormatterString sets the formatter from the string that the plugin was registered with +func SetFormatterString(s string) error { + return gi.SetFormatterString(s) +} + +// SetFormatterString sets the formatter from the string that the plugin was registered with +func (g *Gout) SetFormatterString(s string) error { + if f, ok := formats.Formats[s]; ok { + g.formatter = f() + + return nil + } + return fmt.Errorf("unknown formatter name: %v", s) +} + // Print print an interface using the given Formatter and io.Writer func Print(v interface{}) (err error) { return gi.Print(v) } +// Print prints the output on a custom Gout instance func (g *Gout) Print(v interface{}) (err error) { defer func() { if r := recover(); r != nil { - err = fmt.Errorf("Panic while attempting to format: %v", r) + err = fmt.Errorf("panic while attempting to format: %v", r) } }() var b []byte @@ -69,10 +96,11 @@ func (g *Gout) Print(v interface{}) (err error) { // serialized item func PrintMulti(v ...interface{}) (err error) { return gi.PrintMulti(v) } +// PrintMulti prints multiple items on a custom gout instance func (g *Gout) PrintMulti(v ...interface{}) (err error) { defer func() { if r := recover(); r != nil { - err = fmt.Errorf("Panic while attempting to format: %v", r) + err = fmt.Errorf("panic while attempting to format: %v", r) } }() var b []byte @@ -88,6 +116,7 @@ func (g *Gout) PrintMulti(v ...interface{}) (err error) { // MustPrint print an interface and panic if there is any sort of error func MustPrint(v interface{}) { gi.MustPrint(v) } +// MustPrint outputs data on a custom Gout instance func (g *Gout) MustPrint(v interface{}) { err := g.Print(v) if err != nil { @@ -99,6 +128,7 @@ func (g *Gout) MustPrint(v interface{}) { // error func MustPrintMulti(v ...interface{}) { gi.MustPrintMulti(v) } +// MustPrintMulti prints multiple items with a custom Gout instance func (g *Gout) MustPrintMulti(v ...interface{}) { err := g.PrintMulti(v) if err != nil { diff --git a/gout_test.go b/gout_test.go index fb096cd..efe2fd3 100644 --- a/gout_test.go +++ b/gout_test.go @@ -25,6 +25,11 @@ func TestSetGoutWriter(t *testing.T) { // Make sure we can change the formatter c.SetFormatter(plain.Formatter{}) require.IsType(t, plain.Formatter{}, c.formatter) + + buf = bytes.Buffer{} + c.SetFormatterString("json") + c.Print(struct{ Foo string }{Foo: "bar"}) + require.Equal(t, "{\"Foo\":\"bar\"}\n", buf.String()) } func TestNewGoutWithWriter(t *testing.T) { @@ -54,20 +59,16 @@ func TestPrintError(t *testing.T) { func TestBuiltinGout(t *testing.T) { require.NotPanics(t, func() { MustPrint("foo") }) - require.NotPanics(t, func() { SetWriter(os.Stderr) }) require.NotPanics(t, func() { SetFormatter(json.Formatter{}) }) - - err := Print("foo") - require.NoError(t, err) - - err = PrintMulti("foo", "bar") - require.NoError(t, err) - + require.NoError(t, Print("foo")) + require.NoError(t, PrintMulti("foo", "bar")) require.NotPanics(t, func() { MustPrintMulti("foo", "bar") }) + require.NotNil(t, Get()) - got := Get() - require.NotNil(t, got) + require.NoError(t, SetFormatterString("plain")) + require.EqualError(t, SetFormatterString("never-exists"), "unknown formatter name: never-exists") + require.IsType(t, &plain.Formatter{}, Get().formatter) } func TestWriterPrinterMulti(t *testing.T) { From 7828b2285939b4e50b436666ef469790e3cdcf2b Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Mon, 19 Feb 2024 19:29:51 -0500 Subject: [PATCH 5/8] Fixing example bit --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index fb021ce..934633e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -40,7 +40,7 @@ jobs: - name: Checkout code uses: actions/checkout@v4 - name: Test Examples - run: for EX in $(ls _examples); do go run ./_examples/$EX; done + run: go mod tidy; for EX in $(ls _examples); do go run ./_examples/$EX; done coverage: runs-on: ubuntu-latest steps: From 57aed16864b5c96cbff6ce6d80cc507343995d51 Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Mon, 19 Feb 2024 19:31:31 -0500 Subject: [PATCH 6/8] Fix output example --- .github/workflows/test.yml | 2 +- _examples/gotemplate/main.go | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 934633e..fb021ce 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -40,7 +40,7 @@ jobs: - name: Checkout code uses: actions/checkout@v4 - name: Test Examples - run: go mod tidy; for EX in $(ls _examples); do go run ./_examples/$EX; done + run: for EX in $(ls _examples); do go run ./_examples/$EX; done coverage: runs-on: ubuntu-latest steps: diff --git a/_examples/gotemplate/main.go b/_examples/gotemplate/main.go index fafc325..14f320a 100644 --- a/_examples/gotemplate/main.go +++ b/_examples/gotemplate/main.go @@ -4,7 +4,6 @@ import ( "fmt" gout "github.com/drewstinnett/gout/v2" - "github.com/drewstinnett/gout/v2/config" "github.com/drewstinnett/gout/v2/formats/gotemplate" ) @@ -24,9 +23,7 @@ func main() { } g := gout.New() g.SetFormatter(gotemplate.Formatter{ - Opts: config.FormatterOpts{ - "template": "{{ range . }}{{ .FirstName }} {{ .LastName }} is {{ .Age }} years old\n{{ end }}", - }, + Template: "{{ range . }}{{ .FirstName }} {{ .LastName }} is {{ .Age }} years old\n{{ end }}", }) //"template": "{{ range . }}{{ .FirstName }} {{ .LastName }} is {{ .Age }} years old\n{{ end }}", fmt.Printf("# Format: gotemplate\n## People\n") From 75cafeea0483c6b3acaf7cfb565811297c8dad65 Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Wed, 21 Feb 2024 18:26:04 -0500 Subject: [PATCH 7/8] Cleanup --- gout_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gout_test.go b/gout_test.go index efe2fd3..98ac17d 100644 --- a/gout_test.go +++ b/gout_test.go @@ -88,5 +88,5 @@ func TestWriterAddNewlines(t *testing.T) { var buf bytes.Buffer c.SetWriter(&buf) c.Print(struct{ Foo string }{Foo: "bar"}) - require.Equal(t, true, strings.HasSuffix(buf.String(), "\n"), "Printer did not have a linebreak suffix") + require.True(t, strings.HasSuffix(buf.String(), "\n"), "Printer did not have a linebreak suffix") } From beff581b34868d98e4ff19e4a9e7780e8495295d Mon Sep 17 00:00:00 2001 From: Drew Stinnett Date: Thu, 22 Feb 2024 20:04:12 -0500 Subject: [PATCH 8/8] Removing testify --- formats/gotemplate/gotemplate_test.go | 183 ++++++++------------------ formats/json/json_test.go | 13 +- formats/plain/plain_test.go | 16 ++- formats/registry_test.go | 17 ++- formats/xml/xml_test.go | 16 ++- formats/yaml/yaml_test.go | 63 +-------- go.mod | 10 +- go.sum | 11 -- gout_test.go | 118 ++++++++++++----- 9 files changed, 185 insertions(+), 262 deletions(-) diff --git a/formats/gotemplate/gotemplate_test.go b/formats/gotemplate/gotemplate_test.go index 0c2e908..653bb1c 100644 --- a/formats/gotemplate/gotemplate_test.go +++ b/formats/gotemplate/gotemplate_test.go @@ -2,144 +2,71 @@ package gotemplate import ( "testing" - - "github.com/stretchr/testify/require" ) func TestGTOFormatterFormat(t *testing.T) { - f := Formatter{ - Template: `{{ printf "%+v" . }}`, - } - got, err := f.Format(struct { - Title string - Year int - }{ - Title: "Ghostbusters", - Year: 1985, - }) - require.NoError(t, err) - require.NotNil(t, got) - require.Equal(t, "{Title:Ghostbusters Year:1985}", string(got)) -} - -func TestEmptyTemplate(t *testing.T) { - f := Formatter{} - got, err := f.Format(struct { - Title string - Year int - }{ - Title: "Ghostbusters", - Year: 1985, - }) - require.EqualError(t, err, "no Template set for gotemplate") - require.Nil(t, got) -} - -func TestGTOFormatter(t *testing.T) { - v := struct { + type movie struct { Title string Year int - }{ - Title: "Ghostbusters", - Year: 1985, - } - f := Formatter{ - Template: "{{ .Title }}", - } - got, err := f.Format(v) - require.NoError(t, err) - require.NotNil(t, got) - require.Equal(t, "Ghostbusters", string(got)) -} - -func TestGTOFormatterTemplateError(t *testing.T) { - v := struct { - Title string - Year int - }{ - Title: "Ghostbusters", - Year: 1985, - } - f := Formatter{ - Template: "{{ .NotExistingField }}", } - got, err := f.Format(v) - require.Error(t, err) - require.Nil(t, got) -} -func TestGTOFormatterMultiVal(t *testing.T) { - v := []struct { - Title string - Year int + tests := map[string]struct { + given []movie + givenT string + expect string + expectErr string }{ - { - Title: "Ghostbusters", - Year: 1985, + "custom-template": { + given: []movie{ + {Title: "Ghostbusters", Year: 1985}, + }, + givenT: `{{ printf "%+v" . }}`, + expect: "{Title:Ghostbusters Year:1985}", }, - { - Title: "Halloween", - Year: 1978, + "missing-template": { + given: []movie{ + {Title: "Ghostbusters"}, + }, + expectErr: "no Template set for gotemplate", + }, + "bad-template": { + given: []movie{ + {Title: "Ghostbusters"}, + }, + givenT: "{{ .NotExistingField }}", + expectErr: `template: item:1:3: executing "item" at <.NotExistingField>: can't evaluate field NotExistingField in type gotemplate.movie`, + }, + "multiple-items": { + given: []movie{ + {Title: "Ghostbusters"}, + {Title: "Halloween"}, + }, + givenT: "{{ range . }}{{ .Title }}\n{{ end }}", + expect: "Ghostbusters\nHalloween\n", }, } - f := Formatter{ - Template: "{{ range . }}{{ .Title }}\n{{ end }}", - } - got, err := f.Format(v) - require.NoError(t, err) - require.NotNil(t, got) - require.Equal(t, "Ghostbusters\nHalloween\n", string(got)) -} - -func TestGTOWithOptsFormatter(t *testing.T) { - v := struct { - Title string - Year int - }{ - Title: "Ghostbusters", - Year: 1985, - } - f := Formatter{ - Template: "{{ .Title }}", - } - got, err := f.Format(v) - require.NoError(t, err) - require.NotNil(t, got) - require.Equal(t, "Ghostbusters", string(got)) -} - -/* -func TestGTOWithOptsFormatterMissingTemplate(t *testing.T) { - f := Formatter{ - Template: "", - } - v := struct { - Title string - Year int - }{ - Title: "Ghostbusters", - Year: 1985, - } - // No 'template' option - got, err := f.Format(v) - require.Error(t, err) - require.Nil(t, got) -} -*/ - -func TestFormatWithContext(t *testing.T) { - v := struct { - Title string - Year int - }{ - Title: "Ghostbusters", - Year: 1985, - } - f := Formatter{ - Template: "{{ .Title }}", + for desc, tt := range tests { + // If not multiple 'givens', only pass in a single non-iteralbe interface + var realGiven any + if len(tt.given) == 1 { + realGiven = tt.given[0] + } else { + realGiven = tt.given + } + got, err := Formatter{ + Template: tt.givenT, + }.Format(realGiven) + if tt.expectErr != "" { + if err.Error() != tt.expectErr { + t.Fatalf("%v: expected an error of:\n'%v'\nbut got\n'%v", desc, tt.expectErr, err.Error()) + } + } else { + if err != nil { + t.Fatalf("%v: got an error when none was expected: %v", desc, err) + } + if tt.expect != string(got) { + t.Fatalf("%v: expected %v but got %v", desc, tt.expect, string(got)) + } + } } - got, err := f.Format(v) - require.NoError(t, err) - require.NotNil(t, got) - require.Equal(t, "Ghostbusters", string(got)) } diff --git a/formats/json/json_test.go b/formats/json/json_test.go index a934d01..b77ab74 100644 --- a/formats/json/json_test.go +++ b/formats/json/json_test.go @@ -2,8 +2,6 @@ package json import ( "testing" - - "github.com/stretchr/testify/require" ) func TestJSONFormatter(t *testing.T) { @@ -13,7 +11,12 @@ func TestJSONFormatter(t *testing.T) { }{ Foo: "bar", }) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string(`{"Foo":"bar"}`), string(got)) + if err != nil { + t.Fatalf("got an unexpected error: %v", err) + } + expect := `{"Foo":"bar"}` + gotS := string(got) + if expect != gotS { + t.Fatalf("expected: %v, but got: %v", expect, got) + } } diff --git a/formats/plain/plain_test.go b/formats/plain/plain_test.go index 344fa41..78f8dd1 100644 --- a/formats/plain/plain_test.go +++ b/formats/plain/plain_test.go @@ -2,18 +2,20 @@ package plain import ( "testing" - - "github.com/stretchr/testify/require" ) func TestPlainFormatter(t *testing.T) { - f := Formatter{} - got, err := f.Format(struct { + got, err := Formatter{}.Format(struct { Foo string }{ Foo: "bar", }) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string("{Foo:bar}\n"), string(got)) + if err != nil { + t.Fatalf("got an unexpected error: %v", err) + } + expect := "{Foo:bar}\n" + gotS := string(got) + if gotS != expect { + t.Fatalf("expected: %v but got %v", expect, got) + } } diff --git a/formats/registry_test.go b/formats/registry_test.go index 7be4075..036c4eb 100644 --- a/formats/registry_test.go +++ b/formats/registry_test.go @@ -1,17 +1,22 @@ package formats_test import ( + "slices" "testing" "github.com/drewstinnett/gout/v2/formats" _ "github.com/drewstinnett/gout/v2/formats/builtin" - "github.com/stretchr/testify/require" ) func TestBuiltinRegistry(t *testing.T) { - require.Equal( - t, - []string{"gotemplate", "json", "plain", "xml", "yaml"}, - formats.Names(), - ) + got := formats.Names() + formats := []string{"gotemplate", "json", "plain", "xml", "yaml"} + for _, expect := range formats { + if len(got) != len(formats) { + t.Fatalf("expected len to be %v but got %v", len(formats), len(got)) + } + if !slices.Contains(got, expect) { + t.Fatalf("expected %v to be in %v", expect, got) + } + } } diff --git a/formats/xml/xml_test.go b/formats/xml/xml_test.go index bdd2667..d327404 100644 --- a/formats/xml/xml_test.go +++ b/formats/xml/xml_test.go @@ -3,19 +3,21 @@ package xml import ( "encoding/xml" "testing" - - "github.com/stretchr/testify/require" ) func TestXMLFormatter(t *testing.T) { - f := Formatter{} - got, err := f.Format(struct { + got, err := Formatter{}.Format(struct { XMLName xml.Name `xml:"test"` Foo string `xml:"foo"` }{ Foo: "bar", }) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string("bar"), string(got)) + if err != nil { + t.Fatalf("got unexpected error: %v", err) + } + expect := "bar" + gotS := string(got) + if expect != gotS { + t.Fatalf("expected: %v but got %v", expect, gotS) + } } diff --git a/formats/yaml/yaml_test.go b/formats/yaml/yaml_test.go index eff45b4..7acb229 100644 --- a/formats/yaml/yaml_test.go +++ b/formats/yaml/yaml_test.go @@ -1,28 +1,9 @@ package yaml import ( - "fmt" "testing" - - "github.com/stretchr/testify/require" ) -type Opts struct { - items map[string]interface{} -} - -func (o *Opts) Set(s string, v interface{}) error { - o.items[s] = v - return nil -} - -func (o *Opts) Get(s string) (interface{}, error) { - if _, ok := o.items[s]; ok { - return nil, fmt.Errorf("Could not find config item '%s'", s) - } - return o.items[s], nil -} - func TestYAMLFormatter(t *testing.T) { f := Formatter{} got, err := f.Format(struct { @@ -30,42 +11,12 @@ func TestYAMLFormatter(t *testing.T) { }{ Foo: "bar", }) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string("foo: bar\n"), string(got)) -} - -/* -func TestYAMLFormatterWithOpts(t *testing.T) { - f := Formatter{} - got, err := f.FormatWithContext(context.Background(), []struct { - Foo string - }{ - {Foo: "bar"}, - {Foo: "baz"}, - }) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string("- foo: bar\n- foo: baz\n"), string(got)) -} -*/ - -/* -func TestYAMLFormatterWithOpts(t *testing.T) { - f := Formatter{} - opts := config.FormatterOpts{ - "indent": 10, // TODO: This does not work yet...y?? - "header": true, + if err != nil { + t.Fatalf("got unexpected error: %v", err) + } + expect := "foo: bar\n" + gotS := string(got) + if expect != gotS { + t.Fatalf("expected %v but got %v", expect, got) } - got, err := f.FormatWithOpts([]struct { - Foo string - }{ - {Foo: "bar"}, - {Foo: "baz"}, - }, opts) - require.NoError(t, err) - require.IsType(t, []byte{}, got) - require.Equal(t, string("---\n- foo: bar\n- foo: baz\n"), string(got)) } - -*/ diff --git a/go.mod b/go.mod index 1e833f9..383d1ba 100644 --- a/go.mod +++ b/go.mod @@ -2,12 +2,4 @@ module github.com/drewstinnett/gout/v2 go 1.19 -require ( - github.com/stretchr/testify v1.8.0 - gopkg.in/yaml.v3 v3.0.1 -) - -require ( - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect -) +require gopkg.in/yaml.v3 v3.0.1 diff --git a/go.sum b/go.sum index 5164829..a62c313 100644 --- a/go.sum +++ b/go.sum @@ -1,15 +1,4 @@ -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/gout_test.go b/gout_test.go index 98ac17d..6aaa1f6 100644 --- a/gout_test.go +++ b/gout_test.go @@ -2,17 +2,17 @@ package gout import ( "bytes" - "os" "strings" "testing" "github.com/drewstinnett/gout/v2/formats/json" "github.com/drewstinnett/gout/v2/formats/plain" - "github.com/stretchr/testify/require" ) func TestNewWriter(t *testing.T) { - require.NotNil(t, New()) + if got := New(); got == nil { + t.Fatal("got a nil client with New()") + } } func TestSetGoutWriter(t *testing.T) { @@ -20,66 +20,116 @@ func TestSetGoutWriter(t *testing.T) { var buf bytes.Buffer c.SetWriter(&buf) c.Print(struct{ Foo string }{Foo: "bar"}) - require.Equal(t, "foo: bar\n", buf.String()) + expect := "foo: bar\n" + got := buf.String() + if expect != got { + t.Fatalf("expected: %v but got %v", expect, got) + } // Make sure we can change the formatter c.SetFormatter(plain.Formatter{}) - require.IsType(t, plain.Formatter{}, c.formatter) - buf = bytes.Buffer{} c.SetFormatterString("json") c.Print(struct{ Foo string }{Foo: "bar"}) - require.Equal(t, "{\"Foo\":\"bar\"}\n", buf.String()) + expect = "{\"Foo\":\"bar\"}\n" + got = buf.String() + if expect != got { + t.Fatalf("expected %v but got %v", expect, got) + } } func TestNewGoutWithWriter(t *testing.T) { var b bytes.Buffer - c := New(WithWriter(&b)) - require.NotNil(t, c) - c.Print(struct{ Foo string }{Foo: "bar"}) - require.Equal(t, "foo: bar\n", b.String()) + New(WithWriter(&b)).Print(struct{ Foo string }{Foo: "bar"}) + expect := "foo: bar\n" + got := b.String() + if expect != got { + t.Fatalf("expected %v but got %v", expect, got) + } } func TestNewGoutWithFormatter(t *testing.T) { var b bytes.Buffer - c := New(WithWriter(&b), WithFormatter(plain.Formatter{})) - require.NotNil(t, c) - c.Print(struct{ Foo string }{Foo: "bar"}) - require.Equal(t, "{Foo:bar}\n", b.String()) + New(WithWriter(&b), WithFormatter(plain.Formatter{})).Print(struct{ Foo string }{Foo: "bar"}) + expect := "{Foo:bar}\n" + got := b.String() + if expect != got { + t.Fatalf("expected %v but got %v", expect, got) + } } func TestPrintError(t *testing.T) { c := New() - require.Error(t, c.Print(make(chan int))) + expectErr := "panic while attempting to format: cannot marshal type: chan int" + if err := c.Print(make(chan int)); err.Error() != expectErr { + t.Fatalf("expected error to be:\n%v\n\nbut got:\n%v\n\n", expectErr, err.Error()) + } +} + +func assertPanic(t *testing.T, f func()) { + defer func() { + if r := recover(); r == nil { + t.Errorf("The code did not panic") + } + }() + f() +} +func TestPrintPanic(t *testing.T) { + c := New() unprintable := make(chan int) - require.Panics(t, func() { c.MustPrint(unprintable) }) - require.Panics(t, func() { c.MustPrintMulti(unprintable) }) + assertPanic(t, func() { c.MustPrint(unprintable) }) + assertPanic(t, func() { c.MustPrintMulti(unprintable) }) } func TestBuiltinGout(t *testing.T) { - require.NotPanics(t, func() { MustPrint("foo") }) - require.NotPanics(t, func() { SetWriter(os.Stderr) }) - require.NotPanics(t, func() { SetFormatter(json.Formatter{}) }) - require.NoError(t, Print("foo")) - require.NoError(t, PrintMulti("foo", "bar")) - require.NotPanics(t, func() { MustPrintMulti("foo", "bar") }) - require.NotNil(t, Get()) - - require.NoError(t, SetFormatterString("plain")) - require.EqualError(t, SetFormatterString("never-exists"), "unknown formatter name: never-exists") - require.IsType(t, &plain.Formatter{}, Get().formatter) + var b bytes.Buffer + SetWriter(&b) + MustPrint("foo") + SetFormatter(json.Formatter{}) + + expect := "foo\n" + got := b.String() + if expect != got { + t.Fatalf("expected:\n%v\n\nbut got:\n%v\n\n", expect, got) + } + if err := Print("foo"); err != nil { + t.Fatalf("got unexpected error: %v", err) + } + if err := PrintMulti("foo", "bar"); err != nil { + t.Fatalf("got unexpected error: %v", err) + } + MustPrintMulti("foo", "bar") + + if Get() == nil { + t.Fatalf("got nil from Get()") + } + + if err := SetFormatterString("plain"); err != nil { + t.Fatalf("got unexpected error: %v", err) + } + + expectErr := "unknown formatter name: never-exists" + if err := SetFormatterString("never-exists"); err.Error() != expectErr { + t.Fatalf("expected error '%v', but got '%v'", expectErr, err) + } } func TestWriterPrinterMulti(t *testing.T) { c := New() var buf bytes.Buffer c.SetWriter(&buf) - require.NoError(t, c.PrintMulti( + if err := c.PrintMulti( struct{ Foo string }{Foo: "bar"}, struct{ Year int }{Year: 1978}, - )) - require.Equal(t, "- foo: bar\n- year: 1978\n", buf.String()) + ); err != nil { + t.Fatalf("got unexpected error: %v", err) + } + expect := "- foo: bar\n- year: 1978\n" + got := buf.String() + if expect != got { + t.Fatalf("expected %v but got %v", expect, got) + } } func TestWriterAddNewlines(t *testing.T) { @@ -88,5 +138,7 @@ func TestWriterAddNewlines(t *testing.T) { var buf bytes.Buffer c.SetWriter(&buf) c.Print(struct{ Foo string }{Foo: "bar"}) - require.True(t, strings.HasSuffix(buf.String(), "\n"), "Printer did not have a linebreak suffix") + if !strings.HasSuffix(buf.String(), "\n") { + t.Fatal("Print did not have a linebreak suffix") + } }