Golang proto.Client类代码示例

// Init initializes the plugin. it loads configuration data and binds
// commands and protocol handlers.
func (p *Plugin) Load(c *proto.Client) (err error) {
	err = p.Base.Load(c)
	if err != nil {
		return
	}

	c.Bind(proto.CmdPrivMsg, func(c *proto.Client, m *proto.Message) {
		p.parseSexpr(c, m)
	})

	ini := p.LoadConfig()
	if ini == nil {
		return
	}

	s := ini.Section("exclude")
	list := s.List("url")
	p.exclude = make([]*regexp.Regexp, len(list))

	for i := range list {
		p.exclude[i], err = regexp.Compile(list[i])

		if err != nil {
			return
		}
	}

	return
}

func fetchGithubRepo(c *proto.Client, m *proto.Message, url string) {
	matches := githubUrlRegex.FindStringSubmatch(url)
	if len(matches) != 4 {
		log.Printf("Expected %d Github matches and found %d", 4, len(matches))
		return
	}
	apiUrl := fmt.Sprintf("https://api.github.com/repos/%s/%s", matches[2], matches[3])
	resp, err := http.Get(apiUrl)
	if err != nil {
		log.Printf("Error querying: %s, %s", apiUrl, err)
		return
	}
	bts, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Printf("ERROR reading response to %s: %s", apiUrl, err)
		return
	}
	var result Repository
	err = json.Unmarshal(bts, &result)
	if err != nil {
		log.Printf("ERROR unmarshalling response to %s: %s", apiUrl, err)
		return
	}
	c.PrivMsg(m.Receiver, "%s's respository is: %s", m.SenderName, result.Description)
}

// fetchTitle attempts to retrieve the title element for a given url.
func fetchTitle(c *proto.Client, m *proto.Message, url string) {
	resp, err := http.Get(url)
	if err != nil {
		return
	}

	body, err := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	if err != nil {
		return
	}

	body = bytes.ToLower(body)
	s := bytes.Index(body, []byte("<title>"))
	if s == -1 {
		return
	}

	body = body[s+7:]

	e := bytes.Index(body, []byte("</title>"))
	if e == -1 {
		e = len(body) - 1
	}

	body = bytes.TrimSpace(body[:e])

	c.PrivMsg(m.Receiver, "%s's link shows: %s",
		m.SenderName, html.UnescapeString(string(body)))
}

// bind binds protocol message handlers.
func bind(c *proto.Client) {
	c.Bind(proto.Unknown, onAny)
	c.Bind(proto.CmdPing, onPing)
	c.Bind(proto.EndOfMOTD, onJoinChannels)
	c.Bind(proto.ErrNoMOTD, onJoinChannels)
	c.Bind(proto.ErrNicknameInUse, onNickInUse)
	c.Bind(proto.CmdPrivMsg, onPrivMsg)
}

// shutdown cleans up our mess.
func shutdown(conn *net.Conn, client *proto.Client) {
	plugin.Unload(client)

	log.Printf("Shutting down.")
	client.Quit(config.QuitMessage)
	client.Close()
	conn.Close()
}

// ctcpVersion handles a CTCP version request.
func ctcpVersion(c *proto.Client, m *proto.Message) bool {
	if m.Data != "\x01VERSION\x01" {
		return false
	}

	c.PrivMsg(m.SenderName, "%s %d.%d", AppName, AppVersionMajor, AppVersionMinor)
	return true
}

// ctcpPing handles a CTCP ping request.
func ctcpPing(c *proto.Client, m *proto.Message) bool {
	if !strings.HasPrefix(m.Data, "\x01PING ") {
		return false
	}

	c.PrivMsg(m.SenderName, "\x01PONG %s\x01", m.Data[6:])
	return true
}

// onNickInUse is called whenever we receive a notification that our
// nickname is already in use. We will attempt to re-acquire it by
// identifying with our password. Otherwise we will pick a new name.
func onNickInUse(c *proto.Client, m *proto.Message) {
	if len(config.NickservPassword) > 0 {
		c.Recover(config.Nickname, config.NickservPassword)
		return
	}

	config.SetNickname(config.Nickname + "_")
	c.Nick(config.Nickname, "")
}

func listBotReputation(c *proto.Client, m *proto.Message) {
	resp, err := red.Do("ZRANGE", "reputation", "0", "4", "WITHSCORES")
	if err != nil {
		log.Print(err)
		return
	}
	c.PrivMsg(m.Receiver, "Bottom Reputations:")
	printResponseReputationList(c, m, resp)
}

// parseURL looks for descriptions in incoming messages.
func (p *Plugin) parseDescription(c *proto.Client, m *proto.Message) {
	list := p.description.FindStringSubmatch(m.Data)
	if len(list) == 0 {
		return
	}

	description := list[len(list)-1]
	log.Printf("Found description: %s", description)
	c.PrivMsg(m.Receiver, fmt.Sprintf("%s %s is %s", otherBotUsername, m.SenderName, description))
}

func decrementReputation(c *proto.Client, m *proto.Message, entity string) {
	log.Printf("decrementing %s", entity)
	rep, err := red.Do("ZINCRBY", "reputation", "-1", entity)
	if err != nil {
		log.Print(err)
		return
	}
	c.PrivMsg(m.Receiver, "%s lost 1 rep! rep: %s",
		entity, string(rep.([]byte)))
}

func checkReputation(c *proto.Client, m *proto.Message, entity string) {
	log.Printf("checking %s", entity)
	rep, err := red.Do("ZSCORE", "reputation", entity)
	if err != nil {
		log.Print(err)
		return
	}
	if rep == nil {
		c.PrivMsg(m.Receiver, "never heard of %s", entity)
		return
	}

	c.PrivMsg(m.Receiver, "%s has rep: %s", entity, string(rep.([]byte)))
}

func printResponseReputationList(c *proto.Client, m *proto.Message,
	resp interface{}) {
	values, err := redis.Values(resp, nil)
	if err != nil {
		log.Print(err)
		return
	}
	var reps []struct {
		Name  string
		Score int
	}
	err = redis.ScanSlice(values, &reps)
	for i, rep := range reps {
		c.PrivMsg(m.Receiver, "(%d) %-10s: %3d", i, rep.Name, rep.Score)
	}
}

// fetchTweet attempts to retrieve the tweet associated with a given url.
func fetchTweet(c *proto.Client, m *proto.Message, url string) {
	id, err := strconv.ParseInt(twitterUrlRegex.FindStringSubmatch(url)[2], 10, 64)
	if err != nil {
		c.PrivMsg(m.Receiver, "error parsing tweet :(")
		log.Print("error parsing tweet for %s: %v", url, err)
		fetchTitle(c, m, url)
		return
	}
	tweet, err := api.GetTweet(id, nil)
	if err != nil {
		log.Print("error parsing tweet for %s: %v", url, err)
		fetchTitle(c, m, url)
		return
	}
	c.PrivMsg(m.Receiver, "%s's tweet shows: %s",
		m.SenderName, html.UnescapeString(tweet.Text))
}

func (p *Plugin) Load(c *proto.Client) (err error) {
	err = p.Base.Load(c)
	if err != nil {
		return
	}

	w := new(cmd.Command)
	w.Name = "define"
	w.Description = "Fetch the definition for the given term"
	w.Restricted = false
	w.Params = []cmd.Param{
		{Name: "term", Description: "Word to find definition for", Pattern: cmd.RegAny},
	}
	w.Execute = func(cmd *cmd.Command, c *proto.Client, m *proto.Message) {
		dict, err := Dial("tcp", "dict.org:2628")
		if err != nil {
			log.Printf("[dict] %s", err)
			c.PrivMsg(m.Receiver, "%s, No definition found for '%s'",
				m.SenderName, cmd.Params[0].Value)
			return
		}

		def, err := dict.Define("wn", cmd.Params[0].Value)
		if err != nil {
			log.Printf("[dict] %s", err)
			c.PrivMsg(m.Receiver, "%s, No definition found for '%s'",
				m.SenderName, cmd.Params[0].Value)
			return
		}

		if len(def) == 0 {
			c.PrivMsg(m.Receiver, "%s, No definition found for '%s'",
				m.SenderName, cmd.Params[0].Value)
			return
		}

		space := []byte{' '}
		mspace := []byte{' ', ' '}
		line := bytes.Replace(def[0].Text, []byte{'\n'}, space, -1)

		// Strip all multi-space indents.
		for bytes.Index(line, mspace) > -1 {
			line = bytes.Replace(line, mspace, space, -1)
		}

		c.PrivMsg(m.Receiver, "%s: %s", m.SenderName, line)
	}

	cmd.Register(w)

	return
}