Golang Compile示例

说明

golang compile示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: regexp

示例#1
文件: main.go 项目: silky/rct

func main() {
	directory := flag.String("directory", "/usr/local/rct", "Path to the folder storing RCT experiment data")
	templateDirectory := flag.String("template-directory", "/usr/local/rct/server/templates", "Path to the folder storing RCT server templates (this file -> server/templates)")
	staticDirectory := flag.String("static-directory", "/usr/local/rct/server/static", "Path to the folder storing RCT server templates (this file -> server/static)")

	flag.Parse()
	if len(flag.Args()) > 0 {
		log.Fatalf("Usage: server [-directory DIRECTORY] ")
	}
	h := new(RegexpHandler)
	renderRoute, err := regexp.Compile("/experiments/.*/iterations/.+/.+/render")
	if err != nil {
		log.Fatal(err)
	}
	iterationRoute, err := regexp.Compile("/experiments/.*/iterations/.+/.+")
	if err != nil {
		log.Fatal(err)
	}
	staticRoute, err := regexp.Compile("/static")
	if err != nil {
		log.Fatal(err)
	}
	defaultRoute, err := regexp.Compile("/")
	if err != nil {
		log.Fatal(err)
	}
	h.HandleFunc(renderRoute, renderHandler(*directory, *templateDirectory))
	h.HandleFunc(iterationRoute, newRctHandler(*directory, *templateDirectory))
	h.Handler(staticRoute, http.StripPrefix("/static", http.FileServer(http.Dir(*staticDirectory))))
	h.Handler(defaultRoute, http.FileServer(http.Dir(*directory)))
	allHandlers := jsonStripper(serverHeaderHandler(h))
	log.Fatal(http.ListenAndServe(":8080", handlers.LoggingHandler(os.Stdout, allHandlers)))
}

示例#2
文件: html.go 项目: wcreate/lawoto

func Html2str(html string) string {
	src := string(html)

	//替换HTML的空白字符为空格
	re := regexp.MustCompile(`\s`) //ns*r
	src = re.ReplaceAllString(src, " ")

	//将HTML标签全转换成小写
	re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")
	src = re.ReplaceAllStringFunc(src, strings.ToLower)

	//去除STYLE
	re, _ = regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")
	src = re.ReplaceAllString(src, "")

	//去除SCRIPT
	re, _ = regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")
	src = re.ReplaceAllString(src, "")

	//去除所有尖括号内的HTML代码,并换成换行符
	re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")
	src = re.ReplaceAllString(src, "\n")

	//去除连续的换行符
	re, _ = regexp.Compile("\\s{2,}")
	src = re.ReplaceAllString(src, "\n")

	return strings.TrimSpace(src)
}

示例#3
文件: utils_test.go 项目: CyrusBiotechnology/dozy

func GetVersion(t *testing.T) {
	number_re, err := regexp.Compile("([0-9]+)")
	if err != nil {
		t.Fatal("test encountered an error")
	}
	dot_re, err := regexp.Compile("\\.")
	if err != nil {
		t.Fatal("test encountered an error")
	}

	version_from_function := getVersion()
	numbers := number_re.FindAllString(version_from_function, -1)
	dots := dot_re.FindAllString(version_from_function, -1)

	if len(numbers) != 3 {
		t.Fatal("too many version groups (should be MAJOR.MINOR.BUGFIX)")
	}

	reconstructed := []string{
		numbers[0], dots[0],
		numbers[1], dots[1],
		numbers[2], dots[2],
	}
	check_string := strings.Join(reconstructed, "")

	if version_from_function != check_string {
		t.Fatal("unexpected results from version function")
	}
}

示例#4
文件: conformance.go 项目: Clarifai/kubernetes

// firewall checks that iptables does not have common firewall rules setup that would disrupt traffic
func firewall() error {
	out, err := exec.Command("iptables", "-L", "INPUT").CombinedOutput()
	if err != nil {
		return printSuccess("Firewall Iptables Check %s: Could not run iptables", skipped)
	}
	inputRegex, err := regexp.Compile(iptablesInputRegexStr)
	if err != nil {
		// This should never happen and can only be fixed by changing the code
		panic(err)
	}
	if inputRegex.Match(out) {
		return printError("Firewall Iptables Check %s: Found INPUT rule matching %s", failed, iptablesInputRegexStr)
	}

	// Check GCE forward rules
	out, err = exec.Command("iptables", "-L", "FORWARD").CombinedOutput()
	if err != nil {
		return printSuccess("Firewall Iptables Check %s: Could not run iptables", skipped)
	}
	forwardRegex, err := regexp.Compile(iptablesForwardRegexStr)
	if err != nil {
		// This should never happen and can only be fixed by changing the code
		panic(err)
	}
	if forwardRegex.Match(out) {
		return printError("Firewall Iptables Check %s: Found FORWARD rule matching %s", failed, iptablesInputRegexStr)
	}

	return printSuccess("Firewall Iptables Check %s", success)
}

示例#5
文件: common.go 项目: no2key/pholcus-1

func CleanHtml(str string, depth int) string {
	if depth > 0 {
		//将HTML标签全转换成小写
		re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")
		str = re.ReplaceAllStringFunc(str, strings.ToLower)
	}
	if depth > 1 {
		//去除STYLE
		re, _ := regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")
		str = re.ReplaceAllString(str, "")
	}
	if depth > 2 {
		//去除SCRIPT
		re, _ := regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")
		str = re.ReplaceAllString(str, "")
	}
	if depth > 3 {
		//去除所有尖括号内的HTML代码,并换成换行符
		re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")
		str = re.ReplaceAllString(str, "\n")
	}
	if depth > 4 {
		//去除连续的换行符
		re, _ := regexp.Compile("\\s{2,}")
		str = re.ReplaceAllString(str, "\n")
	}
	return str
}

示例#6
文件: block_paths.go 项目: spxtr/contrib

// Initialize will initialize the munger
func (b *BlockPath) Initialize(config *github.Config, features *features.Features) error {
	if len(b.Path) == 0 {
		glog.Fatalf("--block-path-config is required with the block-path munger")
	}
	file, err := os.Open(b.Path)
	if err != nil {
		glog.Fatalf("Failed to load block-path config: %v", err)
	}
	defer file.Close()

	c := &configBlockPath{}
	if err := yaml.NewYAMLToJSONDecoder(file).Decode(c); err != nil {
		glog.Fatalf("Failed to decode the block-path config: %v", err)
	}

	b.blockRegexp = []regexp.Regexp{}
	for _, str := range c.BlockRegexp {
		reg, err := regexp.Compile(str)
		if err != nil {
			return err
		}
		b.blockRegexp = append(b.blockRegexp, *reg)
	}

	b.doNotBlockRegexp = []regexp.Regexp{}
	for _, str := range c.DoNotBlockRegexp {
		reg, err := regexp.Compile(str)
		if err != nil {
			return err
		}
		b.doNotBlockRegexp = append(b.doNotBlockRegexp, *reg)
	}
	return nil
}

示例#7
文件: issue.go 项目: otremblay/libgojira

func (i *Issue) PrettySprint() string {
	sa := make([]string, 0)
	sa = append(sa, fmt.Sprintln(i.String()))
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Jira URL: %s", i.Url())))
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Status: %s", i.Status)))
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Assignee: %s", i.Assignee)))
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Original time estimate: %s", PrettySeconds(int(i.OriginalEstimate)))))
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Time spent: %s", PrettySeconds(int(i.TimeSpent)))))
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Remaining time estimated: %s", PrettySeconds(int(i.RemainingEstimate)))))
	r, _ := regexp.Compile("[*]([^*]*)[*]")
	splitdesc := strings.Split(i.Description, "\n")
	for k, v := range splitdesc {
		splitdesc[k] = r.ReplaceAllString(v, "\x1b[1m$1\x1b[22m")
	}
	desc := strings.Join(splitdesc, "\n")
	desc = strings.Replace(desc, "{color:red}", "\x1b[31m", -1)
	desc = strings.Replace(desc, "{color}", "\x1b[39m", -1)

	r2, _ := regexp.Compile("(?s)[{]quote[}](.*)[{]quote[}]")
	desc = r2.ReplaceAllString(desc, "\x1b[51$1\x1b[54")
	sa = append(sa, fmt.Sprintln(fmt.Sprintf("Description: %s", desc)))
	if len(i.Files) > 0 {
		sa = append(sa, fmt.Sprintln(fmt.Sprintf("Files: \n%v", i.Files)))
	}

	if len(i.Comments) > 0 {
		sa = append(sa, fmt.Sprintln(fmt.Sprintf("Comments: \n%v", i.Comments)))
	}

	if len(i.TimeLog) > 0 {
		sa = append(sa, fmt.Sprintln(fmt.Sprintf("Worklog: \n%v", i.TimeLog)))
	}

	return strings.Join(sa, "\n")
}

示例#8
文件: http.go 项目: flecno/blackbox_exporter

func matchRegularExpressions(reader io.Reader, config HTTPProbe) bool {
	body, err := ioutil.ReadAll(reader)
	if err != nil {
		log.Errorf("Error reading HTTP body: %s", err)
		return false
	}
	for _, expression := range config.FailIfMatchesRegexp {
		re, err := regexp.Compile(expression)
		if err != nil {
			log.Errorf("Could not compile expression %q as regular expression: %s", expression, err)
			return false
		}
		if re.Match(body) {
			return false
		}
	}
	for _, expression := range config.FailIfNotMatchesRegexp {
		re, err := regexp.Compile(expression)
		if err != nil {
			log.Errorf("Could not compile expression %q as regular expression: %s", expression, err)
			return false
		}
		if !re.Match(body) {
			return false
		}
	}
	return true
}

示例#9
文件: web2image.go 项目: CroweCybersecurity/web2image

/*-----------------------------------------------------------------------
|  Function: WebClient Render
|  Description: Takes screenshot of website, can be substituted for any Tool
|  Inputs:
|        final_url - URL of the Webpage After Redirects
|  Returns:
|        filename - Filename of the Rendered Picture
*-----------------------------------------------------------------------*/
func webclient_render(time_sec int, final_url string) (filename string) {

	// Strip Prefix on URL
	regex, _ := regexp.Compile("://")
	filename = regex.ReplaceAllString(final_url, "_")

	// Change (. or /) to _
	dot_regex, _ := regexp.Compile("\\.|/!$|:|/")
	filename = dot_regex.ReplaceAllString(filename, "_")

	// Add .PNG File Extension and Remove / to prevent directories
	end_regex, _ := regexp.Compile("_?/?$")
	filename = end_regex.ReplaceAllString(filename, ".png")

	file_path := "images/" + filename
	timeout := strconv.Itoa(time_sec)

	// Execute Render Command
	cmd := exec.Command("/usr/bin/python", "webkit2png/scripts.py", final_url, "-o", file_path, "-t", timeout)
	error := cmd.Start()
	if error != nil {
		log.Fatal(error)
	}
	cmd.Wait()
	fmt.Println("[+] Rendered:", filename)

	return
}

示例#10
文件: convert_times.go 项目: sirctseb/WorkloadExperiment

func makeTargets(lines []string, startIndex int) []Target {
	startRE, _ := regexp.Compile(`TargetStart, ([\d\.]+), (\d+), (\d+), (\d+)`)
	targetEndRE, _ := regexp.Compile(`(TargetHit|FriendHit|TargetTimeout), ([\d\.]+), ([\d\.]+), ([\d\.]+), (\d+)(, friend)?`)
	// get info on the three targets
	targetObjs := make([]Target, 3, 3)
	targetNumber := 0
	for i := startIndex; targetNumber < 3 && i < len(lines); i++ {
		// set target info
		if match := startRE.FindStringSubmatch(lines[i]); match != nil {
			targetObjs[targetNumber].startTime, _ = strconv.ParseFloat(match[1], 64)
			targetObjs[targetNumber].ID, _ = strconv.ParseInt(match[4], 10, 64)
			targetObjs[targetNumber].startX, _ = strconv.ParseFloat(match[2], 64)
			targetObjs[targetNumber].startY, _ = strconv.ParseFloat(match[3], 64)
			// find end of target
			for j := i; j < len(lines); j++ {
				if match := targetEndRE.FindStringSubmatch(lines[j]); match != nil {
					if id, _ := strconv.ParseInt(match[5], 10, 32); id == targetObjs[targetNumber].ID {
						targetObjs[targetNumber].endX, _ = strconv.ParseFloat(match[3], 64)
						targetObjs[targetNumber].endY, _ = strconv.ParseFloat(match[4], 64)
						targetObjs[targetNumber].endTime, _ = strconv.ParseFloat(match[2], 64)
						friend := strings.HasPrefix(match[1], "Friend") || len(match[6]) > 0
						targetObjs[targetNumber].enemy = !friend
						break
					}
				}
			}
			targetNumber++
		}
	}
	return targetObjs
}

示例#11
文件: router.go 项目: zond/hackyhack

func (w *resourceWrapper) Subscribe(sub *messages.Subscription) *messages.Error {
	compiledVerbReg, err := regexp.Compile(sub.VerbReg)
	if err != nil {
		return &messages.Error{
			Message: err.Error(),
			Code:    messages.ErrorCodeRegexp,
		}
	}
	compiledMethReg, err := regexp.Compile(sub.MethReg)
	if err != nil {
		return &messages.Error{
			Message: err.Error(),
			Code:    messages.ErrorCodeRegexp,
		}
	}
	compiledEventTypeReg, err := regexp.Compile(sub.EventTypeReg)
	if err != nil {
		return &messages.Error{
			Message: err.Error(),
			Code:    messages.ErrorCodeRegexp,
		}
	}
	w.router.RegisterSubscriber(w.resource, &subWrapper{
		sub:                  sub,
		compiledVerbReg:      compiledVerbReg,
		compiledMethReg:      compiledMethReg,
		compiledEventTypeReg: compiledEventTypeReg,
	})
	return nil
}

示例#12
文件: helper.go 项目: rose312/mzr

func Fixurl(current_url, url string) string {

	re1, _ := regexp.Compile("http[s]?://[^/]+")
	destrooturl := re1.FindString(current_url)

	//当url为://wahaha/xiaoxixi/tupian.png
	if strings.HasPrefix(url, "//") {
		url = "http:" + url
	} else if strings.HasPrefix(url, "/") {
		// re1,_ := regexp.Compile("http[s]?://[^/]+")
		// destrooturl := re1.FindString(current_url)
		url = destrooturl + url
	}

	//当url为:"../wahaha/xiaoxixi/tupian.png"、"./wahaha/xiaoxixi/tupian.png"、"wahaha/xiaoxixi/tupian.png"
	if !strings.HasPrefix(url, "/") && !strings.HasPrefix(url, "http") && !strings.HasPrefix(url, "https") {
		// current_url = strings.TrimSuffix(current_url, "/")
		if destrooturl == current_url {
			url = current_url + "/" + url
		} else {
			re2, _ := regexp.Compile("[^/]+?$")
			url = re2.ReplaceAllString(current_url, "") + url
		}

	}

	return url
}

示例#13
文件: parser_test.go 项目: carriercomm/facette

func (self *QueryParserSuite) TestParseListSeries(c *C) {
	queries, err := ParseQuery("list series")
	c.Assert(err, IsNil)
	c.Assert(queries, HasLen, 1)
	c.Assert(queries[0].IsListQuery(), Equals, true)
	listSeriesQuery := queries[0].GetListSeriesQuery()
	c.Assert(listSeriesQuery, NotNil)
	c.Assert(listSeriesQuery.HasRegex(), Equals, false)
	c.Assert(listSeriesQuery.IncludeSpaces, Equals, false)

	// test the case sensitive and case insensitive list series
	for i := 0; i < 2; i++ {
		query := "list series /^foo.*/"
		if i == 1 {
			query += "i"
		}
		queries, err = ParseQuery(query)
		c.Assert(err, IsNil)
		c.Assert(queries, HasLen, 1)
		c.Assert(queries[0].IsListSeriesQuery(), Equals, true)
		listSeriesQuery = queries[0].GetListSeriesQuery()
		c.Assert(listSeriesQuery, NotNil)
		c.Assert(listSeriesQuery.HasRegex(), Equals, true)
		var regularExpression *regexp.Regexp
		if i == 1 {
			regularExpression, _ = regexp.Compile("(?i)^foo.*")
		} else {
			regularExpression, _ = regexp.Compile("^foo.*")
		}
		c.Assert(listSeriesQuery.GetRegex(), DeepEquals, regularExpression)
		c.Assert(listSeriesQuery.IncludeSpaces, Equals, false)
	}
}

示例#14
文件: danfoss.go 项目: jaybora/solarcompare

func etotal(sid string, client *http.Client,
	initiateData *dataproviders.InitiateData, pv *dataproviders.PvData, resp *[]byte) error {

	reg, err := regexp.Compile(etotalRegEx)
	if err != nil {
		log.Fail(err.Error())
		return err
	}
	foundPart1 := reg.Find(*resp)
	if len(foundPart1) < 6 {
		err := fmt.Errorf("Could not find etotal in response from inverter")
		return err
	}

	reg, err = regexp.Compile(numberRegEx)
	if err != nil {
		log.Fail(err.Error())
	}
	foundPart2 := reg.Find(foundPart1)
	if len(foundPart2) < 2 {
		err = fmt.Errorf("Could not find etotal in response from inverter")
		return err
	}

	etotal := string(foundPart2[1:])
	log.Debugf("Current etotal is %s", etotal)
	etotalfloat, err := strconv.ParseFloat(etotal, 64)

	pv.EnergyTotal = float32(etotalfloat)
	return nil
}

示例#15
文件: terst.go 项目: CedarLogic/go-ethereum

func compareMatch(got, expect interface{}) (int, error) {
	switch got := got.(type) {
	case []byte:
		switch expect := expect.(type) {
		case string:
			matcher, err := regexp.Compile(expect)
			if err != nil {
				return 0, err
			}
			return match(got, matcher)
		case *regexp.Regexp:
			return match(got, expect)
		}
	default:
		if got, err := toString(got); err == nil {
			switch expect := expect.(type) {
			case string:
				matcher, err := regexp.Compile(expect)
				if err != nil {
					return 0, err
				}
				return matchString(got, matcher)
			case *regexp.Regexp:
				return matchString(got, expect)
			}
		} else {
			return 0, err
		}
	}
	return 0, errInvalid
}

示例#16
文件: cert_util.go 项目: worldspawn/vault

// Given a set of requested names for a certificate, verifies that all of them
// match the various toggles set in the role for controlling issuance.
// If one does not pass, it is returned in the string argument.
func validateCommonNames(req *logical.Request, commonNames []string, role *roleEntry) (string, error) {
	hostnameRegex, err := regexp.Compile(`^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$`)
	if err != nil {
		return "", fmt.Errorf("Error compiling hostname regex: %s", err)
	}
	subdomainRegex, err := regexp.Compile(`^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]))*$`)
	if err != nil {
		return "", fmt.Errorf("Error compiling subdomain regex: %s", err)
	}
	for _, name := range commonNames {
		if role.AllowLocalhost && name == "localhost" {
			continue
		}

		sanitizedName := name
		isWildcard := false
		if strings.HasPrefix(name, "*.") {
			sanitizedName = name[2:]
			isWildcard = true
		}
		if !hostnameRegex.MatchString(sanitizedName) {
			return name, nil
		}
		if role.AllowAnyName {
			continue
		}

		if role.AllowTokenDisplayName {
			if name == req.DisplayName {
				continue
			}

			if role.AllowSubdomains {
				if strings.HasSuffix(name, "."+req.DisplayName) {
					continue
				}
			}
		}

		if len(role.AllowedBaseDomain) != 0 {
			if strings.HasSuffix(name, "."+role.AllowedBaseDomain) {
				if role.AllowSubdomains {
					continue
				}

				if subdomainRegex.MatchString(strings.TrimSuffix(name, "."+role.AllowedBaseDomain)) {
					continue
				}

				if isWildcard && role.AllowedBaseDomain == sanitizedName {
					continue
				}
			}
		}

		return name, nil
	}

	return "", nil
}

示例#17
文件: regexp_Find.go 项目: jemoonkim/golangbook

func main() {
	re1, _ := regexp.Compile("\\.[a-zA-Z]+$")
	s1 := re1.FindString("hello example.com") // 정규표현식으로 문자열 검색
	fmt.Println(s1)                           // .com: 맨 마지막에 오는 ".영문"이므로 .com

	re2, _ := regexp.Compile("([a-zA-Z]+)(\\.[a-zA-Z]+)$")
	s2 := re2.FindStringSubmatch("hello example.com") // 문자열을 검색한 뒤 찾은 문자열과
	// 괄호로 구분된 하위 항목 리턴
	fmt.Println(s2) // [example.com example .com]: 맨 마지막에 오는 "영문.영문"을 찾고
	// 하위 항목 example과 .com을 리턴

	n2 := re2.FindStringSubmatchIndex("example.com") // 문자열을 검색한 뒤 찾은 문자열의
	// 위치와 괄호로 구분한 하위 항목의 위치를 리턴
	fmt.Println(n2) // [0 11 0 7 7 11]

	re3, _ := regexp.Compile("\\.[a-zA-Z.]+")
	s3 := re3.FindAllString("hello.co.kr world hello.net example.com", -1)
	// 정규표현식에 해당하는 모든 문자열 검색
	fmt.Println(s3) // [.co.kr .net .com]: ".영문."에 해당하는 모든 문자열(-1)

	s3 = re3.FindAllString("hello.co.kr world hello.net example.com", 2)
	// 정규표현식에 해당하는 모든 문자열 검색
	fmt.Println(s3) // [.co.kr .net]:  ".영문."에 해당하는 문자열 2개 리턴

	n3 := re3.FindAllStringIndex("hello.co.kr world hello.net example.com", -1)
	// 정규표현식에 해당하는 모든 문자열의 위치를 리턴
	fmt.Println(n3) // [[5 11] [23 27] [35 39]]: ".영문."에 해당하는 모든 문자열의 위치
}

示例#18
文件: config.go 项目: google/syzkaller

func parseSuppressions(cfg *Config) error {
	// Add some builtin suppressions.
	supp := append(cfg.Suppressions, []string{
		"panic: failed to start executor binary",
		"panic: executor failed: pthread_create failed",
		"panic: failed to create temp dir",
		"fatal error: runtime: out of memory",
		"fatal error: unexpected signal during runtime execution", // presubmably OOM turned into SIGBUS
		"Out of memory: Kill process .* \\(syz-fuzzer\\)",
		"lowmemorykiller: Killing 'syz-fuzzer'",
		//"INFO: lockdep is turned off", // printed by some sysrq that dumps scheduler state, but also on all lockdep reports
	}...)
	for _, s := range supp {
		re, err := regexp.Compile(s)
		if err != nil {
			return fmt.Errorf("failed to compile suppression '%v': %v", s, err)
		}
		cfg.ParsedSuppressions = append(cfg.ParsedSuppressions, re)
	}
	for _, ignore := range cfg.Ignores {
		re, err := regexp.Compile(ignore)
		if err != nil {
			return fmt.Errorf("failed to compile ignore '%v': %v", ignore, err)
		}
		cfg.ParsedIgnores = append(cfg.ParsedIgnores, re)
	}
	return nil
}

示例#19
文件: data_access.go 项目: jwhitehorn/web_performance

func (self *DataAccess) escape(name string) string {
	wordEx, _ := regexp.Compile(`\W`)
	dashEx, _ := regexp.Compile(`-+`)

	safe := wordEx.ReplaceAllString(name, "-")
	return dashEx.ReplaceAllString(strings.ToLower(safe), "-")
}

示例#20
文件: BrownLegoCSS.go 项目: spiraleye/BrownLegoCSS

func (c *CssCompressor) Compress() []byte {
	c.extractDataUris()
	c.extractComments()

	// preserve strings so their content doesn't get accidentally minified
	c.extractStrings()

	// strings are safe, now wrestle the comments
	c.processComments()

	// Normalize all whitespace strings to single spaces. Easier to work with that way.
	re, _ := regexp.Compile("\\s+")
	c.Css = re.ReplaceAll(c.Css, []byte(" "))

	// Do lots and lots and lots of fun things
	c.performGeneralCleanup()

	// Replace multiple semi-colons in a row with a single one
	re, _ = regexp.Compile(";;+")
	c.Css = re.ReplaceAll(c.Css, []byte(";"))

	// restore preserved comments and strings
	for i, t := range c.preservedTokens {
		c.Css = bytes.Replace(c.Css, []byte("___YUICSSMIN_PRESERVED_TOKEN_"+strconv.Itoa(i)+"___"), []byte(t), -1)
	}

	// Trim the final string (for any leading or trailing white spaces)
	c.Css = bytes.TrimSpace(c.Css)

	// Hooray, we're done!
	return c.Css
}

示例#21
文件: mpCzPa9i.Go 项目: micabressan/trabajo_final

func main() {
    r, err := regexp.Compile(`Hello`)
        myRegex := regexp.MustCompile("/abc/zzz/")
        myString := "abc def ghi"
        myRegex.ReplaceAllString(myString, "$2 $1") // "def abc ghi"


        reg, MyErr := regexp.Compile("\\x00")
        if MyErr != nil {
                panic(MyErr)
        }
        //safe := reg.ReplaceAllString("a*- +fe 5 v90 34,j*.A    E6", "")


    if err != nil {
        fmt.Printf("There is a problem with your regexp.\n")
        return
    }

    file, err := os.Open("DataWithNullsEveryOtherCharacter.csv")
    if err != nil {
        panic(err)
    }

    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
                myStr := scanner.Text()
        // fmt.Printf(">>[%s]\n", myStr)
                safe := reg.ReplaceAllString(myStr, "")
        fmt.Printf("%s\n", safe)
    }

示例#22
文件: slackimport.go 项目: Rudloff/platform

func SlackConvertUserMentions(users []SlackUser, posts map[string][]SlackPost) map[string][]SlackPost {
	var regexes = make(map[string]*regexp.Regexp, len(users))
	for _, user := range users {
		r, err := regexp.Compile("<@" + user.Id + `(\|` + user.Username + ")?>")
		if err != nil {
			l4g.Warn(utils.T("api.slackimport.slack_convert_user_mentions.compile_regexp_failed.warn"), user.Id, user.Username)
			continue
		}
		regexes["@"+user.Username] = r
	}

	// Special cases.
	regexes["@here"], _ = regexp.Compile(`<!here\|@here>`)
	regexes["@channel"], _ = regexp.Compile("<!channel>")
	regexes["@all"], _ = regexp.Compile("<!everyone>")

	for channelName, channelPosts := range posts {
		for postIdx, post := range channelPosts {
			for mention, r := range regexes {
				post.Text = r.ReplaceAllString(post.Text, mention)
				posts[channelName][postIdx] = post
			}
		}
	}

	return posts
}

示例#23
文件: xtremio.go 项目: pb-it/rexray

func (d *xtremIODriver) getLocalDeviceByID() (map[string]string, error) {
	mapDiskByID := make(map[string]string)
	diskIDPath := "/dev/disk/by-id"
	files, err := ioutil.ReadDir(diskIDPath)
	if err != nil {
		return nil, err
	}

	var match1 *regexp.Regexp
	var match2 string

	if d.r.Config.XtremIODeviceMapper || d.r.Config.XtremIOMultipath {
		match1, _ = regexp.Compile(`^dm-name-\w*$`)
		match2 = `^dm-name-\d+`
	} else {
		match1, _ = regexp.Compile(`^wwn-0x\w*$`)
		match2 = `^wwn-0x`
	}

	for _, f := range files {
		if match1.MatchString(f.Name()) {
			naaName := strings.Replace(f.Name(), match2, "", 1)
			naaName = naaName[len(naaName)-16:]
			devPath, _ := filepath.EvalSymlinks(fmt.Sprintf("%s/%s", diskIDPath, f.Name()))
			mapDiskByID[naaName] = devPath
		}
	}
	return mapDiskByID, nil
}

示例#24
文件: tracker_test.go 项目: randeepbhatia/Octopus

func TestBuildGroup(t *testing.T) {
	reg1, _ := regexp.Compile(`[Le]{2}`)
	result1 := &CounterAction{1, 0, 0}
	reg2, _ := regexp.Compile(`[Spo]{3}`)
	result2 := &CounterAction{2, 0, 0}
	context := &Context{"session1", "path1"}

	fg := NewFunnelGroup(context)
	fg.addTracker(1, reg1, 100, result1)
	fg.addTracker(2, reg2, 100, result2)

	reader := strings.NewReader(`Mrs. Leonora Spocky`)
	var r rune = 0
	var size int = 0
	var err error = nil
	for err == nil {
		r, size, err = reader.ReadRune()
		log.Printf("Write %#v %#v %#v", r, size, err)
		fg.WriteRune(r, size, err)
	}

	time.Sleep(10 * time.Millisecond)

	if !((result1.CompleteCounter == 1) && (result1.MatchCounter == 1)) {
		t.Fatal("Failed Result %#v", result1)
	}

	if !((result2.CompleteCounter == 1) && (result2.MatchCounter == 1)) {
		t.Fatal("Failed Result %#v", result2)
	}
}

示例#25
文件: inmem.go 项目: angelabier1/pachyderm

func includeCell(f *btdpb.RowFilter, fam, col string, cell cell) bool {
	if f == nil {
		return true
	}
	// TODO(dsymonds): Implement many more filters.
	switch f := f.Filter.(type) {
	default:
		log.Printf("WARNING: don't know how to handle filter of type %T (ignoring it)", f)
		return true
	case *btdpb.RowFilter_FamilyNameRegexFilter:
		pat := string(f.FamilyNameRegexFilter)
		rx, err := regexp.Compile(pat)
		if err != nil {
			log.Printf("Bad family_name_regex_filter pattern %q: %v", pat, err)
			return false
		}
		return rx.MatchString(fam)
	case *btdpb.RowFilter_ColumnQualifierRegexFilter:
		pat := string(f.ColumnQualifierRegexFilter)
		rx, err := regexp.Compile(pat)
		if err != nil {
			log.Printf("Bad column_qualifier_regex_filter pattern %q: %v", pat, err)
			return false
		}
		return rx.MatchString(col)
	case *btdpb.RowFilter_ValueRegexFilter:
		pat := string(f.ValueRegexFilter)
		rx, err := regexp.Compile(pat)
		if err != nil {
			log.Printf("Bad value_regex_filter pattern %q: %v", pat, err)
			return false
		}
		return rx.Match(cell.value)
	}
}

示例#26
文件: scan_common.go 项目: kisom/cfssl

// RunScans iterates over AllScans, running each scan that matches the family
// and scanner regular expressions concurrently.
func (fs FamilySet) RunScans(host, ip, family, scanner string, timeout time.Duration) (map[string]FamilyResult, error) {
	hostname, port, err := net.SplitHostPort(host)
	if err != nil {
		hostname = host
		port = "443"
	}

	var addr string
	if net.ParseIP(ip) != nil {
		addr = net.JoinHostPort(ip, port)
	} else {
		addr = net.JoinHostPort(hostname, port)
	}

	familyRegexp, err := regexp.Compile(family)
	if err != nil {
		return nil, err
	}

	scannerRegexp, err := regexp.Compile(scanner)
	if err != nil {
		return nil, err
	}

	ctx := newContext(addr, hostname, familyRegexp, scannerRegexp, len(fs))
	for familyName, family := range fs {
		familyCtx := ctx.newfamilyContext(len(family.Scanners))
		for scannerName, scanner := range family.Scanners {
			go familyCtx.runScanner(familyName, scannerName, scanner)
		}
	}

	return ctx.copyResults(timeout), nil
}

示例#27
文件: service.go 项目: velankanisys/bosh

func (oc concreteService) GetInfo() (ntpInfo NTPInfo) {
	ntpPath := filepath.Join(oc.dirProvider.BaseDir(), "/bosh/log/ntpdate.out")
	content, err := oc.fs.ReadFileString(ntpPath)
	if err != nil {
		ntpInfo = NTPInfo{Message: "file missing"}
		return
	}

	lines := strings.Split(strings.Trim(content, "\n"), "\n")
	lastLine := lines[len(lines)-1]

	regex, _ := regexp.Compile(`^(.+)\s+ntpdate.+offset\s+(-*\d+\.\d+)`)
	badServerRegex, _ := regexp.Compile(`no server suitable for synchronization found`)
	matches := regex.FindAllStringSubmatch(lastLine, -1)

	if len(matches) > 0 && len(matches[0]) == 3 {
		ntpInfo = NTPInfo{
			Timestamp: matches[0][1],
			Offset:    matches[0][2],
		}
	} else if badServerRegex.MatchString(lastLine) {
		ntpInfo = NTPInfo{Message: "bad ntp server"}
	} else {
		ntpInfo = NTPInfo{Message: "bad file contents"}
	}

	return
}

示例#28
文件: gopp.go 项目: skelterjohn/gopp

func (g Grammar) TokenREs() (res []TypedRegexp, err error) {
	// first get all the literals, and sort them longest first (so smaller ones don't eat larger ones).
	literals := map[string]bool{}
	g.CollectLiterals(literals)
	sortedLiterals := literalSorter{}
	for literal := range literals {
		sortedLiterals = append(sortedLiterals, literal)
	}
	sort.Sort(sortedLiterals)
	for _, literal := range sortedLiterals {
		re, err := regexp.Compile("^(" + regexp.QuoteMeta(literal) + ")")
		if err != nil {
			panic("regexp.QuoteMeta returned something that didn't compile")
		}
		res = append(res, TypedRegexp{"RAW", re})
	}
	for _, symbol := range g.Symbols {
		var re *regexp.Regexp
		re, err = regexp.Compile("^" + symbol.Pattern)
		if err != nil {
			return
		}
		res = append(res, TypedRegexp{symbol.Name, re})
	}
	return
}

示例#29
文件: cli.go 项目: rjeczalik/pulsekit

func (cli *CLI) init(ctx *cli.Context) error {
	if ctx.GlobalBool("prtg") {
		cli.Err, cli.Out = prtg.Err, prtg.Out
	}
	var err error
	if cli.cred, err = cli.Store.Load(); err == nil {
		cli.c, err = cli.Client(cli.cred.URL, cli.cred.User, cli.cred.Pass)
	}
	if err != nil {
		cli.cred = &Creds{ctx.GlobalString("addr"), ctx.GlobalString("user"), ctx.GlobalString("pass")}
		if cli.c, err = cli.Client(cli.cred.URL, cli.cred.User, cli.cred.Pass); err != nil {
			return err
		}
	}
	a, p, s, o := ctx.GlobalString("agent"), ctx.GlobalString("project"), ctx.GlobalString("stage"), ctx.GlobalString("output")
	if cli.a, err = regexp.Compile(a); err != nil {
		return err
	}
	if cli.p, err = regexp.Compile(p); err != nil {
		return err
	}
	if cli.s, err = regexp.Compile(s); err != nil {
		return err
	}
	if cli.o, err = regexp.Compile(o); err != nil {
		return err
	}
	if cli.d, err = time.ParseDuration(ctx.GlobalString("timeout")); err != nil {
		return err
	}
	cli.n, cli.rev = int64(ctx.GlobalInt("build")), ctx.GlobalString("revision")
	cli.c.SetTimeout(cli.d)
	return nil
}

示例#30
文件: dashboard_controller.go 项目: Cepave/fe

//counter query by endpoints
func (this *DashBoardController) CounterQuery() {
	baseResp := this.BasicRespGen()
	_, err := this.SessionCheck()
	if err != nil {
		this.ResposeError(baseResp, err.Error())
		return
	}
	endpoints := this.GetString("endpoints", "")
	endpointcheck, _ := regexp.Compile("^\\s*\\[\\s*\\]\\s*$")
	if endpoints == "" || endpointcheck.MatchString(endpoints) {
		this.ResposeError(baseResp, "query string is empty, please check it")
		return
	}
	rexstr, _ := regexp.Compile("^\\s*\\[\\s*|\\s*\\]\\s*$")
	endpointsArr := strings.Split(rexstr.ReplaceAllString(endpoints, ""), ",")
	limitNum, _ := this.GetInt("limit", 0)
	counters, err := dashboard.QueryCounterByEndpoints(endpointsArr, limitNum)
	switch {
	case err != nil:
		this.ResposeError(baseResp, err.Error())
		return
	case len(counters) == 0:
		baseResp.Data["counters"] = []string{}
	default:
		baseResp.Data["counters"] = counters
	}
	this.ServeApiJson(baseResp)
	return
}

展开阅读全文