project: refactoring

Author: Lapp

README.md

@@ -1,6 +1,6 @@
 # GetPocket API Golang SDK
 
-[![Release](https://img.shields.io/badge/release-v1.0.3-blue)](https://github.com/Lapp-coder/go-pocket-sdk/releases)
+[![Release](https://img.shields.io/badge/release-v1.0.4-blue)](https://github.com/Lapp-coder/go-pocket-sdk/releases)
 
 ### The basis of the package was made on code from [this](https://github.com/zhashkevych/go-pocket-sdk) repository.
 

README_RU.md

@@ -1,6 +1,6 @@
 # GetPocket API Golang SDK
 
-[![Release](https://img.shields.io/badge/release-v1.0.3-blue)](https://github.com/Lapp-coder/go-pocket-sdk/releases)
+[![Release](https://img.shields.io/badge/release-v1.0.4-blue)](https://github.com/Lapp-coder/go-pocket-sdk/releases)
 
 ### Основа пакета была сделана на коде из [этого](https://github.com/zhashkevych/go-pocket-sdk) репозитория.
 

errors.go

@@ -0,0 +1,16 @@
+package go_pocket_sdk
+
+import (
+	"fmt"
+)
+
+var (
+	ErrEmptyConsumerKey            = fmt.Errorf("empty consumer key")
+	ErrEmptyRequestToken           = fmt.Errorf("empty request token")
+	ErrEmptyAccessToken            = fmt.Errorf("empty access token")
+	ErrEmptyRedirectURL            = fmt.Errorf("empty redirect URL")
+	ErrEmptyRequestTokenInResponse = fmt.Errorf("empty request token in API response")
+	ErrEmptyItemURL                = fmt.Errorf("empty URL for add item")
+	ErrNoActions                   = fmt.Errorf("no actions to modify items")
+	ErrFailedToParseInputBody      = fmt.Errorf("failed to parse input body")
+)

input.go

@@ -1,7 +1,6 @@
 package go_pocket_sdk
 
 import (
-	"errors"
 	"strings"
 )
 
@@ -11,7 +10,7 @@ type AddInput struct {
 	URL         string
 	Title       string
 	Tags        []string
-	TweetId     string
+	TweetID     string
 }
 
 // ModifyInput contains the data needed to modify items in the Pocket list
@@ -36,59 +35,59 @@ type RetrievingInput struct {
 	Offset      int
 }
 
-func (ai AddInput) generateRequest(consumerKey string) (requestAdd, error) {
-	if ai.AccessToken == "" {
-		return requestAdd{}, errors.New("empty access token")
+func (i AddInput) generateRequest(consumerKey string) (requestAdd, error) {
+	if i.AccessToken == "" {
+		return requestAdd{}, ErrEmptyAccessToken
 	}
 
-	if ai.URL == "" {
-		return requestAdd{}, errors.New("empty URL")
+	if i.URL == "" {
+		return requestAdd{}, ErrEmptyItemURL
 	}
 
 	return requestAdd{
 		ConsumerKey: consumerKey,
-		AccessToken: ai.AccessToken,
-		URL:         ai.URL,
-		Title:       ai.Title,
-		Tags:        strings.Join(ai.Tags, ", "),
-		TweetId:     ai.TweetId,
+		AccessToken: i.AccessToken,
+		URL:         i.URL,
+		Title:       i.Title,
+		Tags:        strings.Join(i.Tags, ", "),
+		TweetID:     i.TweetID,
 	}, nil
 }
 
-func (mi ModifyInput) generateRequest(consumerKey string) (requestModify, error) {
-	if mi.AccessToken == "" {
-		return requestModify{}, errors.New("empty access token")
+func (i ModifyInput) generateRequest(consumerKey string) (requestModify, error) {
+	if i.AccessToken == "" {
+		return requestModify{}, ErrEmptyAccessToken
 	}
 
-	if len(mi.Actions) == 0 {
-		return requestModify{}, errors.New("no actions to modify")
+	if len(i.Actions) == 0 {
+		return requestModify{}, ErrNoActions
 	}
 
 	return requestModify{
 		ConsumerKey: consumerKey,
-		AccessToken: mi.AccessToken,
-		Actions:     mi.Actions,
+		AccessToken: i.AccessToken,
+		Actions:     i.Actions,
 	}, nil
 }
 
-func (ri RetrievingInput) generateRequest(consumerKey string) (requestRetrieving, error) {
-	if ri.AccessToken == "" {
-		return requestRetrieving{}, errors.New("empty access token")
+func (i RetrievingInput) generateRequest(consumerKey string) (requestRetrieving, error) {
+	if i.AccessToken == "" {
+		return requestRetrieving{}, ErrEmptyAccessToken
 	}
 
 	return requestRetrieving{
 		ConsumerKey: consumerKey,
-		AccessToken: ri.AccessToken,
-		State:       ri.State,
-		Favorite:    ri.Favorite,
-		Tag:         ri.Tag,
-		ContentType: ri.ContentType,
-		Sort:        ri.Sort,
-		DetailType:  ri.DetailType,
-		Search:      ri.Search,
-		Domain:      ri.Domain,
-		Since:       ri.Since,
-		Count:       ri.Count,
-		Offset:      ri.Offset,
+		AccessToken: i.AccessToken,
+		State:       i.State,
+		Favorite:    i.Favorite,
+		Tag:         i.Tag,
+		ContentType: i.ContentType,
+		Sort:        i.Sort,
+		DetailType:  i.DetailType,
+		Search:      i.Search,
+		Domain:      i.Domain,
+		Since:       i.Since,
+		Count:       i.Count,
+		Offset:      i.Offset,
 	}, nil
 }

pocket.go

@@ -38,7 +38,7 @@ type Client struct {
 // NewClient creates a new client with your application key (to generate a key, create your application here: https://getpocket.com/developer/apps)
 func NewClient(consumerKey string) (*Client, error) {
 	if consumerKey == "" {
-		return nil, fmt.Errorf("empty consumer key")
+		return nil, ErrEmptyConsumerKey
 	}
 
 	return &Client{
@@ -83,13 +83,13 @@ func (c *Client) Retrieving(ctx context.Context, input RetrievingInput) ([]Item,
 		return nil, err
 	}
 
-	return c.getItems(result), nil
+	return c.parseItems(result), nil
 }
 
-func (c *Client) getItems(result gjson.Result) []Item {
+func (c *Client) parseItems(result gjson.Result) []Item {
 	var items []Item
 	for itemID := range result.Get("list").Map() {
-		item := newItem(itemID)
+		item := Item{ID: itemID}
 		item.fillAllFields(result)
 		items = append(items, item)
 	}
@@ -100,7 +100,7 @@ func (c *Client) getItems(result gjson.Result) []Item {
 // Authorize returns the Authorization structure with the access token, username and state obtained from the authorization request
 func (c *Client) Authorize(ctx context.Context, requestToken string) (Authorization, error) {
 	if requestToken == "" {
-		return Authorization{}, fmt.Errorf("empty request token")
+		return Authorization{}, ErrEmptyRequestToken
 	}
 
 	body := requestAuthorization{
@@ -118,7 +118,7 @@ func (c *Client) Authorize(ctx context.Context, requestToken string) (Authorizat
 	state := result.Get("state").String()
 
 	if accessToken == "" {
-		return Authorization{}, fmt.Errorf("empty access token in API response")
+		return Authorization{}, ErrEmptyAccessToken
 	}
 
 	return Authorization{
@@ -131,11 +131,11 @@ func (c *Client) Authorize(ctx context.Context, requestToken string) (Authorizat
 // GetAuthorizationURL returns the url string that is used to grant the user access rights to his Pocket account in your application
 func (c Client) GetAuthorizationURL(requestToken string) (string, error) {
 	if requestToken == "" {
-		return "", fmt.Errorf("empty request token")
+		return "", ErrEmptyRequestToken
 	}
 
 	if c.redirectURL == "" {
-		return "", fmt.Errorf("empty redirection URL")
+		return "", ErrEmptyRedirectURL
 	}
 
 	return fmt.Sprintf(authorizeUrl, requestToken, c.redirectURL), nil
@@ -146,7 +146,7 @@ func (c Client) GetAuthorizationURL(requestToken string) (string, error) {
 // State - metadata string that will be returned at each subsequent authentication response (if you don't need it, specify an empty string).
 func (c *Client) GetRequestToken(ctx context.Context, redirectURL string, state string) (string, error) {
 	if redirectURL == "" {
-		return "", fmt.Errorf("empty redirect URL")
+		return "", ErrEmptyRedirectURL
 	}
 
 	c.redirectURL = redirectURL
@@ -164,7 +164,7 @@ func (c *Client) GetRequestToken(ctx context.Context, redirectURL string, state
 
 	token := result.Get("code").String()
 	if token == "" {
-		return "", fmt.Errorf("empty request token in API response")
+		return "", ErrEmptyRequestTokenInResponse
 	}
 
 	return token, nil
@@ -173,20 +173,20 @@ func (c *Client) GetRequestToken(ctx context.Context, redirectURL string, state
 func (c *Client) doHTTP(ctx context.Context, endpoint string, body interface{}) (gjson.Result, error) {
 	b, err := json.Marshal(body)
 	if err != nil {
-		return gjson.Result{}, fmt.Errorf("an error occurred when marshal the input body: %s", err.Error())
+		return gjson.Result{}, fmt.Errorf("error occurred when marshal the input body: %s", err.Error())
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "POST", host+endpoint, bytes.NewBufferString(string(b)))
 	if err != nil {
-		return gjson.Result{}, fmt.Errorf("an error occurred when creating the query: %s", err.Error())
+		return gjson.Result{}, fmt.Errorf("error occurred when creating the query: %s", err.Error())
 	}
 
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
 	req.Header.Set("X-Accept", "application/json")
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return gjson.Result{}, fmt.Errorf("an error occurred when sending a request to the Pocket server: %s", err.Error())
+		return gjson.Result{}, fmt.Errorf("error occurred when sending a request to the Pocket server: %s", err.Error())
 	}
 	defer resp.Body.Close()
 
@@ -196,12 +196,12 @@ func (c *Client) doHTTP(ctx context.Context, endpoint string, body interface{})
 
 	respBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return gjson.Result{}, fmt.Errorf("an error occurred when reading the request body: %s", err.Error())
+		return gjson.Result{}, fmt.Errorf("error occurred when reading the request body: %s", err.Error())
 	}
 
 	result := gjson.Parse(string(respBody))
 	if result.String() == "" {
-		return gjson.Result{}, fmt.Errorf("failed to parse response body")
+		return gjson.Result{}, ErrFailedToParseInputBody
 	}
 
 	return result, nil