From d7d0e111d72e999997ba44c6df3175e1d5ec87ba Mon Sep 17 00:00:00 2001 From: Dan Anglin Date: Thu, 30 May 2024 09:44:59 +0100 Subject: [PATCH] use hash maps instead of switch statements --- internal/model/const.go | 5 ++ internal/model/status.go | 109 -------------------------- internal/model/status_content_type.go | 55 +++++++++++++ internal/model/status_visibility.go | 83 ++++++++++++++++++++ 4 files changed, 143 insertions(+), 109 deletions(-) create mode 100644 internal/model/const.go create mode 100644 internal/model/status_content_type.go create mode 100644 internal/model/status_visibility.go diff --git a/internal/model/const.go b/internal/model/const.go new file mode 100644 index 0000000..c794dcc --- /dev/null +++ b/internal/model/const.go @@ -0,0 +1,5 @@ +package model + +const ( + unknownValue = "unknown" +) diff --git a/internal/model/status.go b/internal/model/status.go index 279c329..011dca8 100644 --- a/internal/model/status.go +++ b/internal/model/status.go @@ -1,7 +1,6 @@ package model import ( - "encoding/json" "fmt" "time" @@ -196,111 +195,3 @@ func (s Status) String() string { s.URL, ) } - -type StatusVisibility int - -const ( - StatusVisibilityPublic StatusVisibility = iota - StatusVisibilityPrivate - StatusVisibilityUnlisted - StatusVisibilityMutualsOnly - StatusVisibilityDirect - StatusVisibilityUnknown -) - -func (s StatusVisibility) String() string { - switch s { - case StatusVisibilityPublic: - return "public" - case StatusVisibilityPrivate: - return "private" - case StatusVisibilityUnlisted: - return "unlisted" - case StatusVisibilityMutualsOnly: - return "mutuals_only" - case StatusVisibilityDirect: - return "direct" - } - - return "unknown" -} - -func ParseStatusVisibility(value string) StatusVisibility { - switch value { - case "public": - return StatusVisibilityPublic - case "private": - return StatusVisibilityPrivate - case "unlisted": - return StatusVisibilityUnlisted - case "mutuals_only": - return StatusVisibilityMutualsOnly - case "direct": - return StatusVisibilityDirect - } - - return StatusVisibilityUnknown -} - -func (s StatusVisibility) MarshalJSON() ([]byte, error) { - value := s.String() - if value == "unknown" { - return nil, fmt.Errorf("%q is not a valid status visibility", value) - } - - return json.Marshal(value) -} - -func (s *StatusVisibility) UnmarshalJSON(data []byte) error { - var ( - value string - err error - ) - - if err = json.Unmarshal(data, &value); err != nil { - return fmt.Errorf("unable to unmarshal the data; %w", err) - } - - *s = ParseStatusVisibility(value) - - return nil -} - -type StatusContentType int - -const ( - StatusContentTypePlainText StatusContentType = iota - StatusContentTypeMarkdown - StatusContentTypeUnknown -) - -func (s StatusContentType) String() string { - switch s { - case StatusContentTypePlainText: - return "text/plain" - case StatusContentTypeMarkdown: - return "text/markdown" - } - - return "unknown" -} - -func ParseStatusContentType(value string) StatusContentType { - switch value { - case "plain", "text/plain": - return StatusContentTypePlainText - case "markdown", "text/markdown": - return StatusContentTypeMarkdown - } - - return StatusContentTypeUnknown -} - -func (s StatusContentType) MarshalJSON() ([]byte, error) { - value := s.String() - if value == "unknown" { - return nil, fmt.Errorf("%q is not a valid status content type", value) - } - - return json.Marshal(value) -} diff --git a/internal/model/status_content_type.go b/internal/model/status_content_type.go new file mode 100644 index 0000000..121c848 --- /dev/null +++ b/internal/model/status_content_type.go @@ -0,0 +1,55 @@ +package model + +import ( + "encoding/json" + "fmt" +) + +type StatusContentType int + +const ( + StatusContentTypePlainText StatusContentType = iota + StatusContentTypeMarkdown + StatusContentTypeUnknown +) + +const ( + statusContentTypeTextPlainValue = "text/plain" + statusContentTypePlainValue = "plain" + statusContentTypeTextMarkdownValue = "text/markdown" + statusContentTypeMarkdownValue = "markdown" +) + +func (s StatusContentType) String() string { + mapped := map[StatusContentType]string{ + StatusContentTypeMarkdown: statusContentTypeTextMarkdownValue, + StatusContentTypePlainText: statusContentTypeTextPlainValue, + } + + output, ok := mapped[s] + if !ok { + return unknownValue + } + + return output +} + +func ParseStatusContentType(value string) StatusContentType { + switch value { + case statusContentTypePlainValue, statusContentTypeTextPlainValue: + return StatusContentTypePlainText + case statusContentTypeMarkdownValue, statusContentTypeTextMarkdownValue: + return StatusContentTypeMarkdown + } + + return StatusContentTypeUnknown +} + +func (s StatusContentType) MarshalJSON() ([]byte, error) { + value := s.String() + if value == unknownValue { + return nil, fmt.Errorf("%q is not a valid status content type", value) + } + + return json.Marshal(value) +} diff --git a/internal/model/status_visibility.go b/internal/model/status_visibility.go new file mode 100644 index 0000000..125b788 --- /dev/null +++ b/internal/model/status_visibility.go @@ -0,0 +1,83 @@ +package model + +import ( + "encoding/json" + "fmt" +) + +type StatusVisibility int + +const ( + StatusVisibilityPublic StatusVisibility = iota + StatusVisibilityPrivate + StatusVisibilityUnlisted + StatusVisibilityMutualsOnly + StatusVisibilityDirect + StatusVisibilityUnknown +) + +const ( + statusVisibilityPublicValue = "public" + statusVisibilityPrivateValue = "private" + statusVisibilityUnlistedValue = "unlisted" + statusVisibilityMutualsOnlyValue = "mutuals_only" + statusVisibilityDirectValue = "direct" +) + +func (s StatusVisibility) String() string { + mapped := map[StatusVisibility]string{ + StatusVisibilityPublic: statusVisibilityPublicValue, + StatusVisibilityPrivate: statusVisibilityPrivateValue, + StatusVisibilityUnlisted: statusVisibilityUnlistedValue, + StatusVisibilityMutualsOnly: statusVisibilityMutualsOnlyValue, + StatusVisibilityDirect: statusVisibilityDirectValue, + } + + output, ok := mapped[s] + if !ok { + return unknownValue + } + + return output +} + +func ParseStatusVisibility(value string) StatusVisibility { + mapped := map[string]StatusVisibility{ + statusVisibilityPublicValue: StatusVisibilityPublic, + statusVisibilityPrivateValue: StatusVisibilityPrivate, + statusVisibilityUnlistedValue: StatusVisibilityUnlisted, + statusVisibilityMutualsOnlyValue: StatusVisibilityMutualsOnly, + statusVisibilityDirectValue: StatusVisibilityDirect, + } + + output, ok := mapped[value] + if !ok { + return StatusVisibilityUnknown + } + + return output +} + +func (s StatusVisibility) MarshalJSON() ([]byte, error) { + value := s.String() + if value == unknownValue { + return nil, fmt.Errorf("%q is not a valid status visibility", value) + } + + return json.Marshal(value) +} + +func (s *StatusVisibility) UnmarshalJSON(data []byte) error { + var ( + value string + err error + ) + + if err = json.Unmarshal(data, &value); err != nil { + return fmt.Errorf("unable to unmarshal the data; %w", err) + } + + *s = ParseStatusVisibility(value) + + return nil +}