268 lines
6.0 KiB
Go
268 lines
6.0 KiB
Go
package segments
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/diamondburned/arikawa/discord"
|
|
"github.com/diamondburned/arikawa/state"
|
|
"github.com/diamondburned/cchat/text"
|
|
"github.com/diamondburned/ningen/md"
|
|
"github.com/yuin/goldmark/ast"
|
|
)
|
|
|
|
// NameSegment represents a clickable member name; it does not implement colors.
|
|
type NameSegment struct {
|
|
start, end int
|
|
|
|
guild discord.Guild
|
|
member discord.Member
|
|
}
|
|
|
|
var (
|
|
_ text.Segment = (*NameSegment)(nil)
|
|
_ text.Mentioner = (*NameSegment)(nil)
|
|
)
|
|
|
|
func UserSegment(start, end int, u discord.User) NameSegment {
|
|
return NameSegment{
|
|
start: start,
|
|
end: end,
|
|
member: discord.Member{User: u},
|
|
}
|
|
}
|
|
|
|
func MemberSegment(start, end int, guild discord.Guild, m discord.Member) NameSegment {
|
|
return NameSegment{
|
|
start: start,
|
|
end: end,
|
|
guild: guild,
|
|
member: m,
|
|
}
|
|
}
|
|
|
|
func (m NameSegment) Bounds() (start, end int) {
|
|
return m.start, m.end
|
|
}
|
|
|
|
func (m NameSegment) MentionInfo() text.Rich {
|
|
return userInfo(m.guild, m.member)
|
|
}
|
|
|
|
type MentionSegment struct {
|
|
start, end int
|
|
*md.Mention
|
|
|
|
store state.Store
|
|
guild discord.Snowflake
|
|
}
|
|
|
|
var (
|
|
_ text.Segment = (*MentionSegment)(nil)
|
|
_ text.Colorer = (*MentionSegment)(nil)
|
|
_ text.Mentioner = (*MentionSegment)(nil)
|
|
)
|
|
|
|
func (r *TextRenderer) mention(n *md.Mention, enter bool) ast.WalkStatus {
|
|
if enter {
|
|
var seg = MentionSegment{
|
|
Mention: n,
|
|
store: r.store,
|
|
guild: r.msg.GuildID,
|
|
}
|
|
|
|
switch {
|
|
case n.Channel != nil:
|
|
seg.start, seg.end = r.writeString("#" + n.Channel.Name)
|
|
case n.GuildUser != nil:
|
|
seg.start, seg.end = r.writeString("@" + n.GuildUser.Username)
|
|
case n.GuildRole != nil:
|
|
seg.start, seg.end = r.writeString("@" + n.GuildRole.Name)
|
|
default:
|
|
// Unexpected error; skip.
|
|
return ast.WalkSkipChildren
|
|
}
|
|
|
|
r.append(seg)
|
|
}
|
|
|
|
return ast.WalkContinue
|
|
}
|
|
|
|
func (m MentionSegment) Bounds() (start, end int) {
|
|
return m.start, m.end
|
|
}
|
|
|
|
// Color tries to return the color of the mention segment, or it returns the
|
|
// usual blurple if none.
|
|
func (m MentionSegment) Color() (color uint32) {
|
|
// Try digging through what we have for a color.
|
|
switch {
|
|
case m.GuildUser != nil && m.GuildUser.Member != nil:
|
|
g, err := m.store.Guild(m.guild)
|
|
if err != nil {
|
|
return blurple
|
|
}
|
|
|
|
color = discord.MemberColor(*g, *m.GuildUser.Member).Uint32()
|
|
|
|
case m.GuildRole != nil && m.GuildRole.Color > 0:
|
|
color = m.GuildRole.Color.Uint32()
|
|
}
|
|
|
|
if color > 0 {
|
|
return
|
|
}
|
|
|
|
return blurple
|
|
}
|
|
|
|
// TODO
|
|
func (m MentionSegment) MentionInfo() text.Rich {
|
|
switch {
|
|
case m.Channel != nil:
|
|
return m.channelInfo()
|
|
case m.GuildUser != nil:
|
|
return m.userInfo()
|
|
case m.GuildRole != nil:
|
|
return m.roleInfo()
|
|
}
|
|
|
|
// Unknown; return an empty text.
|
|
return text.Rich{}
|
|
}
|
|
|
|
func (m MentionSegment) channelInfo() text.Rich {
|
|
content := strings.Builder{}
|
|
content.WriteByte('#')
|
|
content.WriteString(m.Channel.Name)
|
|
|
|
if m.Channel.NSFW {
|
|
content.WriteString(" (NSFW)")
|
|
}
|
|
|
|
if m.Channel.Topic != "" {
|
|
content.WriteByte('\n')
|
|
content.WriteString(m.Channel.Topic)
|
|
}
|
|
|
|
return text.Rich{
|
|
Content: content.String(),
|
|
}
|
|
}
|
|
|
|
func (m MentionSegment) userInfo() text.Rich {
|
|
// // We should have a member if there's nil. Sometimes when the members aren't
|
|
// // prefetched, the markdown parser can miss them. We can check this again.
|
|
// if m.GuildUser.Member == nil && m.guild.Valid() {
|
|
// // Best effort; fine if it's nil.
|
|
// m.GuildUser.Member, _ = m.store.Member(m.guild, m.GuildUser.ID)
|
|
// }
|
|
|
|
if m.GuildUser.Member == nil {
|
|
m.GuildUser.Member = &discord.Member{
|
|
User: m.GuildUser.User,
|
|
}
|
|
}
|
|
|
|
// Get the guild for the role slice. If not, then too bad.
|
|
g, err := m.store.Guild(m.guild)
|
|
if err != nil {
|
|
g = &discord.Guild{}
|
|
}
|
|
|
|
return userInfo(*g, *m.GuildUser.Member)
|
|
}
|
|
|
|
func userInfo(guild discord.Guild, member discord.Member) text.Rich {
|
|
var content bytes.Buffer
|
|
var segment text.Rich
|
|
|
|
// Make a large avatar if there's one.
|
|
if member.User.Avatar != "" {
|
|
segmentadd(&segment, AvatarSegment{
|
|
start: 0,
|
|
url: member.User.AvatarURL(), // full URL
|
|
text: "Avatar",
|
|
size: 72, // large
|
|
})
|
|
// Space out.
|
|
content.WriteByte(' ')
|
|
}
|
|
|
|
// Write the nickname if there's one; else, write the username only.
|
|
if member.Nick != "" {
|
|
content.WriteString(member.Nick)
|
|
content.WriteByte(' ')
|
|
|
|
start, end := writestringbuf(&content, fmt.Sprintf(
|
|
"(%s#%s)",
|
|
member.User.Username,
|
|
member.User.Discriminator,
|
|
))
|
|
|
|
segmentadd(&segment, InlineSegment{
|
|
start: start,
|
|
end: end,
|
|
attributes: text.AttrDimmed,
|
|
})
|
|
} else {
|
|
content.WriteString(member.User.Username)
|
|
content.WriteByte('#')
|
|
content.WriteString(member.User.Discriminator)
|
|
}
|
|
|
|
// Write extra information if any, but only if we have the guild state.
|
|
if len(member.RoleIDs) > 0 && guild.ID.Valid() {
|
|
// Write a prepended new line, as role writes will always prepend a new
|
|
// line. This is to prevent a trailing new line.
|
|
content.WriteString("\n\n--- Roles ---")
|
|
|
|
for _, id := range member.RoleIDs {
|
|
rl, ok := findRole(guild.Roles, id)
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
// Prepend a new line before each item.
|
|
content.WriteByte('\n')
|
|
// Write exactly the role name, then grab the segment and color it.
|
|
start, end := writestringbuf(&content, "@"+rl.Name)
|
|
// But we only add the color if the role has one.
|
|
if color := rl.Color.Uint32(); color > 0 {
|
|
segmentadd(&segment, NewColoredSegment(start, end, rl.Color.Uint32()))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Assign the written content into the text segment and return it.
|
|
segment.Content = content.String()
|
|
return segment
|
|
}
|
|
|
|
func findRole(roles []discord.Role, id discord.Snowflake) (discord.Role, bool) {
|
|
for _, role := range roles {
|
|
if role.ID == id {
|
|
return role, true
|
|
}
|
|
}
|
|
return discord.Role{}, false
|
|
}
|
|
|
|
func (m MentionSegment) roleInfo() text.Rich {
|
|
// We don't have much to write here.
|
|
var segment = text.Rich{
|
|
Content: m.GuildRole.Name,
|
|
}
|
|
|
|
// Maybe add a color if we have any.
|
|
if c := m.GuildRole.Color.Uint32(); c > 0 {
|
|
segment.Segments = []text.Segment{
|
|
NewColored(len(m.GuildRole.Name), m.GuildRole.Color.Uint32()),
|
|
}
|
|
}
|
|
|
|
return segment
|
|
}
|