proxy.golang.org : github.com/zach-klippenstein/goregen

Package regen is a library for generating random strings from regular expressions. The generated strings will match the expressions they were generated from. Similar to Ruby's randexp library. E.g. will return a lowercase alphanumeric string between 1 and 64 characters long. Expressions are parsed using the Go standard library's parser: http://golang.org/pkg/regexp/syntax/. "." will generate any character, not necessarily a printable one. "x{0,}", "x*", and "x+" will generate a random number of x's up to an arbitrary limit. If you care about the maximum number, specify it explicitly in the expression, e.g. "x{0,256}". Flags can be passed to the parser by setting them in the GeneratorArgs struct. Newline flags are respected, and newlines won't be generated unless the appropriate flags for matching them are set. E.g. Generate(".|[^a]") will never generate newlines. To generate newlines, create a generator and pass the flag syntax.MatchNL. The Perl character class flag is supported, and required if the pattern contains them. Unicode groups are not supported at this time. Support may be added in the future. A generator can safely be used from multiple goroutines without locking. A large bottleneck with running generators concurrently is actually the entropy source. Sources returned from rand.NewSource() are slow to seed, and not safe for concurrent use. Instead, the source passed in GeneratorArgs is used to seed an XorShift64 source (algorithm from the paper at http://vigna.di.unimi.it/ftp/papers/xorshift.pdf). This source only uses a single variable internally, and is much faster to seed than the default source. One source is created per call to NewGenerator. If no source is passed in, the default source is used to seed. The source is not locked and does not use atomic operations, so there is a chance that multiple goroutines using the same source may get the same output. While obviously not cryptographically secure, I think the simplicity and performance benefit outweighs the risk of collisions. If you really care about preventing this, the solution is simple: don't call a single Generator from multiple goroutines. Benchmarks are included for creating and running generators for limited-length, complex regexes, and simple, highly-repetitive regexes. The complex benchmarks generate fake HTTP messages with the following regex: The repetitive benchmarks use the regex See regen_benchmarks_test.go for more information. On my mid-2014 MacBook Pro (2.6GHz Intel Core i5, 8GB 1600MHz DDR3), the results of running the benchmarks with minimal load are:

Registry - Source - Documentation - JSON
purl: pkg:golang/github.com/zach-klippenstein/goregen
License: Apache-2.0
Latest release: about 9 years ago
First release: about 9 years ago
Namespace: github.com/zach-klippenstein
Dependent packages: 222
Dependent repositories: 253
Stars: 82 on GitHub
Forks: 14 on GitHub
Docker dependents: 17
Docker downloads: 230,537
See more repository details: repos.ecosyste.ms
Funding links: https://github.com/sponsors/zach-klippenstein
Last synced: about 2 months ago

• Readme
• Versions 1
• Dependent Packages 222
• Maintainers 0