furrybb: an experimental #furry boost bot

35 files changed, 5471 insertions, 0 deletions

diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/account.go b/mastodon/furrybb/vendor/github.com/McKael/madon/account.go
new file mode 100644
index 0000000..e96aa59
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/account.go
@@ -0,0 +1,430 @@
+/*
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/sendgrid/rest"
+)
+
+// getAccountsOptions contains option fields for POST and DELETE API calls
+type getAccountsOptions struct {
+	// The ID is used for most commands
+	ID int
+
+	// The following fields are used when searching for accounts
+	Q     string
+	Limit int
+}
+
+// getSingleAccount returns an account entity
+// The operation 'op' can be "account", "verify_credentials", "follow",
+// "unfollow", "block", "unblock", "mute", "unmute",
+// "follow_requests/authorize" or // "follow_requests/reject".
+// The id is optional and depends on the operation.
+func (mc *Client) getSingleAccount(op string, id int) (*Account, error) {
+	var endPoint string
+	method := rest.Get
+	strID := strconv.Itoa(id)
+
+	switch op {
+	case "account":
+		endPoint = "accounts/" + strID
+	case "verify_credentials":
+		endPoint = "accounts/verify_credentials"
+	case "follow", "unfollow", "block", "unblock", "mute", "unmute":
+		endPoint = "accounts/" + strID + "/" + op
+		method = rest.Post
+	case "follow_requests/authorize", "follow_requests/reject":
+		// The documentation is incorrect, the endpoint actually
+		// is "follow_requests/:id/{authorize|reject}"
+		endPoint = op[:16] + strID + "/" + op[16:]
+		method = rest.Post
+	default:
+		return nil, ErrInvalidParameter
+	}
+
+	var account Account
+	if err := mc.apiCall(endPoint, method, nil, &account); err != nil {
+		return nil, err
+	}
+	return &account, nil
+}
+
+// getMultipleAccounts returns a list of account entities
+// The operation 'op' can be "followers", "following", "search", "blocks",
+// "mutes", "follow_requests".
+// The id is optional and depends on the operation.
+func (mc *Client) getMultipleAccounts(op string, opts *getAccountsOptions) ([]Account, error) {
+	var endPoint string
+
+	switch op {
+	case "followers", "following":
+		if opts == nil || opts.ID < 1 {
+			return []Account{}, ErrInvalidID
+		}
+		endPoint = "accounts/" + strconv.Itoa(opts.ID) + "/" + op
+	case "follow_requests", "blocks", "mutes":
+		endPoint = op
+	case "search":
+		if opts == nil || opts.Q == "" {
+			return []Account{}, ErrInvalidParameter
+		}
+		endPoint = "accounts/" + op
+	default:
+		return nil, ErrInvalidParameter
+	}
+
+	// Handle target-specific query parameters
+	params := make(apiCallParams)
+	if op == "search" {
+		params["q"] = opts.Q
+		if opts.Limit > 0 {
+			params["limit"] = strconv.Itoa(opts.Limit)
+		}
+	}
+
+	var accounts []Account
+	if err := mc.apiCall(endPoint, rest.Get, params, &accounts); err != nil {
+		return nil, err
+	}
+	return accounts, nil
+}
+
+// GetAccount returns an account entity
+// The returned value can be nil if there is an error or if the
+// requested ID does not exist.
+func (mc *Client) GetAccount(accountID int) (*Account, error) {
+	account, err := mc.getSingleAccount("account", accountID)
+	if err != nil {
+		return nil, err
+	}
+	if account != nil && account.ID == 0 {
+		return nil, ErrEntityNotFound
+	}
+	return account, nil
+}
+
+// GetCurrentAccount returns the current user account
+func (mc *Client) GetCurrentAccount() (*Account, error) {
+	account, err := mc.getSingleAccount("verify_credentials", 0)
+	if err != nil {
+		return nil, err
+	}
+	if account != nil && account.ID == 0 {
+		return nil, ErrEntityNotFound
+	}
+	return account, nil
+}
+
+// GetAccountFollowers returns the list of accounts following a given account
+func (mc *Client) GetAccountFollowers(accountID int) ([]Account, error) {
+	o := &getAccountsOptions{ID: accountID}
+	return mc.getMultipleAccounts("followers", o)
+}
+
+// GetAccountFollowing returns the list of accounts a given account is following
+func (mc *Client) GetAccountFollowing(accountID int) ([]Account, error) {
+	o := &getAccountsOptions{ID: accountID}
+	return mc.getMultipleAccounts("following", o)
+}
+
+// FollowAccount follows an account
+func (mc *Client) FollowAccount(accountID int) error {
+	account, err := mc.getSingleAccount("follow", accountID)
+	if err != nil {
+		return err
+	}
+	if account != nil && account.ID != accountID {
+		return ErrEntityNotFound
+	}
+	return nil
+}
+
+// UnfollowAccount unfollows an account
+func (mc *Client) UnfollowAccount(accountID int) error {
+	account, err := mc.getSingleAccount("unfollow", accountID)
+	if err != nil {
+		return err
+	}
+	if account != nil && account.ID != accountID {
+		return ErrEntityNotFound
+	}
+	return nil
+}
+
+// FollowRemoteAccount follows a remote account
+// The parameter 'uri' is a URI (e.mc. "username@domain").
+func (mc *Client) FollowRemoteAccount(uri string) (*Account, error) {
+	if uri == "" {
+		return nil, ErrInvalidID
+	}
+
+	params := make(apiCallParams)
+	params["uri"] = uri
+
+	var account Account
+	if err := mc.apiCall("follows", rest.Post, params, &account); err != nil {
+		return nil, err
+	}
+	if account.ID == 0 {
+		return nil, ErrEntityNotFound
+	}
+	return &account, nil
+}
+
+// BlockAccount blocks an account
+func (mc *Client) BlockAccount(accountID int) error {
+	account, err := mc.getSingleAccount("block", accountID)
+	if err != nil {
+		return err
+	}
+	if account != nil && account.ID != accountID {
+		return ErrEntityNotFound
+	}
+	return nil
+}
+
+// UnblockAccount unblocks an account
+func (mc *Client) UnblockAccount(accountID int) error {
+	account, err := mc.getSingleAccount("unblock", accountID)
+	if err != nil {
+		return err
+	}
+	if account != nil && account.ID != accountID {
+		return ErrEntityNotFound
+	}
+	return nil
+}
+
+// MuteAccount mutes an account
+func (mc *Client) MuteAccount(accountID int) error {
+	account, err := mc.getSingleAccount("mute", accountID)
+	if err != nil {
+		return err
+	}
+	if account != nil && account.ID != accountID {
+		return ErrEntityNotFound
+	}
+	return nil
+}
+
+// UnmuteAccount unmutes an account
+func (mc *Client) UnmuteAccount(accountID int) error {
+	account, err := mc.getSingleAccount("unmute", accountID)
+	if err != nil {
+		return err
+	}
+	if account != nil && account.ID != accountID {
+		return ErrEntityNotFound
+	}
+	return nil
+}
+
+// SearchAccounts returns a list of accounts matching the query string
+// The limit parameter is optional (can be 0).
+func (mc *Client) SearchAccounts(query string, limit int) ([]Account, error) {
+	o := &getAccountsOptions{Q: query, Limit: limit}
+	return mc.getMultipleAccounts("search", o)
+}
+
+// GetBlockedAccounts returns the list of blocked accounts
+func (mc *Client) GetBlockedAccounts() ([]Account, error) {
+	return mc.getMultipleAccounts("blocks", nil)
+}
+
+// GetMutedAccounts returns the list of muted accounts
+func (mc *Client) GetMutedAccounts() ([]Account, error) {
+	return mc.getMultipleAccounts("mutes", nil)
+}
+
+// GetAccountFollowRequests returns the list of follow requests accounts
+func (mc *Client) GetAccountFollowRequests() ([]Account, error) {
+	return mc.getMultipleAccounts("follow_requests", nil)
+}
+
+// GetAccountRelationships returns a list of relationship entities for the given accounts
+func (mc *Client) GetAccountRelationships(accountIDs []int) ([]Relationship, error) {
+	if len(accountIDs) < 1 {
+		return nil, ErrInvalidID
+	}
+
+	params := make(apiCallParams)
+	for i, id := range accountIDs {
+		if id < 1 {
+			return nil, ErrInvalidID
+		}
+		qID := fmt.Sprintf("id[%d]", i+1)
+		params[qID] = strconv.Itoa(id)
+	}
+
+	var rl []Relationship
+	if err := mc.apiCall("accounts/relationships", rest.Get, params, &rl); err != nil {
+		return nil, err
+	}
+	return rl, nil
+}
+
+// GetAccountStatuses returns a list of status entities for the given account
+// If onlyMedia is true, returns only statuses that have media attachments.
+// If excludeReplies is true, skip statuses that reply to other statuses.
+func (mc *Client) GetAccountStatuses(accountID int, onlyMedia, excludeReplies bool) ([]Status, error) {
+	if accountID < 1 {
+		return nil, ErrInvalidID
+	}
+
+	endPoint := "accounts/" + strconv.Itoa(accountID) + "/" + "statuses"
+	params := make(apiCallParams)
+	if onlyMedia {
+		params["only_media"] = "true"
+	}
+	if excludeReplies {
+		params["exclude_replies"] = "true"
+	}
+
+	var sl []Status
+	if err := mc.apiCall(endPoint, rest.Get, params, &sl); err != nil {
+		return nil, err
+	}
+	return sl, nil
+}
+
+// FollowRequestAuthorize authorizes or rejects an account follow-request
+func (mc *Client) FollowRequestAuthorize(accountID int, authorize bool) error {
+	endPoint := "follow_requests/reject"
+	if authorize {
+		endPoint = "follow_requests/authorize"
+	}
+	_, err := mc.getSingleAccount(endPoint, accountID)
+	return err
+}
+
+// UpdateAccount updates the connected user's account data
+// The fields avatar & headerImage can contain base64-encoded images; if
+// they do not (that is; if they don't contain ";base64,"), they are considered
+// as file paths and their content will be encoded.
+// All fields can be nil, in which case they are not updated.
+// displayName and note can be set to "" to delete previous values;
+// I'm not sure images can be deleted -- only replaced AFAICS.
+func (mc *Client) UpdateAccount(displayName, note, avatar, headerImage *string) (*Account, error) {
+	const endPoint = "accounts/update_credentials"
+	params := make(apiCallParams)
+
+	if displayName != nil {
+		params["display_name"] = *displayName
+	}
+	if note != nil {
+		params["note"] = *note
+	}
+
+	var err error
+	avatar, err = fileToBase64(avatar, nil)
+	if err != nil {
+		return nil, err
+	}
+	headerImage, err = fileToBase64(headerImage, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var formBuf bytes.Buffer
+	w := multipart.NewWriter(&formBuf)
+
+	if avatar != nil {
+		w.WriteField("avatar", *avatar)
+	}
+	if headerImage != nil {
+		w.WriteField("header", *headerImage)
+	}
+	w.Close()
+
+	// Prepare the request
+	req, err := mc.prepareRequest(endPoint, rest.Patch, params)
+	if err != nil {
+		return nil, fmt.Errorf("prepareRequest failed: %s", err.Error())
+	}
+	req.Headers["Content-Type"] = w.FormDataContentType()
+	req.Body = formBuf.Bytes()
+
+	// Make API call
+	r, err := restAPI(req)
+	if err != nil {
+		return nil, fmt.Errorf("account update failed: %s", err.Error())
+	}
+
+	// Check for error reply
+	var errorResult Error
+	if err := json.Unmarshal([]byte(r.Body), &errorResult); err == nil {
+		// The empty object is not an error
+		if errorResult.Text != "" {
+			return nil, fmt.Errorf("%s", errorResult.Text)
+		}
+	}
+
+	// Not an error reply; let's unmarshal the data
+	var account Account
+	if err := json.Unmarshal([]byte(r.Body), &account); err != nil {
+		return nil, fmt.Errorf("cannot decode API response: %s", err.Error())
+	}
+	return &account, nil
+}
+
+// fileToBase64 is a helper function to convert a file's contents to
+// base64-encoded data.  Is the data string already contains base64 data, it
+// is not modified.
+// If contentType is nil, it is detected.
+func fileToBase64(data, contentType *string) (*string, error) {
+	if data == nil {
+		return nil, nil
+	}
+
+	if *data == "" {
+		return data, nil
+	}
+
+	if strings.Contains(*data, ";base64,") {
+		return data, nil
+	}
+
+	// We need to convert the file and file name to base64
+
+	file, err := os.Open(*data)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	fStat, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	buffer := make([]byte, fStat.Size())
+	_, err = file.Read(buffer)
+	if err != nil {
+		return nil, err
+	}
+
+	var cType string
+	if contentType == nil || *contentType == "" {
+		cType = http.DetectContentType(buffer[:512])
+	} else {
+		cType = *contentType
+	}
+	contentData := base64.StdEncoding.EncodeToString(buffer)
+	newData := "data:" + cType + ";base64," + contentData
+	return &newData, nil
+}
diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/api.go b/mastodon/furrybb/vendor/github.com/McKael/madon/api.go
new file mode 100644
index 0000000..b232553
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/api.go
@@ -0,0 +1,137 @@
+/*
+Copyright 2017 Ollivier Robert
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/sendgrid/rest"
+)
+
+// restAPI actually does the HTTP query
+// It is a copy of rest.API with better handling of parameters with multiple values
+func restAPI(request rest.Request) (*rest.Response, error) {
+	c := &rest.Client{HTTPClient: http.DefaultClient}
+
+	// Build the HTTP request object.
+	if len(request.QueryParams) != 0 {
+		// Add parameters to the URL
+		request.BaseURL += "?"
+		urlp := url.Values{}
+		for key, value := range request.QueryParams {
+			// It seems Mastodon doesn't like parameters with index
+			// numbers, but it needs the brackets.
+			// Let's check if the key matches '^.+\[.*\]$'
+			klen := len(key)
+			if klen == 0 {
+				continue
+			}
+			i := strings.Index(key, "[")
+			if key[klen-1] == ']' && i > 0 {
+				// This is an array, let's remove the index number
+				key = key[:i] + "[]"
+			}
+			urlp.Add(key, value)
+		}
+		urlpstr := urlp.Encode()
+		request.BaseURL += urlpstr
+	}
+
+	req, err := http.NewRequest(string(request.Method), request.BaseURL, bytes.NewBuffer(request.Body))
+	if err != nil {
+		return nil, err
+	}
+
+	for key, value := range request.Headers {
+		req.Header.Set(key, value)
+	}
+	_, exists := req.Header["Content-Type"]
+	if len(request.Body) > 0 && !exists {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	// Build the HTTP client and make the request.
+	res, err := c.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+
+	// Build Response object.
+	response, err := rest.BuildResponse(res)
+	if err != nil {
+		return nil, err
+	}
+
+	return response, nil
+}
+
+// prepareRequest inserts all pre-defined stuff
+func (mc *Client) prepareRequest(target string, method rest.Method, params apiCallParams) (rest.Request, error) {
+	var req rest.Request
+
+	if mc == nil {
+		return req, ErrUninitializedClient
+	}
+
+	endPoint := mc.APIBase + "/" + target
+
+	// Request headers
+	hdrs := make(map[string]string)
+	hdrs["User-Agent"] = fmt.Sprintf("madon/%s", MadonVersion)
+	if mc.UserToken != nil {
+		hdrs["Authorization"] = fmt.Sprintf("Bearer %s", mc.UserToken.AccessToken)
+	}
+
+	req = rest.Request{
+		BaseURL:     endPoint,
+		Headers:     hdrs,
+		Method:      method,
+		QueryParams: params,
+	}
+	return req, nil
+}
+
+// apiCall makes a call to the Mastodon API server
+func (mc *Client) apiCall(endPoint string, method rest.Method, params apiCallParams, data interface{}) error {
+	if mc == nil {
+		return fmt.Errorf("use of uninitialized madon client")
+	}
+
+	// Prepare query
+	req, err := mc.prepareRequest(endPoint, method, params)
+	if err != nil {
+		return err
+	}
+
+	// Make API call
+	r, err := restAPI(req)
+	if err != nil {
+		return fmt.Errorf("API query (%s) failed: %s", endPoint, err.Error())
+	}
+
+	// Check for error reply
+	var errorResult Error
+	if err := json.Unmarshal([]byte(r.Body), &errorResult); err == nil {
+		// The empty object is not an error
+		if errorResult.Text != "" {
+			return fmt.Errorf("%s", errorResult.Text)
+		}
+	}
+
+	// Not an error reply; let's unmarshal the data
+	err = json.Unmarshal([]byte(r.Body), &data)
+	if err != nil {
+		return fmt.Errorf("cannot decode API response (%s): %s", method, err.Error())
+	}
+	return nil
+}
diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/app.go b/mastodon/furrybb/vendor/github.com/McKael/madon/app.go
new file mode 100644
index 0000000..d890224
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/app.go
@@ -0,0 +1,96 @@
+/*
+Copyright 2017 Ollivier Robert
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"errors"
+	"net/url"
+	"strings"
+
+	"github.com/sendgrid/rest"
+)
+
+type registerApp struct {
+	ID           int    `json:"id"`
+	ClientID     string `json:"client_id"`
+	ClientSecret string `json:"client_secret"`
+}
+
+// buildInstanceURL creates the URL from the instance name or cleans up the
+// provided URL
+func buildInstanceURL(instanceName string) (string, error) {
+	if instanceName == "" {
+		return "", errors.New("no instance provided")
+	}
+
+	instanceURL := instanceName
+	if !strings.Contains(instanceURL, "/") {
+		instanceURL = "https://" + instanceName
+	}
+
+	u, err := url.ParseRequestURI(instanceURL)
+	if err != nil {
+		return "", err
+	}
+
+	u.Path = ""
+	u.RawPath = ""
+	u.RawQuery = ""
+	u.Fragment = ""
+	return u.String(), nil
+}
+
+// NewApp registers a new application with a given instance
+func NewApp(name string, scopes []string, redirectURI, instanceName string) (mc *Client, err error) {
+	instanceURL, err := buildInstanceURL(instanceName)
+	if err != nil {
+		return nil, err
+	}
+
+	mc = &Client{
+		Name:        name,
+		InstanceURL: instanceURL,
+		APIBase:     instanceURL + currentAPIPath,
+	}
+
+	params := make(apiCallParams)
+	params["client_name"] = name
+	params["scopes"] = strings.Join(scopes, " ")
+	if redirectURI != "" {
+		params["redirect_uris"] = redirectURI
+	} else {
+		params["redirect_uris"] = NoRedirect
+	}
+
+	var app registerApp
+	if err := mc.apiCall("apps", rest.Post, params, &app); err != nil {
+		return nil, err
+	}
+
+	mc.ID = app.ClientID
+	mc.Secret = app.ClientSecret
+
+	return
+}
+
+// RestoreApp recreates an application client with existing secrets
+func RestoreApp(name, instanceName, appID, appSecret string, userToken *UserToken) (mc *Client, err error) {
+	instanceURL, err := buildInstanceURL(instanceName)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Client{
+		Name:        name,
+		InstanceURL: instanceURL,
+		APIBase:     instanceURL + currentAPIPath,
+		ID:          appID,
+		Secret:      appSecret,
+		UserToken:   userToken,
+	}, nil
+}
diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/favourites.go b/mastodon/furrybb/vendor/github.com/McKael/madon/favourites.go
new file mode 100644
index 0000000..b8f6754
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/favourites.go
@@ -0,0 +1,21 @@
+/*
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"github.com/sendgrid/rest"
+)
+
+// GetFavourites returns the list of the user's favourites
+func (mc *Client) GetFavourites() ([]Status, error) {
+	var faves []Status
+	err := mc.apiCall("favourites", rest.Get, nil, &faves)
+	if err != nil {
+		return nil, err
+	}
+	return faves, nil
+}
diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/instance.go b/mastodon/furrybb/vendor/github.com/McKael/madon/instance.go
new file mode 100644
index 0000000..ed5d01b
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/instance.go
@@ -0,0 +1,20 @@
+/*
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"github.com/sendgrid/rest"
+)
+
+// GetCurrentInstance returns current instance information
+func (mc *Client) GetCurrentInstance() (*Instance, error) {
+	var i Instance
+	if err := mc.apiCall("instance", rest.Get, nil, &i); err != nil {
+		return nil, err
+	}
+	return &i, nil
+}
diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/login.go b/mastodon/furrybb/vendor/github.com/McKael/madon/login.go
new file mode 100644
index 0000000..1cef1d0
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/login.go
@@ -0,0 +1,88 @@
+/*
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/sendgrid/rest"
+)
+
+// UserToken represents a user token as returned by the Mastodon API
+type UserToken struct {
+	AccessToken string `json:"access_token"`
+	CreatedAt   int    `json:"created_at"`
+	Scope       string `json:"scope"`
+	TokenType   string `json:"token_type"`
+}
+
+// LoginBasic does basic user authentication
+func (mc *Client) LoginBasic(username, password string, scopes []string) error {
+	if mc == nil {
+		return ErrUninitializedClient
+	}
+
+	if username == "" {
+		return fmt.Errorf("missing username")
+	}
+	if password == "" {
+		return fmt.Errorf("missing password")
+	}
+
+	hdrs := make(map[string]string)
+	opts := make(map[string]string)
+
+	hdrs["User-Agent"] = "madon/" + MadonVersion
+
+	opts["grant_type"] = "password"
+	opts["client_id"] = mc.ID
+	opts["client_secret"] = mc.Secret
+	opts["username"] = username
+	opts["password"] = password
+	if len(scopes) > 0 {
+		opts["scope"] = strings.Join(scopes, " ")
+	}
+
+	req := rest.Request{
+		BaseURL:     mc.InstanceURL + "/oauth/token",
+		Headers:     hdrs,
+		QueryParams: opts,
+		Method:      rest.Post,
+	}
+
+	r, err := restAPI(req)
+	if err != nil {
+		return err
+	}
+
+	var resp UserToken
+
+	err = json.Unmarshal([]byte(r.Body), &resp)
+	if err != nil {
+		return fmt.Errorf("cannot unmarshal server response: %s", err.Error())
+	}
+
+	mc.UserToken = &resp
+	return nil
+}
+
+// SetUserToken sets an existing user credentials
+// No verification of the arguments is made.
+func (mc *Client) SetUserToken(token, username, password string, scopes []string) error {
+	if mc == nil {
+		return ErrUninitializedClient
+	}
+
+	mc.UserToken = &UserToken{
+		AccessToken: token,
+		Scope:       strings.Join(scopes, " "),
+		TokenType:   "bearer",
+	}
+	return nil
+}
diff --git a/mastodon/furrybb/vendor/github.com/McKael/madon/madon.go b/mastodon/furrybb/vendor/github.com/McKael/madon/madon.go
new file mode 100644
index 0000000..91109ca
--- /dev/null
+++ b/mastodon/furrybb/vendor/github.com/McKael/madon/madon.go
@@ -0,0 +1,36 @@
+/*
+Copyright 2017 Ollivier Robert
+Copyright 2017 Mikael Berthe
+
+Licensed under the MIT license.  Please see the LICENSE file is this directory.
+*/
+
+package madon
+
+import (
+	"errors"
+)
+
+// apiCallParams is a map with the parameters for an API call
+type apiCallParams map[string]string
+
+const (
+	// MadonVersion contains the version of the Madon library
+	MadonVersi