kYT{Kw;5hKY|9`ek
f;?Qr3k^%k?%ZYU~@jNX_00000NkvXXu0mjf9u0TR
literal 0
HcmV?d00001
diff --git a/internal/media/util.go b/internal/media/util.go
index 9ffb79a..64d1ee7 100644
--- a/internal/media/util.go
+++ b/internal/media/util.go
@@ -70,6 +70,36 @@ func supportedImageType(mimeType string) bool {
return false
}
+// supportedVideoType checks mime type of a video against a slice of accepted types,
+// and returns True if the mime type is accepted.
+func supportedVideoType(mimeType string) bool {
+ acceptedVideoTypes := []string{
+ "video/mp4",
+ "video/mpeg",
+ "video/webm",
+ }
+ for _, accepted := range acceptedVideoTypes {
+ if mimeType == accepted {
+ return true
+ }
+ }
+ return false
+}
+
+// supportedEmojiType checks that the content type is image/png -- the only type supported for emoji.
+func supportedEmojiType(mimeType string) bool {
+ acceptedEmojiTypes := []string{
+ "image/gif",
+ "image/png",
+ }
+ for _, accepted := range acceptedEmojiTypes {
+ if mimeType == accepted {
+ return true
+ }
+ }
+ return false
+}
+
// purgeExif is a little wrapper for the action of removing exif data from an image.
// Only pass pngs or jpegs to this function.
func purgeExif(b []byte) ([]byte, error) {
@@ -87,23 +117,12 @@ func purgeExif(b []byte) ([]byte, error) {
return clean, nil
}
-func deriveImage(b []byte, extension string) (*imageAndMeta, error) {
- var i image.Image
+func deriveGif(b []byte, extension string) (*imageAndMeta, error) {
+ var g *gif.GIF
var err error
-
switch extension {
- case "image/jpeg":
- i, err = jpeg.Decode(bytes.NewReader(b))
- if err != nil {
- return nil, err
- }
- case "image/png":
- i, err = png.Decode(bytes.NewReader(b))
- if err != nil {
- return nil, err
- }
case "image/gif":
- i, err = gif.Decode(bytes.NewReader(b))
+ g, err = gif.DecodeAll(bytes.NewReader(b))
if err != nil {
return nil, err
}
@@ -111,19 +130,22 @@ func deriveImage(b []byte, extension string) (*imageAndMeta, error) {
return nil, fmt.Errorf("extension %s not recognised", extension)
}
- width := i.Bounds().Size().X
- height := i.Bounds().Size().Y
+ // use the first frame to get the static characteristics
+ width := g.Config.Width
+ height := g.Config.Height
size := width * height
aspect := float64(width) / float64(height)
- bh, err := blurhash.Encode(4, 3, i)
- if err != nil {
- return nil, fmt.Errorf("error generating blurhash: %s", err)
+
+ bh, err := blurhash.Encode(4, 3, g.Image[0])
+ if err != nil || bh == "" {
+ return nil, err
}
out := &bytes.Buffer{}
- if err := jpeg.Encode(out, i, nil); err != nil {
+ if err := gif.EncodeAll(out, g); err != nil {
return nil, err
}
+
return &imageAndMeta{
image: out.Bytes(),
width: width,
@@ -134,16 +156,60 @@ func deriveImage(b []byte, extension string) (*imageAndMeta, error) {
}, nil
}
-// deriveThumbnailFromImage returns a byte slice and metadata for a 256-pixel-width thumbnail
-// of a given jpeg, png, or gif, or an error if something goes wrong.
-//
-// Note that the aspect ratio of the image will be retained,
-// so it will not necessarily be a square.
-func deriveThumbnail(b []byte, extension string) (*imageAndMeta, error) {
+func deriveImage(b []byte, contentType string) (*imageAndMeta, error) {
var i image.Image
var err error
- switch extension {
+ switch contentType {
+ case "image/jpeg":
+ i, err = jpeg.Decode(bytes.NewReader(b))
+ if err != nil {
+ return nil, err
+ }
+ case "image/png":
+ i, err = png.Decode(bytes.NewReader(b))
+ if err != nil {
+ return nil, err
+ }
+ default:
+ return nil, fmt.Errorf("content type %s not recognised", contentType)
+ }
+
+ width := i.Bounds().Size().X
+ height := i.Bounds().Size().Y
+ size := width * height
+ aspect := float64(width) / float64(height)
+
+ bh, err := blurhash.Encode(4, 3, i)
+ if err != nil {
+ return nil, err
+ }
+
+ out := &bytes.Buffer{}
+ if err := jpeg.Encode(out, i, nil); err != nil {
+ return nil, err
+ }
+
+ return &imageAndMeta{
+ image: out.Bytes(),
+ width: width,
+ height: height,
+ size: size,
+ aspect: aspect,
+ blurhash: bh,
+ }, nil
+}
+
+// deriveThumbnail returns a byte slice and metadata for a thumbnail of width x and height y,
+// of a given jpeg, png, or gif, or an error if something goes wrong.
+//
+// Note that the aspect ratio of the image will be retained,
+// so it will not necessarily be a square, even if x and y are set as the same value.
+func deriveThumbnail(b []byte, contentType string, x uint, y uint) (*imageAndMeta, error) {
+ var i image.Image
+ var err error
+
+ switch contentType {
case "image/jpeg":
i, err = jpeg.Decode(bytes.NewReader(b))
if err != nil {
@@ -160,10 +226,10 @@ func deriveThumbnail(b []byte, extension string) (*imageAndMeta, error) {
return nil, err
}
default:
- return nil, fmt.Errorf("extension %s not recognised", extension)
+ return nil, fmt.Errorf("content type %s not recognised", contentType)
}
- thumb := resize.Thumbnail(256, 256, i, resize.NearestNeighbor)
+ thumb := resize.Thumbnail(x, y, i, resize.NearestNeighbor)
width := thumb.Bounds().Size().X
height := thumb.Bounds().Size().Y
size := width * height
@@ -182,6 +248,35 @@ func deriveThumbnail(b []byte, extension string) (*imageAndMeta, error) {
}, nil
}
+// deriveStaticEmojji takes a given gif or png of an emoji, decodes it, and re-encodes it as a static png.
+func deriveStaticEmoji(b []byte, contentType string) (*imageAndMeta, error) {
+ var i image.Image
+ var err error
+
+ switch contentType {
+ case "image/png":
+ i, err = png.Decode(bytes.NewReader(b))
+ if err != nil {
+ return nil, err
+ }
+ case "image/gif":
+ i, err = gif.Decode(bytes.NewReader(b))
+ if err != nil {
+ return nil, err
+ }
+ default:
+ return nil, fmt.Errorf("content type %s not allowed for emoji", contentType)
+ }
+
+ out := &bytes.Buffer{}
+ if err := png.Encode(out, i); err != nil {
+ return nil, err
+ }
+ return &imageAndMeta{
+ image: out.Bytes(),
+ }, nil
+}
+
type imageAndMeta struct {
image []byte
width int
diff --git a/internal/media/util_test.go b/internal/media/util_test.go
index f24c166..be617a2 100644
--- a/internal/media/util_test.go
+++ b/internal/media/util_test.go
@@ -121,7 +121,7 @@ func (suite *MediaUtilTestSuite) TestDeriveThumbnailFromJPEG() {
assert.Nil(suite.T(), err)
// clean it up and validate the clean version
- imageAndMeta, err := deriveThumbnail(b, "image/jpeg")
+ imageAndMeta, err := deriveThumbnail(b, "image/jpeg", 256, 256)
assert.Nil(suite.T(), err)
assert.Equal(suite.T(), 256, imageAndMeta.width)
diff --git a/internal/oauth/server.go b/internal/oauth/server.go
index 8bac8fc..5382889 100644
--- a/internal/oauth/server.go
+++ b/internal/oauth/server.go
@@ -26,7 +26,7 @@ import (
"github.com/gin-gonic/gin"
"github.com/sirupsen/logrus"
"github.com/superseriousbusiness/gotosocial/internal/db"
- "github.com/superseriousbusiness/gotosocial/internal/db/model"
+ "github.com/superseriousbusiness/gotosocial/internal/db/gtsmodel"
"github.com/superseriousbusiness/oauth2/v4"
"github.com/superseriousbusiness/oauth2/v4/errors"
"github.com/superseriousbusiness/oauth2/v4/manage"
@@ -34,6 +34,9 @@ import (
)
const (
+ // SessionAuthorizedToken is the key set in the gin context for the Token
+ // of a User who has successfully passed Bearer token authorization.
+ // The interface returned from grabbing this key should be parsed as oauth2.TokenInfo
SessionAuthorizedToken = "authorized_token"
// SessionAuthorizedUser is the key set in the gin context for the id of
// a User who has successfully passed Bearer token authorization.
@@ -65,9 +68,9 @@ type s struct {
type Authed struct {
Token oauth2.TokenInfo
- Application *model.Application
- User *model.User
- Account *model.Account
+ Application *gtsmodel.Application
+ User *gtsmodel.User
+ Account *gtsmodel.Account
}
// GetAuthed is a convenience function for returning an Authed struct from a gin context.
@@ -96,7 +99,7 @@ func GetAuthed(c *gin.Context) (*Authed, error) {
i, ok = ctx.Get(SessionAuthorizedApplication)
if ok {
- parsed, ok := i.(*model.Application)
+ parsed, ok := i.(*gtsmodel.Application)
if !ok {
return nil, errors.New("could not parse application from session context")
}
@@ -105,7 +108,7 @@ func GetAuthed(c *gin.Context) (*Authed, error) {
i, ok = ctx.Get(SessionAuthorizedUser)
if ok {
- parsed, ok := i.(*model.User)
+ parsed, ok := i.(*gtsmodel.User)
if !ok {
return nil, errors.New("could not parse user from session context")
}
@@ -114,7 +117,7 @@ func GetAuthed(c *gin.Context) (*Authed, error) {
i, ok = ctx.Get(SessionAuthorizedAccount)
if ok {
- parsed, ok := i.(*model.Account)
+ parsed, ok := i.(*gtsmodel.Account)
if !ok {
return nil, errors.New("could not parse account from session context")
}
diff --git a/internal/oauth/tokenstore.go b/internal/oauth/tokenstore.go
index c4c9ff1..14caa65 100644
--- a/internal/oauth/tokenstore.go
+++ b/internal/oauth/tokenstore.go
@@ -98,7 +98,7 @@ func (pts *tokenStore) Create(ctx context.Context, info oauth2.TokenInfo) error
if !ok {
return errors.New("info param was not a models.Token")
}
- if err := pts.db.Put(oauthTokenToPGToken(t)); err != nil {
+ if err := pts.db.Put(OAuthTokenToPGToken(t)); err != nil {
return fmt.Errorf("error in tokenstore create: %s", err)
}
return nil
@@ -130,7 +130,7 @@ func (pts *tokenStore) GetByCode(ctx context.Context, code string) (oauth2.Token
if err := pts.db.GetWhere("code", code, pgt); err != nil {
return nil, err
}
- return pgTokenToOauthToken(pgt), nil
+ return PGTokenToOauthToken(pgt), nil
}
// GetByAccess selects a token from the DB based on the Access field
@@ -144,7 +144,7 @@ func (pts *tokenStore) GetByAccess(ctx context.Context, access string) (oauth2.T
if err := pts.db.GetWhere("access", access, pgt); err != nil {
return nil, err
}
- return pgTokenToOauthToken(pgt), nil
+ return PGTokenToOauthToken(pgt), nil
}
// GetByRefresh selects a token from the DB based on the Refresh field
@@ -158,7 +158,7 @@ func (pts *tokenStore) GetByRefresh(ctx context.Context, refresh string) (oauth2
if err := pts.db.GetWhere("refresh", refresh, pgt); err != nil {
return nil, err
}
- return pgTokenToOauthToken(pgt), nil
+ return PGTokenToOauthToken(pgt), nil
}
/*
@@ -194,8 +194,8 @@ type Token struct {
RefreshExpiresAt time.Time `pg:"type:timestamp"`
}
-// oauthTokenToPGToken is a lil util function that takes a gotosocial token and gives back a token for inserting into postgres
-func oauthTokenToPGToken(tkn *models.Token) *Token {
+// OAuthTokenToPGToken is a lil util function that takes a gotosocial token and gives back a token for inserting into postgres
+func OAuthTokenToPGToken(tkn *models.Token) *Token {
now := time.Now()
// For the following, we want to make sure we're not adding a time.Now() to an *empty* ExpiresIn, otherwise that's
@@ -236,8 +236,8 @@ func oauthTokenToPGToken(tkn *models.Token) *Token {
}
}
-// pgTokenToOauthToken is a lil util function that takes a postgres token and gives back a gotosocial token
-func pgTokenToOauthToken(pgt *Token) *models.Token {
+// PGTokenToOauthToken is a lil util function that takes a postgres token and gives back a gotosocial token
+func PGTokenToOauthToken(pgt *Token) *models.Token {
now := time.Now()
return &models.Token{
diff --git a/internal/router/router.go b/internal/router/router.go
index ce924b2..7ab208e 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -83,7 +83,17 @@ func (r *router) AttachMiddleware(middleware gin.HandlerFunc) {
// New returns a new Router with the specified configuration, using the given logrus logger.
func New(config *config.Config, logger *logrus.Logger) (Router, error) {
- engine := gin.New()
+ lvl, err := logrus.ParseLevel(config.LogLevel)
+ if err != nil {
+ return nil, fmt.Errorf("couldn't parse log level %s to set router level: %s", config.LogLevel, err)
+ }
+ switch lvl {
+ case logrus.TraceLevel, logrus.DebugLevel:
+ gin.SetMode(gin.DebugMode)
+ default:
+ gin.SetMode(gin.ReleaseMode)
+ }
+ engine := gin.Default()
// create a new session store middleware
store, err := sessionStore()
diff --git a/internal/storage/inmem.go b/internal/storage/inmem.go
index 25432fb..2d88189 100644
--- a/internal/storage/inmem.go
+++ b/internal/storage/inmem.go
@@ -7,25 +7,49 @@ import (
"github.com/superseriousbusiness/gotosocial/internal/config"
)
+// NewInMem returns an in-memory implementation of the Storage interface.
+// This is good for testing and whatnot but ***SHOULD ABSOLUTELY NOT EVER
+// BE USED IN A PRODUCTION SETTING***, because A) everything will be wiped out
+// if you restart the server and B) if you store lots of images your RAM use
+// will absolutely go through the roof.
func NewInMem(c *config.Config, log *logrus.Logger) (Storage, error) {
return &inMemStorage{
stored: make(map[string][]byte),
+ log: log,
}, nil
}
type inMemStorage struct {
stored map[string][]byte
+ log *logrus.Logger
}
func (s *inMemStorage) StoreFileAt(path string, data []byte) error {
+ l := s.log.WithField("func", "StoreFileAt")
+ l.Debugf("storing at path %s", path)
s.stored[path] = data
return nil
}
func (s *inMemStorage) RetrieveFileFrom(path string) ([]byte, error) {
+ l := s.log.WithField("func", "RetrieveFileFrom")
+ l.Debugf("retrieving from path %s", path)
d, ok := s.stored[path]
if !ok {
return nil, fmt.Errorf("no data found at path %s", path)
}
return d, nil
}
+
+func (s *inMemStorage) ListKeys() ([]string, error) {
+ keys := []string{}
+ for k := range s.stored {
+ keys = append(keys, k)
+ }
+ return keys, nil
+}
+
+func (s *inMemStorage) RemoveFileAt(path string) error {
+ delete(s.stored, path)
+ return nil
+}
diff --git a/internal/storage/local.go b/internal/storage/local.go
index 29461d5..3b64524 100644
--- a/internal/storage/local.go
+++ b/internal/storage/local.go
@@ -1,21 +1,70 @@
package storage
import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+
"github.com/sirupsen/logrus"
"github.com/superseriousbusiness/gotosocial/internal/config"
)
+// NewLocal returns an implementation of the Storage interface that uses
+// the local filesystem for storing and retrieving files, attachments, etc.
func NewLocal(c *config.Config, log *logrus.Logger) (Storage, error) {
- return &localStorage{}, nil
+ return &localStorage{
+ config: c,
+ log: log,
+ }, nil
}
type localStorage struct {
+ config *config.Config
+ log *logrus.Logger
}
func (s *localStorage) StoreFileAt(path string, data []byte) error {
+ l := s.log.WithField("func", "StoreFileAt")
+ l.Debugf("storing at path %s", path)
+ components := strings.Split(path, "/")
+ dir := strings.Join(components[0:len(components)-1], "/")
+ if err := os.MkdirAll(dir, 0777); err != nil {
+ return fmt.Errorf("error writing file at %s: %s", path, err)
+ }
+ if err := os.WriteFile(path, data, 0777); err != nil {
+ return fmt.Errorf("error writing file at %s: %s", path, err)
+ }
return nil
}
func (s *localStorage) RetrieveFileFrom(path string) ([]byte, error) {
- return nil, nil
+ l := s.log.WithField("func", "RetrieveFileFrom")
+ l.Debugf("retrieving from path %s", path)
+ b, err := os.ReadFile(path)
+ if err != nil {
+ return nil, fmt.Errorf("error reading file at %s: %s", path, err)
+ }
+ return b, nil
+}
+
+func (s *localStorage) ListKeys() ([]string, error) {
+ keys := []string{}
+ err := filepath.Walk(s.config.StorageConfig.BasePath, func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ if !info.IsDir() {
+ keys = append(keys, path)
+ }
+ return nil
+ })
+ if err != nil {
+ return nil, err
+ }
+ return keys, nil
+}
+
+func (s *localStorage) RemoveFileAt(path string) error {
+ return os.Remove(path)
}
diff --git a/internal/storage/mock_Storage.go b/internal/storage/mock_Storage.go
index 865d522..2444f03 100644
--- a/internal/storage/mock_Storage.go
+++ b/internal/storage/mock_Storage.go
@@ -9,6 +9,43 @@ type MockStorage struct {
mock.Mock
}
+// ListKeys provides a mock function with given fields:
+func (_m *MockStorage) ListKeys() ([]string, error) {
+ ret := _m.Called()
+
+ var r0 []string
+ if rf, ok := ret.Get(0).(func() []string); ok {
+ r0 = rf()
+ } else {
+ if ret.Get(0) != nil {
+ r0 = ret.Get(0).([]string)
+ }
+ }
+
+ var r1 error
+ if rf, ok := ret.Get(1).(func() error); ok {
+ r1 = rf()
+ } else {
+ r1 = ret.Error(1)
+ }
+
+ return r0, r1
+}
+
+// RemoveFileAt provides a mock function with given fields: path
+func (_m *MockStorage) RemoveFileAt(path string) error {
+ ret := _m.Called(path)
+
+ var r0 error
+ if rf, ok := ret.Get(0).(func(string) error); ok {
+ r0 = rf(path)
+ } else {
+ r0 = ret.Error(0)
+ }
+
+ return r0
+}
+
// RetrieveFileFrom provides a mock function with given fields: path
func (_m *MockStorage) RetrieveFileFrom(path string) ([]byte, error) {
ret := _m.Called(path)
diff --git a/internal/storage/storage.go b/internal/storage/storage.go
index fa884ed..409c90b 100644
--- a/internal/storage/storage.go
+++ b/internal/storage/storage.go
@@ -16,9 +16,15 @@
along with this program. If not, see .
*/
+// Package storage contains an interface and implementations for storing and retrieving files and attachments.
package storage
+// Storage is an interface for storing and retrieving blobs
+// such as images, videos, and any other attachments/documents
+// that shouldn't be stored in a database.
type Storage interface {
StoreFileAt(path string, data []byte) error
RetrieveFileFrom(path string) ([]byte, error)
+ ListKeys() ([]string, error)
+ RemoveFileAt(path string) error
}
diff --git a/internal/util/parse.go b/internal/util/parse.go
index 375ab97..f0bcff5 100644
--- a/internal/util/parse.go
+++ b/internal/util/parse.go
@@ -1,32 +1,96 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
package util
-import "fmt"
+import (
+ "fmt"
+ "github.com/superseriousbusiness/gotosocial/internal/db/gtsmodel"
+ mastotypes "github.com/superseriousbusiness/gotosocial/internal/mastotypes/mastomodel"
+)
+
+// URIs contains a bunch of URIs and URLs for a user, host, account, etc.
type URIs struct {
- HostURL string
- UserURL string
+ HostURL string
+ UserURL string
+ StatusesURL string
+
UserURI string
- InboxURL string
- OutboxURL string
- FollowersURL string
- CollectionURL string
+ StatusesURI string
+ InboxURI string
+ OutboxURI string
+ FollowersURI string
+ CollectionURI string
}
+// GenerateURIs throws together a bunch of URIs for the given username, with the given protocol and host.
func GenerateURIs(username string, protocol string, host string) *URIs {
hostURL := fmt.Sprintf("%s://%s", protocol, host)
userURL := fmt.Sprintf("%s/@%s", hostURL, username)
+ statusesURL := fmt.Sprintf("%s/statuses", userURL)
+
userURI := fmt.Sprintf("%s/users/%s", hostURL, username)
- inboxURL := fmt.Sprintf("%s/inbox", userURI)
- outboxURL := fmt.Sprintf("%s/outbox", userURI)
- followersURL := fmt.Sprintf("%s/followers", userURI)
- collectionURL := fmt.Sprintf("%s/collections/featured", userURI)
+ statusesURI := fmt.Sprintf("%s/statuses", userURI)
+ inboxURI := fmt.Sprintf("%s/inbox", userURI)
+ outboxURI := fmt.Sprintf("%s/outbox", userURI)
+ followersURI := fmt.Sprintf("%s/followers", userURI)
+ collectionURI := fmt.Sprintf("%s/collections/featured", userURI)
return &URIs{
- HostURL: hostURL,
- UserURL: userURL,
+ HostURL: hostURL,
+ UserURL: userURL,
+ StatusesURL: statusesURL,
+
UserURI: userURI,
- InboxURL: inboxURL,
- OutboxURL: outboxURL,
- FollowersURL: followersURL,
- CollectionURL: collectionURL,
+ StatusesURI: statusesURI,
+ InboxURI: inboxURI,
+ OutboxURI: outboxURI,
+ FollowersURI: followersURI,
+ CollectionURI: collectionURI,
}
}
+
+// ParseGTSVisFromMastoVis converts a mastodon visibility into its gts equivalent.
+func ParseGTSVisFromMastoVis(m mastotypes.Visibility) gtsmodel.Visibility {
+ switch m {
+ case mastotypes.VisibilityPublic:
+ return gtsmodel.VisibilityPublic
+ case mastotypes.VisibilityUnlisted:
+ return gtsmodel.VisibilityUnlocked
+ case mastotypes.VisibilityPrivate:
+ return gtsmodel.VisibilityFollowersOnly
+ case mastotypes.VisibilityDirect:
+ return gtsmodel.VisibilityDirect
+ }
+ return ""
+}
+
+// ParseMastoVisFromGTSVis converts a gts visibility into its mastodon equivalent
+func ParseMastoVisFromGTSVis(m gtsmodel.Visibility) mastotypes.Visibility {
+ switch m {
+ case gtsmodel.VisibilityPublic:
+ return mastotypes.VisibilityPublic
+ case gtsmodel.VisibilityUnlocked:
+ return mastotypes.VisibilityUnlisted
+ case gtsmodel.VisibilityFollowersOnly, gtsmodel.VisibilityMutualsOnly:
+ return mastotypes.VisibilityPrivate
+ case gtsmodel.VisibilityDirect:
+ return mastotypes.VisibilityDirect
+ }
+ return ""
+}
diff --git a/internal/util/regexes.go b/internal/util/regexes.go
new file mode 100644
index 0000000..60b397d
--- /dev/null
+++ b/internal/util/regexes.go
@@ -0,0 +1,36 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package util
+
+import "regexp"
+
+var (
+ // mention regex can be played around with here: https://regex101.com/r/qwM9D3/1
+ mentionRegexString = `(?: |^|\W)(@[a-zA-Z0-9_]+(?:@[a-zA-Z0-9_\-\.]+)?)(?: |\n)`
+ mentionRegex = regexp.MustCompile(mentionRegexString)
+ // hashtag regex can be played with here: https://regex101.com/r/Vhy8pg/1
+ hashtagRegexString = `(?: |^|\W)?#([a-zA-Z0-9]{1,30})(?:\b|\r)`
+ hashtagRegex = regexp.MustCompile(hashtagRegexString)
+ // emoji regex can be played with here: https://regex101.com/r/478XGM/1
+ emojiRegexString = `(?: |^|\W)?:([a-zA-Z0-9_]{2,30}):(?:\b|\r)?`
+ emojiRegex = regexp.MustCompile(emojiRegexString)
+ // emoji shortcode regex can be played with here: https://regex101.com/r/zMDRaG/1
+ emojiShortcodeString = `^[a-z0-9_]{2,30}$`
+ emojiShortcodeRegex = regexp.MustCompile(emojiShortcodeString)
+)
diff --git a/internal/util/status.go b/internal/util/status.go
new file mode 100644
index 0000000..e4b3ec6
--- /dev/null
+++ b/internal/util/status.go
@@ -0,0 +1,96 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package util
+
+import (
+ "strings"
+)
+
+// DeriveMentions takes a plaintext (ie., not html-formatted) status,
+// and applies a regex to it to return a deduplicated list of accounts
+// mentioned in that status.
+//
+// It will look for fully-qualified account names in the form "@user@example.org".
+// or the form "@username" for local users.
+// The case of the returned mentions will be lowered, for consistency.
+func DeriveMentions(status string) []string {
+ mentionedAccounts := []string{}
+ for _, m := range mentionRegex.FindAllStringSubmatch(status, -1) {
+ mentionedAccounts = append(mentionedAccounts, m[1])
+ }
+ return Lower(Unique(mentionedAccounts))
+}
+
+// DeriveHashtags takes a plaintext (ie., not html-formatted) status,
+// and applies a regex to it to return a deduplicated list of hashtags
+// used in that status, without the leading #. The case of the returned
+// tags will be lowered, for consistency.
+func DeriveHashtags(status string) []string {
+ tags := []string{}
+ for _, m := range hashtagRegex.FindAllStringSubmatch(status, -1) {
+ tags = append(tags, m[1])
+ }
+ return Lower(Unique(tags))
+}
+
+// DeriveEmojis takes a plaintext (ie., not html-formatted) status,
+// and applies a regex to it to return a deduplicated list of emojis
+// used in that status, without the surround ::. The case of the returned
+// emojis will be lowered, for consistency.
+func DeriveEmojis(status string) []string {
+ emojis := []string{}
+ for _, m := range emojiRegex.FindAllStringSubmatch(status, -1) {
+ emojis = append(emojis, m[1])
+ }
+ return Lower(Unique(emojis))
+}
+
+// Unique returns a deduplicated version of a given string slice.
+func Unique(s []string) []string {
+ keys := make(map[string]bool)
+ list := []string{}
+ for _, entry := range s {
+ if _, value := keys[entry]; !value {
+ keys[entry] = true
+ list = append(list, entry)
+ }
+ }
+ return list
+}
+
+// Lower lowercases all strings in a given string slice
+func Lower(s []string) []string {
+ new := []string{}
+ for _, i := range s {
+ new = append(new, strings.ToLower(i))
+ }
+ return new
+}
+
+// HTMLFormat takes a plaintext formatted status string, and converts it into
+// a nice HTML-formatted string.
+//
+// This includes:
+// - Replacing line-breaks with
+// - Replacing URLs with hrefs.
+// - Replacing mentions with links to that account's URL as stored in the database.
+func HTMLFormat(status string) string {
+ // TODO: write proper HTML formatting logic for a status
+ return status
+}
diff --git a/internal/util/status_test.go b/internal/util/status_test.go
new file mode 100644
index 0000000..72bd3e8
--- /dev/null
+++ b/internal/util/status_test.go
@@ -0,0 +1,105 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package util
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/suite"
+)
+
+type StatusTestSuite struct {
+ suite.Suite
+}
+
+func (suite *StatusTestSuite) TestDeriveMentionsOK() {
+ statusText := `@dumpsterqueer@example.org testing testing
+
+ is this thing on?
+
+ @someone_else@testing.best-horse.com can you confirm? @hello@test.lgbt
+
+ @thisisalocaluser ! @NORWILL@THIS.one!!
+
+ here is a duplicate mention: @hello@test.lgbt
+ `
+
+ menchies := DeriveMentions(statusText)
+ assert.Len(suite.T(), menchies, 4)
+ assert.Equal(suite.T(), "@dumpsterqueer@example.org", menchies[0])
+ assert.Equal(suite.T(), "@someone_else@testing.best-horse.com", menchies[1])
+ assert.Equal(suite.T(), "@hello@test.lgbt", menchies[2])
+ assert.Equal(suite.T(), "@thisisalocaluser", menchies[3])
+}
+
+func (suite *StatusTestSuite) TestDeriveMentionsEmpty() {
+ statusText := ``
+ menchies := DeriveMentions(statusText)
+ assert.Len(suite.T(), menchies, 0)
+}
+
+func (suite *StatusTestSuite) TestDeriveHashtagsOK() {
+ statusText := `#testing123 #also testing
+
+# testing this one shouldn't work
+
+ #thisshouldwork
+
+#ThisShouldAlsoWork #not_this_though
+
+#111111 thisalsoshouldn'twork#### ##`
+
+ tags := DeriveHashtags(statusText)
+ assert.Len(suite.T(), tags, 5)
+ assert.Equal(suite.T(), "testing123", tags[0])
+ assert.Equal(suite.T(), "also", tags[1])
+ assert.Equal(suite.T(), "thisshouldwork", tags[2])
+ assert.Equal(suite.T(), "thisshouldalsowork", tags[3])
+ assert.Equal(suite.T(), "111111", tags[4])
+}
+
+func (suite *StatusTestSuite) TestDeriveEmojiOK() {
+ statusText := `:test: :another:
+
+Here's some normal text with an :emoji: at the end
+
+:spaces shouldnt work:
+
+:emoji1::emoji2:
+
+:anotheremoji:emoji2:
+:anotheremoji::anotheremoji::anotheremoji::anotheremoji:
+:underscores_ok_too:
+`
+
+ tags := DeriveEmojis(statusText)
+ assert.Len(suite.T(), tags, 7)
+ assert.Equal(suite.T(), "test", tags[0])
+ assert.Equal(suite.T(), "another", tags[1])
+ assert.Equal(suite.T(), "emoji", tags[2])
+ assert.Equal(suite.T(), "emoji1", tags[3])
+ assert.Equal(suite.T(), "emoji2", tags[4])
+ assert.Equal(suite.T(), "anotheremoji", tags[5])
+ assert.Equal(suite.T(), "underscores_ok_too", tags[6])
+}
+
+func TestStatusTestSuite(t *testing.T) {
+ suite.Run(t, new(StatusTestSuite))
+}
diff --git a/internal/util/validation.go b/internal/util/validation.go
index 88a5687..8102bc3 100644
--- a/internal/util/validation.go
+++ b/internal/util/validation.go
@@ -142,3 +142,13 @@ func ValidatePrivacy(privacy string) error {
// TODO: add some validation logic here -- length, characters, etc
return nil
}
+
+// ValidateEmojiShortcode just runs the given shortcode through the regular expression
+// for emoji shortcodes, to figure out whether it's a valid shortcode, ie., 2-30 characters,
+// lowercase a-z, numbers, and underscores.
+func ValidateEmojiShortcode(shortcode string) error {
+ if !emojiShortcodeRegex.MatchString(shortcode) {
+ return fmt.Errorf("shortcode %s did not pass validation, must be between 2 and 30 characters, lowercase letters, numbers, and underscores only", shortcode)
+ }
+ return nil
+}
diff --git a/scripts/auth_flow.sh b/scripts/auth_flow.sh
index 8bba395..5552349 100755
--- a/scripts/auth_flow.sh
+++ b/scripts/auth_flow.sh
@@ -5,10 +5,9 @@ set -eux
SERVER_URL="http://localhost:8080"
REDIRECT_URI="${SERVER_URL}"
CLIENT_NAME="Test Application Name"
-
REGISTRATION_REASON="Testing whether or not this dang diggity thing works!"
-REGISTRATION_EMAIL="test@example.org"
-REGISTRATION_USERNAME="test_user"
+REGISTRATION_USERNAME="${1}"
+REGISTRATION_EMAIL="${2}"
REGISTRATION_PASSWORD="very safe password 123"
REGISTRATION_AGREEMENT="true"
REGISTRATION_LOCALE="en"
diff --git a/testrig/actions.go b/testrig/actions.go
new file mode 100644
index 0000000..1caa185
--- /dev/null
+++ b/testrig/actions.go
@@ -0,0 +1,125 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package testrig
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/sirupsen/logrus"
+ "github.com/superseriousbusiness/gotosocial/internal/action"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/account"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/admin"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/app"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/auth"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/fileserver"
+ mediaModule "github.com/superseriousbusiness/gotosocial/internal/apimodule/media"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/security"
+ "github.com/superseriousbusiness/gotosocial/internal/apimodule/status"
+ "github.com/superseriousbusiness/gotosocial/internal/cache"
+ "github.com/superseriousbusiness/gotosocial/internal/config"
+ "github.com/superseriousbusiness/gotosocial/internal/federation"
+ "github.com/superseriousbusiness/gotosocial/internal/gotosocial"
+)
+
+// Run creates and starts a gotosocial testrig server
+var Run action.GTSAction = func(ctx context.Context, _ *config.Config, log *logrus.Logger) error {
+ dbService := NewTestDB()
+ router := NewTestRouter()
+ storageBackend := NewTestStorage()
+ mediaHandler := NewTestMediaHandler(dbService, storageBackend)
+ oauthServer := NewTestOauthServer(dbService)
+ distributor := NewTestDistributor()
+ if err := distributor.Start(); err != nil {
+ return fmt.Errorf("error starting distributor: %s", err)
+ }
+ mastoConverter := NewTestMastoConverter(dbService)
+
+ c := NewTestConfig()
+
+ StandardDBSetup(dbService)
+ StandardStorageSetup(storageBackend, "./testrig/media")
+
+ // build client api modules
+ authModule := auth.New(oauthServer, dbService, log)
+ accountModule := account.New(c, dbService, oauthServer, mediaHandler, mastoConverter, log)
+ appsModule := app.New(oauthServer, dbService, mastoConverter, log)
+ mm := mediaModule.New(dbService, mediaHandler, mastoConverter, c, log)
+ fileServerModule := fileserver.New(c, dbService, storageBackend, log)
+ adminModule := admin.New(c, dbService, mediaHandler, mastoConverter, log)
+ statusModule := status.New(c, dbService, mediaHandler, mastoConverter, distributor, log)
+ securityModule := security.New(c, log)
+
+ apiModules := []apimodule.ClientAPIModule{
+ // modules with middleware go first
+ securityModule,
+ authModule,
+
+ // now everything else
+ accountModule,
+ appsModule,
+ mm,
+ fileServerModule,
+ adminModule,
+ statusModule,
+ }
+
+ for _, m := range apiModules {
+ if err := m.Route(router); err != nil {
+ return fmt.Errorf("routing error: %s", err)
+ }
+ if err := m.CreateTables(dbService); err != nil {
+ return fmt.Errorf("table creation error: %s", err)
+ }
+ }
+
+ // if err := dbService.CreateInstanceAccount(); err != nil {
+ // return fmt.Errorf("error creating instance account: %s", err)
+ // }
+
+ gts, err := gotosocial.New(dbService, &cache.MockCache{}, router, federation.New(dbService, log), c)
+ if err != nil {
+ return fmt.Errorf("error creating gotosocial service: %s", err)
+ }
+
+ if err := gts.Start(ctx); err != nil {
+ return fmt.Errorf("error starting gotosocial service: %s", err)
+ }
+
+ // catch shutdown signals from the operating system
+ sigs := make(chan os.Signal, 1)
+ signal.Notify(sigs, os.Interrupt, syscall.SIGTERM)
+ sig := <-sigs
+ log.Infof("received signal %s, shutting down", sig)
+
+ StandardDBTeardown(dbService)
+ StandardStorageTeardown(storageBackend)
+
+ // close down all running services in order
+ if err := gts.Stop(ctx); err != nil {
+ return fmt.Errorf("error closing gotosocial service: %s", err)
+ }
+
+ log.Info("done! exiting...")
+ return nil
+}
diff --git a/testrig/config.go b/testrig/config.go
new file mode 100644
index 0000000..f7028b1
--- /dev/null
+++ b/testrig/config.go
@@ -0,0 +1,26 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package testrig
+
+import "github.com/superseriousbusiness/gotosocial/internal/config"
+
+// NewTestConfig returns a config initialized with test defaults
+func NewTestConfig() *config.Config {
+ return config.TestDefault()
+}
diff --git a/testrig/db.go b/testrig/db.go
new file mode 100644
index 0000000..5974eae
--- /dev/null
+++ b/testrig/db.go
@@ -0,0 +1,144 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package testrig
+
+import (
+ "context"
+
+ "github.com/sirupsen/logrus"
+ "github.com/superseriousbusiness/gotosocial/internal/db"
+ "github.com/superseriousbusiness/gotosocial/internal/db/gtsmodel"
+ "github.com/superseriousbusiness/gotosocial/internal/oauth"
+)
+
+var testModels []interface{} = []interface{}{
+ >smodel.Account{},
+ >smodel.Application{},
+ >smodel.Block{},
+ >smodel.DomainBlock{},
+ >smodel.EmailDomainBlock{},
+ >smodel.Follow{},
+ >smodel.FollowRequest{},
+ >smodel.MediaAttachment{},
+ >smodel.Mention{},
+ >smodel.Status{},
+ >smodel.StatusFave{},
+ >smodel.StatusBookmark{},
+ >smodel.StatusMute{},
+ >smodel.StatusPin{},
+ >smodel.Tag{},
+ >smodel.User{},
+ >smodel.Emoji{},
+ &oauth.Token{},
+ &oauth.Client{},
+}
+
+// NewTestDB returns a new initialized, empty database for testing
+func NewTestDB() db.DB {
+ config := NewTestConfig()
+ l := logrus.New()
+ l.SetLevel(logrus.TraceLevel)
+ testDB, err := db.New(context.Background(), config, l)
+ if err != nil {
+ panic(err)
+ }
+ return testDB
+}
+
+// StandardDBSetup populates a given db with all the necessary tables/models for perfoming tests.
+func StandardDBSetup(db db.DB) {
+ for _, m := range testModels {
+ if err := db.CreateTable(m); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestTokens() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestClients() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestApplications() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestUsers() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestAccounts() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestAttachments() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestStatuses() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestEmojis() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestTags() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ for _, v := range NewTestFaves() {
+ if err := db.Put(v); err != nil {
+ panic(err)
+ }
+ }
+
+ if err := db.CreateInstanceAccount(); err != nil {
+ panic(err)
+ }
+}
+
+// StandardDBTeardown drops all the standard testing tables/models from the database to ensure it's clean for the next test.
+func StandardDBTeardown(db db.DB) {
+ for _, m := range testModels {
+ if err := db.DropTable(m); err != nil {
+ panic(err)
+ }
+ }
+}
diff --git a/testrig/distributor.go b/testrig/distributor.go
new file mode 100644
index 0000000..e21321d
--- /dev/null
+++ b/testrig/distributor.go
@@ -0,0 +1,25 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package testrig
+
+import "github.com/superseriousbusiness/gotosocial/internal/distributor"
+
+func NewTestDistributor() distributor.Distributor {
+ return distributor.New(NewTestLog())
+}
diff --git a/testrig/log.go b/testrig/log.go
new file mode 100644
index 0000000..0bafc96
--- /dev/null
+++ b/testrig/log.go
@@ -0,0 +1,28 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package testrig
+
+import "github.com/sirupsen/logrus"
+
+// NewTestLog returns a trace level logger for testing
+func NewTestLog() *logrus.Logger {
+ log := logrus.New()
+ log.SetLevel(logrus.TraceLevel)
+ return log
+}
diff --git a/testrig/mastoconverter.go b/testrig/mastoconverter.go
new file mode 100644
index 0000000..10bdbdc
--- /dev/null
+++ b/testrig/mastoconverter.go
@@ -0,0 +1,29 @@
+/*
+ GoToSocial
+ Copyright (C) 2021 GoToSocial Authors admin@gotosocial.org
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+*/
+
+package testrig
+
+import (
+ "github.com/superseriousbusiness/gotosocial/internal/db"
+ "github.com/superseriousbusiness/gotosocial/internal/mastotypes"
+)
+
+// NewTestMastoConverter returned a mastotypes converter with the given db and the default test config
+func NewTestMastoConverter(db db.DB) mastotypes.Converter {
+ return mastotypes.New(NewTestConfig(), db)
+}
diff --git a/testrig/media/ohyou-original.jpeg b/testrig/media/ohyou-original.jpeg
new file mode 100755
index 0000000000000000000000000000000000000000..3499651607f3359b20366c1af75a786bfa30cfe1
GIT binary patch
literal 27759
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
p1Xwt8AnnXt@zVYXJEv{E0+!O;ERKBo3
z@RH*rb1@|Cezq>P_Flh(b_e-t!>{s$3J57yHlKxo^1T$8<+DB%%UJw$!{H?dk9R=?
z4#i){+j?5M#~}+F7Lxil*=n+fH#1y6u*nV;f`_^y>Ry`MD6!+vfOqGADr
z<#dU;j!C%I_B&7wz$DyVzRSLi;mVnAtAGJCcuFE;sPz?a|K%XbXcEuo#+dk`lg=~|
zPZ2&57?)qj2BfL(gr(LAqWtxzn%x93*JnQdeP`GFFH_mw+2{KL+iP&mwEo|=%_H?wkZIgeRi6#GUtd$Zbi^LK-YvO)f=DOV{&(8>v{Uk-IHgJQ^J^*1H`v?
zr9B)Qxj6)nf19|aR1Z~|$M_KotwdYv?Y8?cRupp9Za1>S>D|FMj|OgK?;oDLo*ha3
z+!DQj_u1oO(d;W2nmbDtFeKk3>zOuJReL~rE2sLy{Q0wFmzU`PoJTcFmHHYIveKE0
zmhoh%$xy##G_5F+W2#13S~XIx#F5s*7ZKc@B5YW**IeW_%EPGLO8*Vp)ts<
zHrod74uDCYoC*ArHAp8DlB_dTJb7d_!rZ_VX{jzrKM-W(;$2hV3l_+$<=K+Y^e%Mn
zKH(}AC?v|cKiM&xo$KO+E!oHRf*zhfA*^*wOp-GDpiHn?m)w8X5nbr4p!v#mcoIS95HK*h-|BlvYK9gF8>wCx&wJzHty$A+Grg(h*$%gJvF&mwL5`Ou<&ihu
zJ@;w>lV){G{d_2eAl)inYZZ)v4bRB(HXPj`j&p8_4qmrDU{O_h<2en^5WyOB&i_gp
zM`IAGz$(T596Z!9OF^B%%JQRCF)K#%~h=e%eZJ36PKo^o;bv;qIMS@#f=2}_vDkm2lSph3g9blyB!Vw>yNVH!_gV5x=UIs8>8bXh1?
zRKAi%vb~`&HW6nR*XUfjYDkIx!e3T;!#HNzW>D)nLgM$cS?gR*)*y!h(FJ?@XZKA>
zKNj{EUNqk#J%pSl;P_QysO$8