Example #1
0
func writePullRequestChanges(repo *github.Repo, messageFile string) error {
	message := `
# Requesting a pull to %s from %s
#
# Write a message for this pull request. The first block
# of the text is the title and the rest is description.%s
`
	startRegexp := regexp.MustCompilePOSIX("^")
	endRegexp := regexp.MustCompilePOSIX(" +$")

	commitLogs, _ := git.Log(repo.Base, repo.Head)
	var changesMsg string
	if len(commitLogs) > 0 {
		commitLogs = strings.TrimSpace(commitLogs)
		commitLogs = startRegexp.ReplaceAllString(commitLogs, "# ")
		commitLogs = endRegexp.ReplaceAllString(commitLogs, "")
		changesMsg = `
#
# Changes:
#
%s`
		changesMsg = fmt.Sprintf(changesMsg, commitLogs)
	}

	message = fmt.Sprintf(message, repo.FullBase(), repo.FullHead(), changesMsg)

	return ioutil.WriteFile(messageFile, []byte(message), 0644)
}
Example #2
0
func (p *pullRequestMsg) FormattedCommitLogs() string {
	startRegexp := regexp.MustCompilePOSIX("^")
	endRegexp := regexp.MustCompilePOSIX(" +$")

	commitLogs := strings.TrimSpace(p.CommitLogs)
	commitLogs = startRegexp.ReplaceAllString(commitLogs, fmt.Sprintf("%s ", p.CS))
	commitLogs = endRegexp.ReplaceAllString(commitLogs, "")

	return commitLogs
}
Example #3
0
func (g *HttpJsonLibGenerator) Generate() ([]byte, error) {
	clientAPI, err := g.generateAPI()
	if err != nil {
		return nil, err
	}

	result := regexp.MustCompilePOSIX(">>>API_NAME<<<").ReplaceAll(mainTemplate, []byte(GetAPIName(g.serviceName)))
	result = regexp.MustCompilePOSIX(">>>PKG_NAME<<<").ReplaceAll(result, []byte(g.pkgName))
	result = regexp.MustCompilePOSIX(">>>CLIENT_API<<<").ReplaceAll(result, clientAPI)
	result = regexp.MustCompilePOSIX(">>>IMPORTS<<<").ReplaceAll(result, g.collectImports())

	return format.Source(result)
}
// Search search engines
func FindDirectoryURL() (string, error) {
	ch := make(chan string, 100)
	fetch_and_parse := func(url string) {
		s2w := make([]byte, 1)
		rand.Reader.Read(s2w)
		for i := 0; i < int(s2w[0])%4; i++ {
			time.Sleep(time.Second)
		}
		resp, err := http.Get(url)
		if err != nil {
			return
		}
		defer func() {
			if r := recover(); r != nil {
			}
		}()
		defer resp.Body.Close()
		thing := new(bytes.Buffer)
		io.Copy(thing, resp.Body)
		tosearch := string(thing.Bytes())
		rge := regexp.MustCompilePOSIX("Kids in rectangles irritating sick urchins rattling foxes,.*lol")
		str := rge.FindString(tosearch)
		arr := strings.Split(str, " ")
		res := arr[len(arr)-2]
		buf := new(bytes.Buffer)
		buf.WriteString("https://")
		buf.WriteString(res)
		buf.WriteString("/")
		ch <- buf.String()
	}
	go fetch_and_parse("https://stackoverflow.com/users/2022968/user54609")
	go fetch_and_parse("https://pastee.org/q2ndr")
	return <-ch, nil
}
Example #5
0
// ValidateParameters *must* be implemented by a module. It provides a method
// to verify that the parameters passed to the module conform the expected format.
// It must return an error if the parameters do not validate.
func (r Runner) ValidateParameters() (err error) {
	fqdn := regexp.MustCompilePOSIX(`^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$`)
	if !fqdn.MatchString(r.Parameters.LookupHost) {
		return fmt.Errorf("ValidateParameters: LookupHost parameter is not a valid FQDN.")
	}
	return
}
Example #6
0
func main() {
	log.SetFlags(0)
	log.SetPrefix("gocyclo: ")
	flag.Usage = usage
	flag.Parse()

	if len(*ignore) == 0 {
		ignoreRx = nil
	} else {
		ignoreRx = regexp.MustCompilePOSIX(*ignore)
	}

	args := flag.Args()
	if len(args) == 0 {
		usage()
	}

	stats := analyze(args)
	sort.Sort(byComplexity(stats))
	written := writeStats(os.Stdout, stats)

	if *avg {
		showAverage(stats)
	}

	if *over > 0 && written > 0 {
		os.Exit(1)
	}
}
Example #7
0
func waitForCmd(s *Shell) stateFn {
	timeout := time.After(2 * time.Second)
	r := regexp.MustCompilePOSIX("^(.*?>)?" + regexp.QuoteMeta(s.scmd) + "[[:space:]]*?$[\r\n]*")
	// fmt.Println("waitForCmd: looking for '" + r.String() + "'")
	for {
		select {
		case readout := <-s.cout:
			// fmt.Println("waitForCmd: received '" + readout + "'")
			s.status.stdout = s.status.stdout + readout
			if loc := r.FindStringIndex(s.status.stdout); loc != nil {
				s.status.stdout = s.status.stdout[loc[1]:]
				return waitForEnd(s)
			}
		case readerr := <-s.cerr:
			anErrIndex := &errIndex{
				start: len(s.status.stdout),
				end:   len(s.status.stdout) + len(readerr)}
			s.status.errs = append(s.status.errs, *anErrIndex)
			s.status.stdout = s.status.stdout + readerr
		case _ = <-timeout:
			fmt.Println("waitForCmd: No cmd detected on shell?! '" + s.scmd + "'")
			return nil // should actually Panic
		}
	}
	return nil
}
Example #8
0
func GetCurrentContainerID() string {
	file, err := os.Open("/proc/self/cgroup")

	if err != nil {
		return ""
	}

	reader := bufio.NewReader(file)
	scanner := bufio.NewScanner(reader)
	scanner.Split(bufio.ScanLines)

	regex := "/docker/([[:alnum:]]{64})$"
	re := regexp.MustCompilePOSIX(regex)

	for scanner.Scan() {
		_, lines, err := bufio.ScanLines([]byte(scanner.Text()), true)
		if err == nil {
			if re.MatchString(string(lines)) {
				submatches := re.FindStringSubmatch(string(lines))
				containerID := submatches[1]

				return containerID
			}
		}
	}

	return ""
}
Example #9
0
func main() {
	aliases := loadExtAlias()

	pExt := flag.String("ext", "", "Specify the extension. If not specified, extract from filename")

	flag.Parse()

	*pExt = findExtAlias(aliases, removeLeadingDot(*pExt))

	args := flag.Args()
	if len(args) < 1 {
		printUsage()
	}

	pat := flag.Arg(0)
	fns := villa.Paths(args[1:]...)

	re := regexp.MustCompilePOSIX(pat)

	if len(fns) > 0 {
		for _, fn := range fns {
			ext := *pExt
			if ext == "" {
				ext = findExtAlias(aliases, removeLeadingDot(fn.Ext()))
			}

			grep.Grep(re, fn, ext)
		}
	} else {
		grep.Grep(re, "", *pExt)
	}
}
Example #10
0
func GetThreadHashHTML(file string) (thread string) {
	exp := regexp.MustCompilePOSIX(`thread-([0-9a-f]+)\.html`)
	matches := exp.FindStringSubmatch(file)
	if len(matches) != 2 {
		return ""
	}
	thread = matches[1]
	return
}
Example #11
0
func printDatagram(out *color.Color, d *protocol.Datagram) {
	re := regexp.MustCompilePOSIX("^00000")

	out.Printf("FROM: %s\n", d.From)
	out.Printf("SIZE: %d\n", len(d.Data))
	data := strings.TrimLeft(hex.Dump(d.Data), "0")
	out.Printf("DATA: 000" + re.ReplaceAllString(data, "      "))
	color.Set(color.Bold)
}
Example #12
0
func GetGroupForCatalogHTML(file string) (group string) {
	exp := regexp.MustCompilePOSIX(`catalog-(.+)\.html`)
	matches := exp.FindStringSubmatch(file)
	if len(matches) != 2 {
		return ""
	}
	group = matches[1]
	return
}
Example #13
0
func (f *Field) parseTag(tag string) {
	tag = tag[1:len(tag)] //избавляемся от `
	rxp := regexp.MustCompilePOSIX(`db:\"([a-z0-9\-_]+)\"`)
	name := rxp.FindString(tag)
	if name == "-" {
		return
	}
	f.Name = name[4 : len(name)-1]
	rxp = regexp.MustCompilePOSIX(`id_([a-z0-9]+)`)
	if rxp.MatchString(f.Name) {
		f.Foreign = true
		f.ForeignTable = f.Name[3:]
	}
	rxp = regexp.MustCompilePOSIX(`gen:"([a-z0-9\-_,\'\'\(\)]+)"`)
	gen := rxp.FindString(tag)
	if len(gen) < 6 {
		return
	}
	opts := strings.Split(gen[5:len(gen)-1], ",")
	if len(opts) > 0 {
		f.Type = opts[0]
	}
	for _, opt := range opts {
		if opt == f.Type {
			continue
		}
		switch opt {
		case "autoincrement":
			f.AutoIncrement = true
		case "notnull":
			f.NotNull = true
		case "primary":
			f.Primary = true
		case "unique":
			f.Uniqeu = true
		case "index":
			f.Index = true
		default:
			rxp = regexp.MustCompilePOSIX(`default\(.+\)`)
			def := rxp.FindString(opt)
			f.Default = def[8 : len(def)-1]
		}
	}
}
Example #14
0
// Tries to find an appropriate point to word wrap line, taking shell escape codes into account.
// (Note that because the escape codes are not visible, we can run past the max length for one of them)
func findSplit(line string, guess int) int {
	if guess >= len(line) {
		return len(line)
	}
	r := regexp.MustCompilePOSIX(fmt.Sprintf(".{%d,%d}(\\x1b[^m]+m)?", guess/2, guess))
	m := r.FindStringIndex(line)
	if m != nil {
		return m[1] // second element in slice is the end index
	}
	return guess // Dunno what to do at this point. It's probably unlikely to happen often though.
}
Example #15
0
func pullRequestChangesMessage(base, head, fullBase, fullHead string, commits []string) (string, error) {
	var defaultMsg, commitSummary string
	if len(commits) == 1 {
		msg, err := git.Show(commits[0])
		if err != nil {
			return "", err
		}
		defaultMsg = fmt.Sprintf("%s\n", msg)
	} else if len(commits) > 1 {
		commitLogs, err := git.Log(base, head)
		if err != nil {
			return "", err
		}

		if len(commitLogs) > 0 {
			startRegexp := regexp.MustCompilePOSIX("^")
			endRegexp := regexp.MustCompilePOSIX(" +$")

			commitLogs = strings.TrimSpace(commitLogs)
			commitLogs = startRegexp.ReplaceAllString(commitLogs, "# ")
			commitLogs = endRegexp.ReplaceAllString(commitLogs, "")
			commitSummary = `
#
# Changes:
#
%s`
			commitSummary = fmt.Sprintf(commitSummary, commitLogs)
		}
	}

	message := `%s
# Requesting a pull to %s from %s
#
# Write a message for this pull request. The first block
# of the text is the title and the rest is description.%s
`
	message = fmt.Sprintf(message, defaultMsg, fullBase, fullHead, commitSummary)

	return message, nil
}
Example #16
0
func (g *HttpJsonLibGenerator) generateAPI() ([]byte, error) {
	var result bytes.Buffer
	var typesBuf bytes.Buffer

	for _, path := range g.hm.GetHandlersPaths() {
		info := g.hm.GetHandlerInfo(path)
		for _, v := range info.Versions {
			inTypeName, outTypeName, err := g.printHandlerInOutTypes(&typesBuf, v.Request.Type, v.Response)
			if err != nil {
				return nil, err
			}
			handlerTypeName := strings.Replace(strings.Title(v.Route), "/", "", -1)
			handlerTypeName = strings.Replace(handlerTypeName, "_", "", -1)

			errVarName := g.printHandlerMethodError(&typesBuf, handlerTypeName, v.Errors)

			method := regexp.MustCompilePOSIX(">>>HANDLER_PATH<<<").ReplaceAll(handlerCallPostFuncTemplate, []byte(v.Route))
			method = regexp.MustCompilePOSIX(">>>HANDLER_NAME<<<").ReplaceAll(method, []byte(handlerTypeName))
			method = regexp.MustCompilePOSIX(">>>INPUT_TYPE<<<").ReplaceAll(method, []byte(inTypeName))
			method = regexp.MustCompilePOSIX(">>>RETURNED_TYPE<<<").ReplaceAll(method, []byte(outTypeName))
			method = regexp.MustCompilePOSIX(">>>HANDLER_ERRORS<<<").ReplaceAll(method, []byte(errVarName))
			method = regexp.MustCompilePOSIX(">>>API_NAME<<<").ReplaceAll(method, []byte(GetAPIName(g.serviceName)))

			result.Write(method)
		}
	}

	typesBuf.WriteTo(&result)

	return result.Bytes(), nil
}
Example #17
0
// FindGithubInfo tries to find the username and repository
// of the current git project.
//
// We do this using git remote -v. If it works, we should get something like:
//
//	origin	[email protected]:cassava/repoctl.git (fetch)
//	origin	[email protected]:cassava/repoctl.git (push)
//
// This is one of multiple formats. We need to expand this with time to cover
// all the different formats that it can have.
//
//  1. Check if github is there
//  2. Check protocol and extract information
//		a) git protocol: `[email protected]:username/repository.git`
//		b) https protocol: `https://github.com/username/repository.git`
//
func FindGithubInfo(_ string) (*GithubRepo, error) {
	out, err := exec.Command("git", "remote", "-v").Output()
	if err != nil {
		return nil, err
	}

	r := regexp.MustCompilePOSIX(`([^\t]+)\t(git@|http://|https://)github\.com[/:]([^/]+)/(.+)\.git[ \t]*.*`)
	infos := make(map[string][2]string)
	scanner := bufio.NewScanner(bytes.NewBuffer(out))
	for scanner.Scan() {
		s := scanner.Text()
		if !strings.Contains(s, "github") {
			continue
		}
		if !r.MatchString(s) {
			fmt.Fprintf(os.Stderr, "Warning: cannot match %q.\n", s)
			continue
		}

		ls := r.FindStringSubmatch(s)
		source, _, user, repo := ls[1], ls[2], ls[3], ls[4]
		infos[source] = [2]string{user, repo}
	}
	if err := scanner.Err(); err != nil {
		return nil, err
	}

	var up [2]string
	if len(infos) == 0 {
		return nil, errors.New("not a GitHub repository")
	} else if len(infos) == 1 {
		for _, v := range infos {
			up = v
		}
	} else {
		// Try the origin repository first; if it exists, it is bound to be the right one.
		if v, ok := infos["origin"]; ok {
			up = v
		} else {
			for k, v := range infos {
				fmt.Fprintf(os.Stderr, "Warning: multiple GitHub repositories; using source %q.\n", k)
				up = v
				break
			}
		}
	}

	return &GithubRepo{
		User: up[0],
		Name: up[1],
	}, nil
}
Example #18
0
// generate a thumbnailer that uses ffmpeg
func FFMpegThumbnailer(ffmpegPath string, conf *Config) Thumbnailer {
	if conf == nil {
		conf = defaultCfg
	}
	return &ExecThumbnailer{
		Exec:   ffmpegPath,
		Accept: regexp.MustCompilePOSIX(`\.(mkv|mp4|avi|webm|ogv|mov|m4v|mpg)$`),
		GenArgs: func(inf, outf string) []string {
			outf += ".jpeg"
			return []string{"-i", inf, "-vf", fmt.Sprintf("scale=%d:%d", conf.ThumbW, conf.ThumbH), "-vframes", "1", outf}
		},
	}
}
Example #19
0
func grt_CompilePOSIX() {

	// the POSIX engine will prefer the leftmost-longest match. It will not
	// return after finding the first match, but will check that the found
	// match is indeed the longest one.

	s := "ABCDEEEEE"
	rr := regexp.MustCompile(`ABCDE{2}|ABCDE{4}`)
	rp := regexp.MustCompilePOSIX(`ABCDE{2}|ABCDE{4}`)
	fmt.Println(rr.FindAllString(s, 2)) // <- first acceptable match
	fmt.Println(rp.FindAllString(s, 2)) // POSIX wants the longer match

}
Example #20
0
File: main.go Project: bjarneh/cmd
func addRegexFilter() {

	var reg *regexp.Regexp

	if posix {
		reg = regexp.MustCompilePOSIX(pattern)
	} else {
		reg = regexp.MustCompile(pattern)
	}

	walker.IncludeFile = func(s string) bool {
		return reg.MatchString(s)
	}
}
Example #21
0
func wiki(uri string) string {
	langRex := regexp.MustCompilePOSIX(`[a-z]+\.wiki`)
	lang := langRex.FindString(uri)
	lang = lang[:len(lang)-5]
	articleRex := regexp.MustCompilePOSIX(`.org\/wiki\/[a-zA-Z0-9а-яА-Я_\(\)\%\,\:]+`)
	article := articleRex.FindString(uri)
	article = article[10:]
	fmt.Println(article)
	wikiUrl := "https://" + lang + ".wikipedia.org/w/api.php?format=json&action=query&prop=extracts&exintro=&explaintext=&titles=" + article
	resp, err := http.Get(wikiUrl)
	if err != nil {
		return ""
	}
	defer resp.Body.Close()
	jsraw, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return ""
	}
	wikiSearch := new(struct {
		Query struct {
			Pages map[string]map[string]interface{} `json:"pages"`
		} `json:"query"`
	})
	err = json.Unmarshal(jsraw, wikiSearch)
	fmt.Println(string(jsraw))
	for _, page := range wikiSearch.Query.Pages {
		var msg string
		if title, ok := page["title"].(string); ok {
			msg += "*" + title + "*\n"
			if extract, ok := page["extract"].(string); ok {
				msg += "```" + extract + "```"
			}
		}
		return msg
	}
	return ""
}
Example #22
0
func GetGroupAndPageHTML(file string) (board string, page int) {
	exp := regexp.MustCompilePOSIX(`(.*)-([0-9]+)\.html`)
	matches := exp.FindStringSubmatch(file)
	if len(matches) != 3 {
		return "", -1
	}
	var err error
	board = matches[1]
	tmp := matches[2]
	page, err = strconv.Atoi(tmp)
	if err != nil {
		page = -1
	}
	return
}
Example #23
0
File: main.go Project: bjarneh/cmd
func addRegexpFilter() {

	var reg *regexp.Regexp

	if posix {
		reg = regexp.MustCompilePOSIX(pattern)
	} else {
		reg = regexp.MustCompile(pattern)
	}

	matchOK = func(s string) bool {
		b := slurpStripNullByte(s)
		return reg.Match(b)
	}
}
Example #24
0
// create an imagemagick thumbnailer
func ImageMagickThumbnailer(convertPath string, conf *Config) Thumbnailer {
	if conf == nil {
		conf = defaultCfg
	}
	return &ExecThumbnailer{
		Exec:   convertPath,
		Accept: regexp.MustCompilePOSIX(`\.(png|jpg|jpeg|gif|webp)$`),
		GenArgs: func(inf, outf string) []string {
			if strings.HasSuffix(inf, ".gif") {
				inf += "[0]"
			}
			if conf.JpegOnly {
				outf += ".jpeg"
			}
			return []string{"-thumbnail", fmt.Sprintf("%d", conf.ThumbW), inf, outf}
		},
	}
}
Example #25
0
func main() {
	conn, err := protocol.Connect()

	if err != nil {
		panic(err.Error())
	}

	datagrams := make(chan protocol.Datagram)
	bytes := make(chan []byte)

	go func() {
		for d := range conn.Datagrams {
			datagrams <- d
			bytes <- d.Data
		}

		close(datagrams)
		close(bytes)
	}()

	msgs, errs := protocol.NewMessageDecoder(datagrams)

	re := regexp.MustCompilePOSIX("^00000")

	for {
		b := <-bytes

		out := color.New(color.FgWhite)
		out.Printf("DATA: length=%d\n", len(b))
		out.Print(re.ReplaceAllString(hex.Dump(b), "      "))
		color.Set(color.Bold)

		select {
		case msg := <-msgs:
			out.Add(color.FgGreen)
			out.Printf("MSG:  %+v\n      %T %+v", msg.Header, msg.Payload, msg.Payload)
		case err := <-errs:
			out.Add(color.FgRed)
			out.Printf("ERR:  %s", err.Error())
		}
		fmt.Printf("\n\n")
	}
}
Example #26
0
func (l *lexer) readTokenMatchingRegexp(pattern string) {
	pattern = "^" + pattern
	reg := re.MustCompilePOSIX(pattern)

	indexes := reg.FindStringIndex(l.input[l.position-1:])

	if indexes == nil {
		panic("No match")
	}

	if indexes[0] != 0 {
		// shouldn't happen due to anchoring
		panic("Unexpected regex match")
	}

	for i := 0; i < indexes[1]-1; i++ {
		l.read()
	}
}
Example #27
0
func parseOpts() error {
	flag.Usage = usageFunc

	key := flag.String("key", "", "A POSIX regexp to filter a key. Doesn't affect -stdin filtering.")
	filter := flag.String("filter", "{}", "A JSON object as filter: {\"username\": \"moon\"}.")
	or := flag.Bool("or", false, "Filter on Key OR filter.")
	url := flag.String("url", "http://localhost:8091", "Couchbase URL.")
	bucket := flag.String("bucket", "", "Listen on Couchbase bucket name.")
	pool := flag.String("pool", "default", "Couchbase pool name.")
	stdin := flag.Bool("stdin", false, "Listen on stdin.")

	flag.Parse()

	if *bucket == "" && *stdin == false {
		return errors.New("Either -stdin or -bucket has to be specified.")
	}

	opts.RegexpKey = regexp.MustCompilePOSIX(*key)

	opts.Stdin = *stdin
	opts.Url = *url
	opts.Or = *or
	opts.Pool = *pool
	opts.Bucket = *bucket
	opts.Key = *key

	var v interface{}

	err := json.Unmarshal([]byte(*filter), &v)
	if err != nil {
		return err
	}

	if filter, ok := v.(map[string]interface{}); ok {
		opts.Filter = filter
	} else {
		return errors.New("Filter must be a JSON object.")
	}

	return nil
}
Example #28
0
func getPrivatePPAFromConf(f *os.File) (res []string) {
	res = make([]string, 5)
	reader := bufio.NewReader(f)

	re := regexp.MustCompilePOSIX("^\\[(.+)\\]$")

	for {
		line, err := reader.ReadString('\n')
		if err != nil && err != io.EOF {
			break
		}
		if match := re.FindStringSubmatch(line); len(match) == 2 {
			res = append(res, match[1])
		}

		if err == io.EOF {
			break
		}
	}
	return res
}
Example #29
0
func main() {
	flag.Parse()
	log.Printf("connecting to Slack API...")
	bot, err := NewSlackBot(*token)
	panicOnErr(err)
	for {
		log.Printf("awaiting message")
		select {
		case <-bot.Quit:
			log.Printf("quit")
			return
		case msg := <-bot.Messages:
			data, _ := json.Marshal(msg)
			log.Printf("new message %s", string(data))
			if msg.Type == "message" {
				if !bot.IsBot(msg.User) {
					fmt.Println("Author:", bot.UserIdToName(msg.User))
					fmt.Println("Channel:", bot.ChannelIdToName(msg.Channel))
					fmt.Println("Text:", msg.Text)
					playgroundUrl := regexp.MustCompile(`https?\:\/\/play\.golang\.org\/p\/([a-zA-Z0-9]+)`)
					wikiUrl := regexp.MustCompilePOSIX(`https?\:\/\/[a-z]*\.wikipedia\.org\/wiki\/([a-zA-Z0-9%_\(\)а-яА-я\,\:]+)`)
					switch {
					case playgroundUrl.MatchString(msg.LowerText()):
						uris := playgroundUrl.FindAllString(msg.Text, -1)
						for _, uri := range uris {
							bot.SendMessage(msg.Channel, playground(uri))
						}
					case wikiUrl.MatchString(msg.LowerText()):
						uris := wikiUrl.FindAllString(msg.LowerText(), -1)
						for _, uri := range uris {
							bot.SendMessage(msg.Channel, wiki(uri))
						}
					case strings.Contains(msg.LowerText(), "pong"):
						bot.SendMessage(msg.Channel, "@"+bot.UserIdToName(msg.User)+": ping")
					}
				}
			}
		}
	}
}
Example #30
0
func (s NaturalSort) Less(i, j int) bool {
	r := regexp.MustCompilePOSIX(`^([^0-9]*)+|[0-9]+`)

	spliti := r.FindAllString(strings.Replace(s[i], " ", "", -1), -1)
	splitj := r.FindAllString(strings.Replace(s[j], " ", "", -1), -1)

	splitshortest := len(spliti)
	if len(spliti) > len(splitj) {
		splitshortest = len(splitj)
	}
	for index := 0; index < splitshortest; index++ {
		if spliti[index] != splitj[index] {
			inti, ei := strconv.Atoi(spliti[index])
			intj, ej := strconv.Atoi(splitj[index])
			if ei == nil && ej == nil { //if number
				return inti < intj
			}
			return spliti[index] < splitj[index]
		}

	}
	return s[i] < s[j]
}