100+ results for 'regex ansi lang:go'
Not the results you expected?
simple.go
(https://code.google.com/p/sre2/)
Go · 143 lines
✨ Summary
This Go code implements a regular expression (regex) engine, allowing users to match strings against predefined patterns. It uses a finite state machine approach to efficiently search for matches in input strings, capturing groups and returning success indicators. The code is designed to be efficient and scalable, using techniques like sparse bitsets and linked lists to minimize memory usage.
This Go code implements a regular expression (regex) engine, allowing users to match strings against predefined patterns. It uses a finite state machine approach to efficiently search for matches in input strings, capturing groups and returning success indicators. The code is designed to be efficient and scalable, using techniques like sparse bitsets and linked lists to minimize memory usage.
1 package sre2
3 func (r *sregexp) Match(src string) bool {
4 success, _ := r.run(src, false)
5 return success
6 }
8 func (r *sregexp) MatchIndex(src string) []int {
9 _, capture := r.run(src, true)
10 return capture
11 }
13 func (r *sregexp) run(src string, submatch bool) (success bool, capture []int) {
14 curr := makeStateList(len(r.prog))
15 next := makeStateList(len(r.prog))
go1pkgrename.go (git://github.com/tav/go.git) Go · 146 lines
main.go
(https://code.google.com/p/godag/)
Go · 546 lines
✨ Summary
The code is a command-line tool called godag that compiles and builds Go projects. It takes a source directory as input, parses command-line options, and performs various actions such as formatting code, linking binaries, and running unit tests. The output includes information about the compiled project, such as package info, compile order, and test results.
The code is a command-line tool called godag that compiles and builds Go projects. It takes a source directory as input, parses command-line options, and performs various actions such as formatting code, linking binaries, and running unit tests. The output includes information about the compiled project, such as package info, compile order, and test results.
503 -q --quiet silent, print only errors
504 -L --lib write objects to other dir (!src)
505 -M --main regex to select main package
506 -a --all link main pkgs to bin/nameOfMainDir
507 -D --dot create a graphviz dot file
508 -I import package directories
509 -t --test run all unit-tests
510 -m --match regex to select unit-tests
511 -b --bench regex to select benchmarks
riak.go
(https://code.google.com/p/goriak/)
Go · 530 lines
✨ Summary
This Go code implements a client for interacting with a Riak NoSQL database using its REST API. It provides methods for making GET, PUT, and other requests to the database, as well as an asynchronous request API that allows for concurrent requests. The code also includes support for callbacks and response channels, enabling developers to handle responses in a flexible manner.
This Go code implements a client for interacting with a Riak NoSQL database using its REST API. It provides methods for making GET, PUT, and other requests to the database, as well as an asynchronous request API that allows for concurrent requests. The code also includes support for callbacks and response channels, enabling developers to handle responses in a flexible manner.
49 "strconv"
50 "strings"
51 "regexp"
52 //"fmt"
53 )
305 location, ok := resp.Header["Location"]
306 if ok {
307 // TODO: regexp would be much cleaner
308 parts := strings.Split(location, "/", -1)
309 if len(parts) > 3 {
371 links, ok := resp.Header["Link"]
372 if ok {
373 // This should all be REGEXP but just haven't gotten around to
374 // it yet.
375 var LINK_SPLITTER = regexp.MustCompile("^<.*,")
regex.go
(git://github.com/bobappleyard/bwl.git)
Go · 285 lines
✨ Summary
This Go code implements a lexer for regular expressions. It creates a lexical analysis system that can parse and match strings against given regex patterns, replacing matched substrings with user-defined functions. The code uses a stack machine approach to handle nested subexpressions and character sets. It returns a BasicState object representing the final state of the parsing process.
This Go code implements a lexer for regular expressions. It creates a lexical analysis system that can parse and match strings against given regex patterns, replacing matched substrings with user-defined functions. The code uses a stack machine approach to handle nested subexpressions and character sets. It returns a BasicState object representing the final state of the parsing process.
41 }
43 func (self *Lexer) ForceRegex(re string, m RegexSet) *BasicState {
44 res, err := self.Regex(re, m)
50 }
52 func (self *Lexer) Regexes(m, regexes RegexSet) {
53 for i, x := range regexes {
60 }
62 func NewRegex(re string, m RegexSet) *Regex {
63 l := New()
64 l.ForceRegex(re, m).SetFinal(0)
121 }
123 func (self *BasicState) AddRegex(re string, m RegexSet) (*BasicState, error) {
124 if m == nil {
125 m = defaultMeta
reg.go
(git://github.com/moovweb/rubex.git)
Go · 135 lines
✨ Summary
The Go code compares the performance of two regular expression libraries, rubex and the native Go library, on a large string. It measures the average time taken by each library to match a pattern against the string in multiple goroutines, demonstrating a significant speed difference between the two libraries. The output shows the average time taken by each library for each run.
The Go code compares the performance of two regular expression libraries, rubex and the native Go library, on a large string. It measures the average time taken by each library to match a pattern against the string in multiple goroutines, demonstrating a significant speed difference between the two libraries. The output shows the average time taken by each library for each run.
The Go code compares the performance of two regular expression libraries, rubex and the native Go library, on a large string. It measures the average time taken by each library to match a pattern against the string in multiple goroutines, demonstrating a significant speed difference between the two libraries. The output shows the average time taken by each library for each run.
The Go code compares the performance of two regular expression libraries, rubex and the native Go library, on a large string. It measures the average time taken by each library to match a pattern against the string in multiple goroutines, demonstrating a significant speed difference between the two libraries. The output shows the average time taken by each library for each run.
1 // Comparing the speeds of the golang native regex library and rubex.
2 // The numbers show a dramatic difference, with rubex being nearly 400
3 // times slower than the native go libraries. Unfortunately for us,
4 // the native go libraries have a different regex behavior than rubex,
5 // so we'll have to hack at it a bit to fit our needs if we decide to use it.
6 // (which we should, I mean, come on, 400 times faster? That's mad wins.)
11 import re "github.com/moovweb/rubex"
12 import "time"
13 import "regexp"
14 import "runtime"
15 import "os"
44 re2 = make([]Matcher, NUM)
45 for i := 0; i < NUM; i++ {
46 re1[i] = regexp.MustCompile("[a-c]*$")
47 re2[i] = re.MustCompile("[a-c]*$")
48 }
util.go (git://github.com/robfig/revel.git) Go · 172 lines
router.go (git://github.com/dbrain/soggy.git) Go · 325 lines
47 type RouteBundle struct {
48 method string
49 path *regexp.Regexp
50 Routes []*Route
51 }
66 var httpResponseWriterType = reflect.TypeOf((*http.ResponseWriter)(nil)).Elem()
68 func (route *Route) CacheCallType(routePath *regexp.Regexp) {
69 handlerType := route.handler.Type()
175 }
177 func (route *Route) CallHandler(ctx *Context, routePath *regexp.Regexp, relativePath string) {
178 var args []reflect.Value
179 callType := route.callType
265 rawRegex := "^" + SaneURLPath(path) + "$"
266 routeRegex, err := regexp.Compile(rawRegex)
267 if err != nil {
268 log.Println("Could not compile route regex", rawRegex, ":", err)
pastee.go (https://github.com/msparks/pastee.git) Go · 211 lines
prepared_query.go (https://github.com/backstage/backstage.git) Go · 252 lines
clone.go (git://github.com/defunkt/hub.git) Go · 156 lines
3 import (
4 "fmt"
5 "regexp"
6 "strings"
76 p.Parse(args.Params)
78 nameWithOwnerRegexp := regexp.MustCompile(NameWithOwnerRe)
79 for _, i := range p.PositionalIndices {
80 a := args.Params[i]
81 if nameWithOwnerRegexp.MatchString(a) && !isCloneable(a) {
82 url := getCloneURL(a, isSSH, args.Command != "submodule")
83 args.ReplaceParam(i, url)
merge.go (git://github.com/defunkt/hub.git) Go · 100 lines
3 import (
4 "fmt"
5 "regexp"
7 "github.com/github/hub/v2/github"
54 }
56 pullURLRegex := regexp.MustCompile("^pull/(\\d+)")
57 projectPath := url.ProjectPath()
58 if !pullURLRegex.MatchString(projectPath) {
60 }
62 id := pullURLRegex.FindStringSubmatch(projectPath)[1]
63 gh := github.NewClient(url.Project.Host)
64 pullRequest, err := gh.PullRequest(url.Project, id)
metaphone.go (git://github.com/sanjayc77/metaphone.git) Go · 173 lines
7 import (
8 "fmt"
9 "regexp"
10 "bytes"
11 "strings"
35 func dropInitialLetters(token string) string {
36 if regexp.MustCompile("^(kn|gn|pn|ae|wr)").MatchString(token) {
37 return token[1:]
38 }
42 func dropBafterMAtEnd(token string) string {
43 return regexp.MustCompile("mb$").ReplaceAllLiteralString(token, "m")
44 }
mprof_test.go (git://github.com/axw/llgo.git) Go · 101 lines
simplify.go (git://github.com/tav/go.git) Go · 151 lines
13 // The returned regexp may share structure with or be the original.
14 func (re *Regexp) Simplify() *Regexp {
15 if re == nil {
16 return nil
18 switch re.Op {
19 case OpCapture, OpConcat, OpAlternate:
20 // Simplify children, building new Regexp if children change.
21 nre := re
22 for i, sub := range re.Sub {
84 // Build leading prefix: xx.
85 var prefix *Regexp
86 if re.Min > 0 {
87 prefix = &Regexp{Op: OpConcat}
132 // Letting them call simplify1 makes sure the expressions they
133 // generate are simple.
134 func simplify1(op Op, flags Flags, sub, re *Regexp) *Regexp {
135 // Special case: repeat the empty string as much as
136 // you want, but it's still the empty string.
sqlmock.go (https://bitbucket.org/kamilsk/click.git) Go · 439 lines
booking.go (git://github.com/robfig/revel.git) Go · 114 lines
5 "github.com/coopernurse/gorp"
6 "github.com/robfig/revel"
7 "regexp"
8 "time"
9 )
22 Beds int
24 // Transient
25 CheckInDate time.Time
26 CheckOutDate time.Time
37 v.Required(booking.CheckOutDate)
39 v.Match(booking.CardNumber, regexp.MustCompile(`\d{16}`)).
40 Message("Credit card number must be numeric and 16 digits")
i18n.go (git://github.com/robfig/revel.git) Go · 188 lines
yenc.go (git://github.com/DanielMorsing/gonzbee.git) Go · 381 lines
functions.go (git://github.com/speedata/publisher.git) Go · 96 lines
6 "fmt"
7 "io"
8 "regexp"
9 "strings"
10 )
12 // replace() xpath function
13 func Replace(text []byte, rexpr string, repl []byte) []byte {
14 r, err := regexp.Compile(rexpr)
15 if err != nil {
16 return nil
20 // go on the other hand uses $12 for $12 and never for $1, so you have to write
21 // $1 as ${1} if there is text after the $1.
22 // We escape the $n backwards to prevent expansion of $12 to ${1}2
23 for i := r.NumSubexp(); i > 0; i-- {
24 // first create rexepx that match "$i"
uuid.go (git://github.com/nu7hatch/gouuid.git) Go · 173 lines
doc.go (git://github.com/mattn/go-sqlite3.git) Go · 135 lines
29 You can write your own extension module for sqlite3. For example, below is an
30 extension for a Regexp matcher operation.
32 #include <pcre.h>
37 SQLITE_EXTENSION_INIT1
38 static void regexp_func(sqlite3_context *context, int argc, sqlite3_value **argv) {
39 if (argc >= 2) {
40 const char *target = (const char *)sqlite3_value_text(argv[1]);
114 &sqlite3.SQLiteDriver{
115 ConnectHook: func(conn *sqlite3.SQLiteConn) error {
116 return conn.RegisterFunc("regexp", regex, true)
117 },
118 })
splib.go (git://github.com/speedata/publisher.git) Go · 201 lines
10 "os"
11 "path/filepath"
12 "regexp"
13 "strings"
14 "unsafe"
68 //export tokenize
69 func tokenize(text, rexpr string) **C.char {
70 r := regexp.MustCompile(rexpr)
71 idx := r.FindAllStringIndex(text, -1)
72 pos := 0
82 //export replace
83 func replace(text string, rexpr string, repl string) *C.char {
84 r := regexp.MustCompile(rexpr)
86 // xpath uses $12 for $12 or $1, depending on the existence of $12 or $1.
types.go (https://bitbucket.org/Jake-Qu/kubernetes-mirror.git) Go · 112 lines
35 // BootstrapTokenIDKey is the id of this token. This can be transmitted in the
36 // clear and encoded in the name of the secret. It must be a random 6 character
37 // string that matches the regexp `^([a-z0-9]{6})$`. Required.
38 BootstrapTokenIDKey = "token-id"
40 // BootstrapTokenSecretKey is the actual secret. It must be a random 16 character
41 // string that matches the regexp `^([a-z0-9]{16})$`. Required.
42 BootstrapTokenSecretKey = "token-secret"
91 BootstrapDefaultGroup = "system:bootstrappers"
93 // BootstrapGroupPattern is the valid regex pattern that all groups
94 // assigned to a bootstrap token by BootstrapTokenExtraGroupsKey must match.
95 // See also util.ValidateBootstrapGroupName()
node.go (https://bitbucket.org/afawkes/acs-engine.git) Go · 179 lines
7 "log"
8 "os/exec"
9 "regexp"
10 "strings"
11 "time"
57 type Condition struct {
58 LastHeartbeatTime time.Time `json:"lastHeartbeatTime"`
59 LastTransitionTime time.Time `json:"lastTransitionTime"`
60 Message string `json:"message"`
61 Reason string `json:"reason"`
141 }
142 split := strings.Split(string(out), "\n")
143 exp, err := regexp.Compile(ServerVersion)
144 if err != nil {
145 log.Printf("Error while compiling regexp:%s", ServerVersion)
suite.go (https://github.com/backstage/backstage.git) Go · 183 lines
curly.go (https://bitbucket.org/butbox/traefik.git) Go · 162 lines
7 import (
8 "net/http"
9 "regexp"
10 "sort"
11 "strings"
76 paramCount++
77 if colon := strings.Index(routeToken, ":"); colon != -1 {
78 // match by regex
79 matchesToken, matchesRemainder := c.regularMatchesPathToken(routeToken, colon, requestToken)
80 if !matchesToken {
105 return true, true
106 }
107 matched, err := regexp.MatchString(regPart, requestToken)
108 return (matched && err == nil), false
109 }
charset_test.go (https://codeberg.org/Codeberg/gitea.git) Go · 252 lines
151 // res = ToUTF8("Hola, así cómo \x81ños")
152 // Do not fail for differences in invalid cases, as the library might change the conversion criteria for those
153 // assert.Regexp(t, "^Hola, así cómo", res)
155 // Japanese (Shift-JIS)
231 assert.Contains(t, encoding, "ISO-8859")
233 setting.Repository.AnsiCharset = "placeholder"
234 testSuccess(b, "placeholder")
thread.go (git://github.com/drbawb/goChanner.git) Go · 127 lines
13 import (
14 // "fmt"
15 "regexp"
16 "html"
17 "strings"
41 //Extracts meta-data from a thread that has an underlying DOM tree, returns err. otherwise.
42 func (t *Thread) ExtractMeta() {
43 regex := regexp.MustCompile(`[0-9]+`)
45 for aix := 0; aix < len(t.Node.Attr); aix++ {
46 if t.Node.Attr[aix].Key == "id" {
47 //fmt.Printf("threads id is: %s", t.Node.Attr[aix].Val)
48 t.ThreadNo = regex.FindString(t.Node.Attr[aix].Val)
49 }
50 }
parse.go (git://github.com/jacobsa/igo.git) Go · 121 lines
10 "go/parser"
11 "igo/set"
12 "regexp"
13 "strings"
14 )
60 }
62 var importRegexp *regexp.Regexp = regexp.MustCompile(`"(.+)"`)
64 func (v *importVisitor) Visit(node interface{}) ast.Visitor {
66 case *ast.ImportSpec:
67 component := node.(*ast.ImportSpec).Path
68 matches := importRegexp.MatchStrings(string(component.Value))
69 if len(matches) < 2 {
70 // skipping this?
jsonfilelog.go (https://github.com/dotcloud/docker.git) Go · 187 lines
config.go (https://github.com/backstage/backstage.git) Go · 187 lines
26 RandomSeed int64
27 RandomizeAllSpecs bool
28 RegexScansFilePath bool
29 FocusString string
30 SkipString string
75 flagSet.StringVar(&(GinkgoConfig.SkipString), prefix+"skip", "", "If set, ginkgo will only run specs that do not match this regular expression.")
77 flagSet.BoolVar(&(GinkgoConfig.RegexScansFilePath), prefix+"regexScansFilePath", false, "If set, ginkgo regex matching also will look at the file path (code location).")
79 flagSet.IntVar(&(GinkgoConfig.FlakeAttempts), prefix+"flakeAttempts", 1, "Make up to this many attempts to run each spec. Please note that if any of the attempts succeed, the suite will not be failed. But any failures will still be recorded.")
156 }
158 if ginkgo.RegexScansFilePath {
159 result = append(result, fmt.Sprintf("--%sregexScansFilePath", prefix))
merge.go (https://gitlab.com/shengwenzhu/hub.git) Go · 86 lines
3 import (
4 "fmt"
5 "regexp"
7 "github.com/github/hub/github"
47 }
49 pullURLRegex := regexp.MustCompile("^pull/(\\d+)")
50 projectPath := url.ProjectPath()
51 if !pullURLRegex.MatchString(projectPath) {
53 }
55 id := pullURLRegex.FindStringSubmatch(projectPath)[1]
56 gh := github.NewClient(url.Project.Host)
57 pullRequest, err := gh.PullRequest(url.Project, id)
config_center.go (https://bitbucket.org/simpleelegant/godi.git) Go · 227 lines
6 "fmt"
7 "net/url"
8 "regexp"
9 "strings"
139 dimeExp := `\A([^\$\%\&\+\(/)\[\]\" "\"])*\z`
140 dimRegexVar, err := regexp.Compile(dimeExp)
141 if err != nil {
142 lager.Logger.Error("not a valid regular expression", err)
144 }
146 if !dimRegexVar.Match([]byte(serviceName)) {
147 lager.Logger.Errorf(nil, "invalid value for dimension info, doesnot setisfy the regular expression for dimInfo:%s",
148 serviceName)
EvaluableExpression_sql.go (https://bitbucket.org/jyotiswarp/ppc.git) Go · 167 lines
version.go (https://bitbucket.org/butbox/traefik.git) Go · 375 lines
5 "errors"
6 "fmt"
7 "regexp"
8 "strconv"
9 "strings"
12 // The compiled version of the regex created at init() is cached here so it
13 // only needs to be created once.
14 var versionRegex *regexp.Regexp
15 var validPrereleaseRegex *regexp.Regexp
27 )
29 // SemVerRegex is the regular expression used to parse a semantic version.
30 const SemVerRegex string = `v?([0-9]+)(\.[0-9]+)?(\.[0-9]+)?` +
46 func init() {
47 versionRegex = regexp.MustCompile("^" + SemVerRegex + "$")
48 validPrereleaseRegex = regexp.MustCompile(ValidPrerelease)
filesys_windows.go (https://github.com/backstage/backstage.git) Go · 82 lines
watch_test.go (https://github.com/backstage/backstage.git) Go · 275 lines
mprof_test.go (https://bitbucket.org/bnat6582/go192.git) Go · 112 lines
handler.go (https://bitbucket.org/mstenius/lambda-api.git) Go · 179 lines
buffer.go (https://github.com/backstage/backstage.git) Go · 228 lines
sysinfo.go (https://bitbucket.org/Jake-Qu/kubernetes-mirror.git) Go · 203 lines
17 import (
18 "fmt"
19 "regexp"
20 "strconv"
21 "strings"
25 )
27 var schedulerRegExp = regexp.MustCompile(`.*\[(.*)\].*`)
29 // Get information about block devices present on the system.
69 blkSched, err := sysfs.GetBlockDeviceScheduler(name)
70 if err == nil {
71 matches := schedulerRegExp.FindSubmatch([]byte(blkSched))
72 if len(matches) >= 2 {
73 disk_info.Scheduler = string(matches[1])
extension.go (git://github.com/mattn/go-sqlite3.git) Go · 43 lines
headerparser.go (https://github.com/dotcloud/docker.git) Go · 161 lines
3 import (
4 "fmt"
5 "regexp"
6 "strings"
7 "unicode"
10 var (
11 // according to rfc7230
12 reToken = regexp.MustCompile(`^[^"(),/:;<=>?@[\]{}[:space:][:cntrl:]]+`)
13 reQuotedValue = regexp.MustCompile(`^[^\\"]+`)
14 reEscapedCharacter = regexp.MustCompile(`^[[:blank:][:graph:]]`)
15 )
28 // {"for": "192.0.2.43:443", "host": "registry.example.org"}.
29 func parseForwardedHeader(forwarded string) (map[string]string, string, error) {
30 // Following are states of forwarded header parser. Any state could transition to a failure.
31 const (
32 // terminating state; can transition to Parameter
readdb.go (https://bitbucket.org/wilyarti/hashtree-mobile.git) Go · 82 lines
25 "log"
26 "os"
27 "regexp"
28 "strings"
29 )
42 var hash string
43 for scanner.Scan() {
44 matched, err := regexp.MatchString("^--- .*", scanner.Text())
45 if err != nil {
46 fmt.Println("Error database not comprehensible!!")
48 }
49 if matched == true {
50 re := regexp.MustCompile("^--- ")
51 s := ""
52 hash = re.ReplaceAllString(scanner.Text(), s)
new.go (https://github.com/mongodb/mongo.git) Go · 99 lines
log.go (https://gitlab.com/kurafuto/kurafuto.git) Go · 87 lines
10 resetColor = ansi.ColorCode("reset")
11 fatalColor = ansi.ColorCode("red+b")
12 warnColor = ansi.ColorCode("yellow+b")
13 debugColor = ansi.ColorCode("blue")
14 infoColor = ansi.ColorCode("blue+b")
17 var (
18 colorRegexp = regexp.MustCompile(`&([a-fA-F0-9r])`)
19 colors = map[byte]string{
20 // TODO: the rest of the color codes.
24 '3': ansi.ColorCode("cyan"),
25 '4': ansi.ColorCode("red"),
26 '5': ansi.ColorCode("magenta"),
34 'd': ansi.ColorCode("magenta+b"),
35 'e': ansi.ColorCode("yellow+b"),
36 'f': ansi.ColorCode("white+b"),
signedmanifesthandler.go (https://bitbucket.org/afawkes/acs-engine.git) Go · 167 lines
testfixtures.go (https://codeberg.org/miguelangelo/gitea.git) Go · 305 lines
size.go (https://github.com/dotcloud/docker.git) Go · 108 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
32 decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
33 binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
34 sizeRegex = regexp.MustCompile(`^(\d+(\.\d+)*) ?([kKmMgGtTpP])?[iI]?[bB]?$`)
35 )
55 }
57 // HumanSizeWithPrecision allows the size to be in any precision,
58 // instead of 4 digit precision used in units.HumanSize.
59 func HumanSizeWithPrecision(size float64, precision int) string {
60 size, unit := getSizeAndUnit(size, 1000.0, decimapAbbrs)
61 return fmt.Sprintf("%.*g%s", precision, size, unit)
providers-line.go (https://bitbucket.org/cipriancraciun/mosaic-packages-repository.git) Go · 310 lines
83 MatchSink MatchSinkFunc
84 ErrorSink ErrorSinkFunc
85 Regexp *regexp.Regexp
86 Separator byte
87 BufferSize uint
90 type MatchCollector struct {
91 matchSink
92 Regexp *regexp.Regexp
93 Separator byte
94 BufferSize uint
242 func (_provider *matchSink) initialize_3 (_matchSink MatchSinkFunc, _errorSink ErrorSinkFunc, _regexp *regexp.Regexp, _separator byte, _bufferSize uint, _waitGroup *sync.WaitGroup) (*os.File, bool, error) {
244 _recordSink := func (_record []byte) (error) {
util.go (https://bitbucket.org/jyotiswarp/ppc.git) Go · 72 lines
tables_test.go (https://github.com/backstage/backstage.git) Go · 214 lines
testing.go
(git://github.com/border/golang-china.git)
Go · 174 lines
✨ Summary
The provided Go code is a testing framework for automated testing of Go packages. It allows users to run tests with optional verbose output and filtering by regular expression. The test runner executes each test, logs errors, and reports pass/fail status. If any test fails, the program exits with a non-zero status code.
The provided Go code is a testing framework for automated testing of Go packages. It allows users to run tests with optional verbose output and filtering by regular expression. The test runner executes each test, logs errors, and reports pass/fail status. If any test fails, the program exits with a non-zero status code.
commands_runmount.go (https://github.com/dotcloud/docker.git) Go · 283 lines
3 import (
4 "encoding/csv"
5 "regexp"
6 "strconv"
7 "strings"
165 value = processed
166 } else if key == "from" {
167 if matched, err := regexp.MatchString(`\$.`, value); err != nil { //nolint
168 return nil, err
169 } else if matched {
170 return nil, errors.Errorf("'%s' doesn't support variable expansion, define alias stage instead", key)
171 }
172 } else {
size.go (https://github.com/backstage/backstage.git) Go · 96 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
32 decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
33 binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
34 sizeRegex = regexp.MustCompile(`^(\d+(\.\d+)*) ?([kKmMgGtTpP])?[bB]?$`)
35 )
50 }
52 // HumanSize returns a human-readable approximation of a size
53 // capped at 4 valid numbers (eg. "2.746 MB", "796 KB").
54 func HumanSize(size float64) string {
config.go (https://gitlab.com/seacoastboy/bleve.git) Go · 163 lines
22 // fragment formatters
23 _ "github.com/blevesearch/bleve/search/highlight/fragment_formatters/ansi"
24 _ "github.com/blevesearch/bleve/search/highlight/fragment_formatters/html"
32 // char filters
33 _ "github.com/blevesearch/bleve/analysis/char_filters/html_char_filter"
34 _ "github.com/blevesearch/bleve/analysis/char_filters/regexp_char_filter"
35 _ "github.com/blevesearch/bleve/analysis/char_filters/zero_width_non_joiner"
57 // tokenizers
58 _ "github.com/blevesearch/bleve/analysis/tokenizers/regexp_tokenizer"
59 _ "github.com/blevesearch/bleve/analysis/tokenizers/single_token"
60 _ "github.com/blevesearch/bleve/analysis/tokenizers/unicode"
terminal_test.go (https://bitbucket.org/skeept/dotvim.git) Go · 139 lines
24 delim := "'"
25 var regex *regexp.Regexp
27 var result string
91 // Whitespace preserving flag with regex delimiter
92 regex = regexp.MustCompile(`\w+`)
94 result = replacePlaceholder("echo {s1}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
98 check("echo ''\\'''")
100 result = replacePlaceholder("echo {s3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
101 check("echo ' '")
116 regex = regexp.MustCompile("[oa]+")
117 // foo'bar baz
118 result = replacePlaceholder("echo {}/{1}/{3}/{2..3}", true, Delimiter{regex: regex}, printsep, false, "query", items1)
119 check("echo ' foo'\\''bar baz'/'f'/'r b'/''\\''bar b'")
120 }
xml.go (https://bitbucket.org/pmadabhushi/latticehealth-elastic.git) Go · 1440 lines
notifications.go (https://github.com/backstage/backstage.git) Go · 141 lines
predicate_influxql.go (https://bitbucket.org/egym-com/dns-tools.git) Go · 262 lines
3 import (
4 "errors"
5 "regexp"
7 "github.com/influxdata/influxql"
102 v.err = errors.New("startsWith not implemented")
103 return nil
104 case ComparisonRegex:
105 be.Op = influxql.EQREGEX
106 case ComparisonNotRegex:
107 be.Op = influxql.NEQREGEX
145 // TODO(sgc): consider hashing the RegexValue and cache compiled version
146 re, err := regexp.Compile(val.RegexValue)
147 if err != nil {
148 v.err = err
ansi.go (https://bitbucket.org/oniony/tmsu) Go · 103 lines
shard_mapper.go (https://bitbucket.org/egym-com/dns-tools.git) Go · 255 lines
116 if m.Regex != nil {
117 measurements = sg.MeasurementsByRegex(m.Regex.Val)
118 } else {
119 measurements = []string{m.Name}
147 if m.Regex != nil {
148 names = sg.MeasurementsByRegex(m.Regex.Val)
149 } else {
150 names = []string{m.Name}
185 if m.Regex != nil {
186 measurements := sg.MeasurementsByRegex(m.Regex.Val)
187 inputs := make([]query.Iterator, 0, len(measurements))
188 if err := func() error {
230 if m.Regex != nil {
231 var costs query.IteratorCost
232 measurements := sg.MeasurementsByRegex(m.Regex.Val)
233 for _, measurement := range measurements {
234 cost, err := sg.IteratorCost(measurement, opt)
cherry_pick.go (https://gitlab.com/shengwenzhu/hub.git) Go · 90 lines
3 import (
4 "regexp"
6 "github.com/github/hub/github"
65 url, err := github.ParseURL(ref)
66 if err == nil {
67 commitRegex := regexp.MustCompile("^commit\\/([a-f0-9]{7,40})")
68 projectPath := url.ProjectPath()
69 if commitRegex.MatchString(projectPath) {
70 sha = commitRegex.FindStringSubmatch(projectPath)[1]
71 project = url.Project
75 }
77 ownerWithShaRegexp := regexp.MustCompile("^([a-zA-Z0-9][a-zA-Z0-9-]*)@([a-f0-9]{7,40})$")
78 if ownerWithShaRegexp.MatchString(ref) {
size.go (https://bitbucket.org/enterstudiosbiz/origin.git) Go · 108 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
32 decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
33 binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
34 sizeRegex = regexp.MustCompile(`^(\d+(\.\d+)*) ?([kKmMgGtTpP])?[bB]?$`)
35 )
55 }
57 // HumanSizeWithPrecision allows the size to be in any precision,
58 // instead of 4 digit precision used in units.HumanSize.
59 func HumanSizeWithPrecision(size float64, precision int) string {
60 size, unit := getSizeAndUnit(size, 1000.0, decimapAbbrs)
61 return fmt.Sprintf("%.*g%s", precision, size, unit)
docker_cli_history_test.go (https://github.com/dotcloud/docker.git) Go · 121 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
88 out, _ := dockerCmd(c, "history", "--human=false", "busybox")
89 lines := strings.Split(out, "\n")
90 sizeColumnRegex, _ := regexp.Compile("SIZE +")
91 indices := sizeColumnRegex.FindStringIndex(lines[0])
106 out, _ := dockerCmd(c, "history", "--human=true", "busybox")
107 lines := strings.Split(out, "\n")
108 sizeColumnRegex, _ := regexp.Compile("SIZE +")
109 humanSizeRegexRaw := "\\d+.*B" // Matches human sizes like 10 MB, 3.2 KB, etc
116 }
117 sizeString := lines[i][startIndex:endIndex]
118 assert.Assert(c, cmp.Regexp("^"+humanSizeRegexRaw+"$",
119 strings.TrimSpace(sizeString)), fmt.Sprintf("The size '%s' was not in human format", sizeString))
120 }
querystr.go (https://repo.or.cz/debiancodesearch.git) Go · 45 lines
4 import (
5 "regexp"
6 "strings"
7 )
11 type QueryStr struct {
12 query string
13 boundaryRegexp *regexp.Regexp
14 anywhereRegexp *regexp.Regexp
24 quotedQuery := regexp.QuoteMeta(strippedQuery)
25 //fmt.Printf("quoted query: %s\n", quotedQuery)
26 result.boundaryRegexp = regexp.MustCompile(`(?i)\b` + quotedQuery + `\b`)
27 result.anywhereRegexp = regexp.MustCompile(`(?i)` + quotedQuery)
32 // XXX: These values might need to be tweaked.
34 index := qs.boundaryRegexp.FindStringIndex(*path)
35 if index != nil {
36 return 0.75 + (0.25 * (1.0 - float32(index[0])/float32(len(*path))))
config.go (https://gitlab.com/kloudsio/os.git) Go · 154 lines
svg.go (https://bitbucket.org/bnat6582/go192.git) Go · 79 lines
dispatchers_windows.go (https://bitbucket.org/gollariel/dockertool.git) Go · 87 lines
6 "os"
7 "path/filepath"
8 "regexp"
9 "strings"
12 )
14 var pattern = regexp.MustCompile(`^[a-zA-Z]:\.$`)
16 // normaliseWorkdir normalises a user requested working directory in a
78 extra := ""
79 original = filepath.FromSlash(strings.ToLower(strings.Replace(strings.ToLower(original), strings.ToLower(command)+" ", "", -1)))
80 if len(regexp.MustCompile(`"[a-z]:\\.*`).FindStringSubmatch(original)) > 0 &&
81 !strings.Contains(original, `\\`) &&
82 strings.Contains(original, "[") &&
testdb.go (https://bitbucket.org/localistico/services-api.git) Go · 158 lines
7 "encoding/csv"
8 "io"
9 "regexp"
10 "strings"
11 "time"
54 }
56 var whitespaceRegexp = regexp.MustCompile("\\s")
58 func getQueryHash(query string) string {
59 // Remove whitespace and lowercase to make stubbing less brittle
60 query = strings.ToLower(whitespaceRegexp.ReplaceAllString(query, ""))
62 h := sha1.New()
main.go (https://gitlab.com/steamdriven80/syncthing.git) Go · 144 lines
16 "net/http"
17 "os"
18 "regexp"
19 "sort"
20 "strings"
35 if u, p := userPass(); u == "" || p == "" {
36 log.Fatal("Need environment variables TRANSIFEX_USER and TRANSIFEX_PASS")
37 }
43 log.Println(curValidLangs)
45 resp := req("https://www.transifex.com/api/2/project/syncthing/resource/gui/stats")
47 var stats map[string]stat
docker_cli_logs_test.go (https://gitlab.com/roth1002/docker.git) Go · 320 lines
size.go (https://github.com/dotcloud/docker.git) Go · 95 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
8 )
10 // HumanSize returns a human-readable approximation of a size
11 // using SI standard (eg. "44kB", "17MB")
12 func HumanSize(size int64) string {
22 }
24 // FromHumanSize returns an integer from a human-readable specification of a size
25 // using SI standard (eg. "44kB", "17MB")
26 func FromHumanSize(size string) (int64, error) {
fmtcmd_test.go (https://bitbucket.org/gollariel/dockertool.git) Go · 440 lines
13 "path/filepath"
14 "reflect"
15 "regexp"
16 "sort"
17 "syscall"
321 if len(fixture.diff) > 0 {
322 expectedOut.WriteString(
323 regexp.QuoteMeta(
324 fmt.Sprintf("diff a/%s/%s b/%s/%s\n", path, fixture.filename, path, fixture.filename),
325 ),
326 )
327 // Need to use regex to ignore datetimes in diff.
328 expectedOut.WriteString(`--- .+?\n`)
329 expectedOut.WriteString(`\+\+\+ .+?\n`)
jsonfilelog.go (https://bitbucket.org/gollariel/dockertool.git) Go · 157 lines
generator.go (https://codeberg.org/momar/linkding.git) Go · 107 lines
5 "math"
6 "math/big"
7 "regexp"
8 "strconv"
9 "strings"
12 )
14 // Types maps an expansion identifier to a slice of possible values. `Generate("#x")` for example returns a random value from the `Types['x']` slice
15 var Types = map[byte][]string{
16 'x': strings.Split("abcdefghijklmnopqrstuvwxyz0123456789", ""),
29 var specification *regexp.Regexp
30 var expansion *regexp.Regexp
31 var repetition = regexp.MustCompile(`(#?.|\[[^\]]*\])\{\d+\}`)
60 typeChars += string(k)
61 }
62 expansion = regexp.MustCompile(`#[` + typeChars + `]`)
63 specification = regexp.MustCompile(`^([a-z0-9-]+|#[` + typeChars + `]|(\[([a-z0-9-]+|#[a-z])+\])?\{\d+\})+$`)
base.go (https://bitbucket.org/pmadabhushi/latticehealth-elastic.git) Go · 110 lines
17 import (
18 "encoding/xml"
19 "regexp"
20 "strconv"
21 )
98 // Escape characters that can be escaped without further escaping the string.
99 var charRe = regexp.MustCompile(`&#x[0-9a-fA-F]*;|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\x[0-9a-fA-F]{2}|\\[0-7]{3}|\\[abtnvfr]`)
101 // replaceUnicode converts hexadecimal Unicode codepoint notations to a one-rune string.
ansi.go (https://bitbucket.org/skeept/dotvim.git) Go · 292 lines
82 }
84 var ansiRegex *regexp.Regexp
86 func init() {
112 }
114 func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
115 var offsets []ansiOffset
200 state = &ansiState{prevState.fg, prevState.bg, prevState.attr}
201 }
202 if ansiCode[0] != '\x1b' || ansiCode[1] != '[' || ansiCode[len(ansiCode)-1] != 'm' {
203 return state
204 }
214 }
216 ansiCode = ansiCode[2 : len(ansiCode)-1]
217 if len(ansiCode) == 0 {
fnmatch.go (https://gitlab.com/steamdriven80/syncthing.git) Go · 86 lines
9 import (
10 "path/filepath"
11 "regexp"
12 "runtime"
13 "strings"
20 )
22 func Convert(pattern string, flags int) (*regexp.Regexp, error) {
23 any := "."
54 }
56 // Characters that are special in regexps but not in glob, must be
57 // escaped.
58 for _, char := range []string{".", "+", "$", "^", "(", ")", "|"} {
uprobe.go (https://github.com/dotcloud/docker.git) Go · 237 lines
re.go (git://github.com/bobappleyard/ts.git) Go · 51 lines
32 read := it.Accessor("readChar")
34 Regex = ts.ObjectClass.Extend(it, "Regex", ts.UserData, []ts.Slot {
35 ts.MSlot("create", func(o, expr *ts.Object) *ts.Object {
36 re := regexp.MustCompile(expr.ToString())
39 }),
40 ts.MSlot("match", func(o, src *ts.Object) *ts.Object {
41 re := o.UserData().(*regexp.Regexp)
42 r := runeReader{read, src}
43 return ts.Wrap(re.FindReaderSubmatchIndex(r))
47 return map[string] *ts.Object {
48 "Regex": Regex.Object(),
49 }
50 }
size.go (https://gitlab.com/munnerz/gitlab-ci-multi-runner.git) Go · 94 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
32 decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
33 binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
34 sizeRegex = regexp.MustCompile(`^(\d+)([kKmMgGtTpP])?[bB]?$`)
35 )
49 }
51 // HumanSize returns a human-readable approximation of a size
52 // using SI standard (eg. "44kB", "17MB")
53 func HumanSize(size float64) string {
test_templates.go (https://bitbucket.org/romanoff/ahc.git) Go · 191 lines
8 "os"
9 "path/filepath"
10 "regexp"
11 "strings"
12 )
60 )
62 var re *regexp.Regexp = regexp.MustCompile("\\s")
64 func (self *TestFile) ParseContent() error {
115 }
117 var provideRe *regexp.Regexp = regexp.MustCompile("@provide\\s+['\"](.+)['\"]")
119 func (self *TemplateTest) getProvide(cssPath string) string {
docker_cli_history_test.go (https://bitbucket.org/gollariel/dockertool.git) Go · 119 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
87 out, _ := dockerCmd(c, "history", "--human=false", "busybox")
88 lines := strings.Split(out, "\n")
89 sizeColumnRegex, _ := regexp.Compile("SIZE +")
90 indices := sizeColumnRegex.FindStringIndex(lines[0])
105 out, _ := dockerCmd(c, "history", "--human=true", "busybox")
106 lines := strings.Split(out, "\n")
107 sizeColumnRegex, _ := regexp.Compile("SIZE +")
108 humanSizeRegexRaw := "\\d+.*B" // Matches human sizes like 10 MB, 3.2 KB, etc
115 }
116 sizeString := lines[i][startIndex:endIndex]
117 c.Assert(strings.TrimSpace(sizeString), checker.Matches, humanSizeRegexRaw, check.Commentf("The size '%s' was not in human format", sizeString))
118 }
119 }
size.go (https://gitlab.com/seacoastboy/deis.git) Go · 81 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 "strings"
30 decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
31 binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
32 sizeRegex = regexp.MustCompile(`^(\d+)([kKmMgGtTpP])?[bB]?$`)
33 )
35 var unitAbbrs = [...]string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}
37 // HumanSize returns a human-readable approximation of a size
38 // using SI standard (eg. "44kB", "17MB")
39 func HumanSize(size int64) string {
component.go (https://bitbucket.org/romanoff/ahc.git) Go · 214 lines
10 "os"
11 "os/exec"
12 "regexp"
13 "strings"
14 "time"
118 }
120 var provideRe *regexp.Regexp = regexp.MustCompile("@provide\\s+['\"](.+)['\"]")
121 var RequireRe *regexp.Regexp = regexp.MustCompile("@require\\s+['\"](.+)['\"]")
122 var FontRe *regexp.Regexp = regexp.MustCompile("@font\\s+['\"](.+)['\"]")
123 var preprocessorRe *regexp.Regexp = regexp.MustCompile("@preprocessor\\s+['\"](.+)['\"]")
152 }
154 var backgroundImageRe *regexp.Regexp = regexp.MustCompile("background-image:\\s+url\\((.+)\\);")
156 func (self *Component) replaceImagesWithDataUri() error {
wrap.go (https://bitbucket.org/admknight/insane-torrent.git) Go · 88 lines
5 "net/http"
6 "os"
7 "regexp"
8 "text/template"
9 "time"
11 "github.com/andrew-d/go-termutil"
12 "github.com/jpillora/ansi"
13 "github.com/jpillora/sizestr"
14 )
22 }
24 var basicColors = &Colors{string(ansi.ResetBytes), string(ansi.GreenBytes), string(ansi.CyanBytes), string(ansi.YellowBytes), string(ansi.YellowBytes), string(ansi.ResetBytes)}
25 var noColors = &Colors{} //no colors
woodcutter.go (https://github.com/kierdavis/mc.git) Go · 269 lines
ansi.go (https://bitbucket.org/wjkoh/dotfiles) Go · 157 lines
31 }
33 var ansiRegex *regexp.Regexp
35 func init() {
37 }
39 func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, []ansiOffset, *ansiState) {
40 var offsets []ansiOffset
88 }
90 func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
91 // State
92 var state *ansiState
110 }
112 ansiCode = ansiCode[2 : len(ansiCode)-1]
113 if len(ansiCode) == 0 {
discovery_test.go (https://bitbucket.org/marthjod/ansible-one-inventory.git) Go · 118 lines
3 import (
4 "encoding/xml"
5 "github.com/marthjod/ansible-one-inventory/discovery"
6 "github.com/marthjod/ansible-one-inventory/filter"
7 "github.com/marthjod/ansible-one-inventory/hostnameextractor"
8 "github.com/marthjod/ansible-one-inventory/model"
109 }
110 filters := filter.GroupFilters{
111 "foo": "(invalid regexp",
112 }
smv.go (https://bitbucket.org/teythoon/vgo) Go · 189 lines
18 "fmt"
19 "io"
20 "regexp"
21 "strings"
22 "text/template"
55 }
57 func (s *smvContext) Transitions() string {
58 r := make([]string, 0, len(s.Model.Edges()))
59 for _, e := range s.Model.Edges() {
157 smvTemplate = template.Must(template.New("smv").Parse(m + smvTemplateString))
159 norm := regexp.MustCompile(`\s+`)
160 min := regexp.MustCompile(` ?([:;=]) ?`)
175 TRANS
176 {{.Transitions}};
178 ASSIGN
filter.go (https://bitbucket.org/marthjod/ansible-one-inventory.git) Go · 38 lines
4 import (
5 "fmt"
6 "github.com/marthjod/ansible-one-inventory/model"
7 "regexp"
8 )
10 // A GroupFilter is a key-value map mapping group names to regexps
11 // which describe hostnames belonging to a respective group.
12 type GroupFilters map[string]string
14 // Takes a list of hostnames and returns an InventoryGroup
15 // consisting of those matching regex.
16 func Filter(hostNames []string, regex string) (model.InventoryGroup, error) {
18 ig := model.InventoryGroup{}
19 re, err := regexp.Compile(regex)
20 if err != nil {
21 return ig, fmt.Errorf("%q: %s", regex, err.Error())
filter_test.go (https://bitbucket.org/marthjod/ansible-one-inventory.git) Go · 57 lines
3 import (
4 "github.com/marthjod/ansible-one-inventory/filter"
5 "github.com/marthjod/ansible-one-inventory/model"
35 var err error
37 regex := "(invalid"
38 _, err = filter.Filter(hostnames, regex)
39 if err == nil {
40 t.Error("No error returned for invalid regexp!")
41 }
42 }
46 "web-staging-east",
47 }
48 regex := "^[a-z]{3}"
50 ig, err := filter.Filter(hostnames, regex)
main.go (https://bitbucket.org/marthjod/gocart.git) Go · 133 lines
36 flag.StringVar(&password, "password", "", `OpenNebula Password`)
37 flag.StringVar(&url, "url", "https://localhost:61443/RPC2", "OpenNebula XML-RPC API URL")
38 flag.StringVar(&patternFilter, "pattern-filter", "^([a-z]{2}).+([a-z]{2})$", "Regexp filter for distinct VM name pattern auto-discovery")
39 flag.StringVar(&patternFilterPrefix, "pattern-filter-prefix", "^", "Prefix for distinct VM name patterns")
40 flag.StringVar(&patternFilterInfix, "pattern-filter-infix", ".+", "Infix for distinct VM name patterns")
time-gaps.go (https://bitbucket.org/marthjod/scripts.git) Go · 118 lines
goswf.go (https://bitbucket.org/jrick/goswf) Go · 158 lines
11 "os"
12 "path/filepath"
13 "regexp"
14 "strings"
15 )
19 subtitleFlag = flag.String(`subtitle`, ``, `site subtitle`)
20 dirFlag = flag.String(`in`, ``, `markdown file tree`)
21 ignoreRegExp = flag.String(`ignore`, ``, `ignore regexp`)
22 tmplFlag = flag.String(`tmpl`, ``, `template file`)
23 mdParser = markdown.NewParser(&markdown.Extensions{Smart: true})
78 func mkPage(srcPath string, info os.FileInfo, err error) error {
79 if skip, err := regexp.MatchString(*ignoreRegExp, filepath.Base(srcPath)); err != nil {
80 panic(err)
81 } else if skip {
semver.go (https://github.com/robert-zaremba/nsq.git) Go · 174 lines
json.nqp (git://github.com/plobsing/nqp.git) Unknown · 107 lines
validator.go (https://github.com/APTrust/bagman.git) Go · 181 lines
9 "os"
10 "path/filepath"
11 "regexp"
12 "strings"
13 )
101 // contents of the bag.
102 func (validator *Validator) UntarredDir() (string) {
103 re := regexp.MustCompile("\\.tar$")
104 return re.ReplaceAllString(validator.PathToFile, "")
105 }
131 // common incorrect variants, such as "bag1of2"
132 func (validator *Validator) LooksLikeMultipart() (bool) {
133 reMisnamedMultiPartBag := regexp.MustCompile(`\.b\d+\.?of\d+$|\.bag\d+\.?of\d+$`)
134 return reMisnamedMultiPartBag.MatchString(validator.UntarredDir())
135 }
sddl_itf.go (https://github.com/canopy-project/canopy-cloud.git) Go · 191 lines
tokens.go (https://github.com/apeace/go-lisp.git) Go · 161 lines
3 import (
4 "fmt"
5 "regexp"
6 "strconv"
7 )
18 type Pattern struct {
19 typ tokenType
20 regexp *regexp.Regexp
21 }
37 func patterns() []Pattern {
38 return []Pattern{
39 {whitespaceToken, regexp.MustCompile(`^\s+`)},
40 {commentToken, regexp.MustCompile(`^;.*`)},
41 {stringToken, regexp.MustCompile(`^("(\\.|[^"])*")`)},
42 {numberToken, regexp.MustCompile(`^((([0-9]+)?\.)?[0-9]+)`)},