create an enum type for status content type

internal/client/statuses.go

@@ -25,42 +25,20 @@ func (g *Client) GetStatus(statusID string) (model.Status, error) {
 	return status, nil
 }
 
-func (g *Client) CreateStatus(
-	content,
-	contentType,
-	language,
-	spoilerText string,
-	boostable,
-	federated,
-	likeable,
-	replyable,
-	sensitive bool,
-	visibility model.StatusVisibility,
-) (model.Status, error) {
-	form := struct {
-		ContentType string                 `json:"content_type"`
+type CreateStatusForm struct {
+	Content     string                  `json:"status"`
 	Language    string                  `json:"language"`
 	SpoilerText string                  `json:"spoiler_text"`
-		Status      string                 `json:"status"`
 	Boostable   bool                    `json:"boostable"`
 	Federated   bool                    `json:"federated"`
 	Likeable    bool                    `json:"likeable"`
 	Replyable   bool                    `json:"replyable"`
 	Sensitive   bool                    `json:"sensitive"`
+	ContentType model.StatusContentType `json:"content_type"`
 	Visibility  model.StatusVisibility  `json:"visibility"`
-	}{
-		ContentType: contentType,
-		Language:    language,
-		SpoilerText: spoilerText,
-		Status:      content,
-		Boostable:   boostable,
-		Federated:   federated,
-		Likeable:    likeable,
-		Sensitive:   sensitive,
-		Replyable:   replyable,
-		Visibility:  visibility,
 }
 
+func (g *Client) CreateStatus(form CreateStatusForm) (model.Status, error) {
 	data, err := json.Marshal(form)
 	if err != nil {
 		return model.Status{}, fmt.Errorf("unable to create the JSON form; %w", err)

internal/executor/create.go

@@ -40,7 +40,7 @@ func NewCreateExecutor(tlf TopLevelFlags, name, summary string) *CreateExecutor
 	createExe.BoolVar(&createExe.replyable, flagReplyable, true, "specify if the status can be replied to")
 	createExe.BoolVar(&createExe.sensitive, flagSensitive, false, "specify if the status should be marked as sensitive")
 	createExe.StringVar(&createExe.content, flagContent, "", "the content of the status to create")
-	createExe.StringVar(&createExe.contentType, flagContentType, "text/plain", "the type that the contents should be parsed from (valid values are plain and markdown)")
+	createExe.StringVar(&createExe.contentType, flagContentType, "plain", "the type that the contents should be parsed from (valid values are plain and markdown)")
 	createExe.StringVar(&createExe.language, flagLanguage, "", "the ISO 639 language code for this status")
 	createExe.StringVar(&createExe.spoilerText, flagSpoilerText, "", "the text to display as the status' warning or subject")
 	createExe.StringVar(&createExe.visibility, flagVisibility, "", "the visibility of the posted status")
@@ -126,21 +126,28 @@ func (c *CreateExecutor) createStatus(gtsClient *client.Client) error {
 
 	parsedVisibility := model.ParseStatusVisibility(visibility)
 	if parsedVisibility == model.StatusVisibilityUnknown {
-		return fmt.Errorf("invalid status visibility %q", visibility)
+		return InvalidStatusVisibilityError{Visibility: visibility}
 	}
 
-	status, err := gtsClient.CreateStatus(
-		c.content,
-		c.contentType,
-		language,
-		c.spoilerText,
-		c.boostable,
-		c.federated,
-		c.likeable,
-		c.replyable,
-		c.sensitive,
-		parsedVisibility,
-	)
+	parsedContentType := model.ParseStatusContentType(c.contentType)
+	if parsedContentType == model.StatusContentTypeUnknown {
+		return InvalidStatusContentTypeError{ContentType: c.contentType}
+	}
+
+	form := client.CreateStatusForm{
+		Content:     c.content,
+		ContentType: parsedContentType,
+		Language:    language,
+		SpoilerText: c.spoilerText,
+		Boostable:   c.boostable,
+		Federated:   c.federated,
+		Likeable:    c.likeable,
+		Replyable:   c.replyable,
+		Sensitive:   c.sensitive,
+		Visibility:  parsedVisibility,
+	}
+
+	status, err := gtsClient.CreateStatus(form)
 	if err != nil {
 		return fmt.Errorf("unable to create the status; %w", err)
 	}

internal/executor/errors.go

@@ -53,3 +53,19 @@ type EmptyContentError struct{}
 func (e EmptyContentError) Error() string {
 	return "content should not be empty"
 }
+
+type InvalidStatusVisibilityError struct {
+	Visibility string
+}
+
+func (e InvalidStatusVisibilityError) Error() string {
+	return "'" + e.Visibility + "' is an invalid status visibility (valid values are public, unlisted, private, mutuals_only and direct)"
+}
+
+type InvalidStatusContentTypeError struct {
+	ContentType string
+}
+
+func (e InvalidStatusContentTypeError) Error() string {
+	return "'" + e.ContentType + "' is an invalid status content type (valid values are plain and markdown)"
+}

internal/model/status.go

@@ -225,8 +225,8 @@ func (s StatusVisibility) String() string {
 	return "unknown"
 }
 
-func ParseStatusVisibility(visibility string) StatusVisibility {
-	switch visibility {
+func ParseStatusVisibility(value string) StatusVisibility {
+	switch value {
 	case "public":
 		return StatusVisibilityPublic
 	case "private":
@@ -265,3 +265,42 @@ func (s *StatusVisibility) UnmarshalJSON(data []byte) error {
 
 	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)
+}