https://github.com/ammar/regexp_parser

A regular expression parser library for Ruby
https://github.com/ammar/regexp_parser

Keywords from Contributors

rubocop code-formatter static-code-analysis rubygems mvc activerecord activejob rspec rack static-analysis

Last synced: about 2 hours ago
JSON representation

Repository metadata

A regular expression parser library for Ruby

Host: GitHub
URL: https://github.com/ammar/regexp_parser
Owner: ammar
License: mit
Created: 2010-10-06T16:07:08.000Z (over 15 years ago)
Default Branch: master
Last Pushed: 2025-09-15T09:05:35.000Z (6 months ago)
Last Synced: 2026-02-28T14:27:09.213Z (3 days ago)
Language: Ruby
Homepage:
Size: 1.23 MB
Stars: 145
Watchers: 9
Forks: 24
Open Issues: 1
Releases: 0
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE

Regexp::Parser

A Ruby gem for tokenizing, parsing, and transforming regular expressions.

Multilayered
- A scanner/tokenizer based on Ragel
- A lexer that produces a "stream" of Token objects
- A parser that produces a "tree" of Expression objects (OO API)
Runs on Ruby 2.x, 3.x and JRuby runtimes
Recognizes Ruby 1.8, 1.9, 2.x and 3.x regular expressions See Supported Syntax

For examples of regexp_parser in use, see Example Projects.

Requirements

Ruby >= 2.0
Ragel >= 6.0, but only if you want to build the gem or work on the scanner.

Install

Install the gem with:

gem install regexp_parser

Or, add it to your project's Gemfile:

gem 'regexp_parser', '~> X.Y.Z'

See the badge at the top of this README or rubygems
for the the latest version number.

Usage

The three main modules are Scanner, Lexer, and Parser. Each of them
provides a single method that takes a regular expression (as a Regexp object or
a string) and returns its results. The Lexer and the Parser accept an
optional second argument that specifies the syntax version, like 'ruby/2.0',
which defaults to the host Ruby version (using RUBY_VERSION).

Here are the basic usage examples:

require 'regexp_parser'

Regexp::Scanner.scan(regexp)

Regexp::Lexer.lex(regexp)

Regexp::Parser.parse(regexp)

All three methods accept a block as the last argument, which, if given, gets
called with the results as follows:

Scanner: the block gets passed the results as they are scanned. See the
example in the next section for details.
Lexer: the block gets passed the tokens one by one as they are scanned.
The result of the block is returned.
Parser: after completion, the block gets passed the root expression.
The result of the block is returned.

All three methods accept either a Regexp or String (containing the pattern)

if a String is passed, options can be supplied:

require 'regexp_parser'

Regexp::Parser.parse(
  "a+ # Recognizes a and A...",
  options: ::Regexp::EXTENDED | ::Regexp::IGNORECASE
)

Components

Scanner

A Ragel-generated scanner that recognizes the cumulative syntax of all
supported syntax versions. It breaks a given expression's text into the
smallest parts, and identifies their type, token, text, and start/end
offsets within the pattern.

Example

The following scans the given pattern and prints out the type, token, text and
start/end offsets for each token found.

require 'regexp_parser'

Regexp::Scanner.scan(/(ab?(cd)*[e-h]+)/) do |type, token, text, ts, te|
  puts "type: #{type}, token: #{token}, text: '#{text}' [#{ts}..#{te}]"
end

# output
# type: group, token: capture, text: '(' [0..1]
# type: literal, token: literal, text: 'ab' [1..3]
# type: quantifier, token: zero_or_one, text: '?' [3..4]
# type: group, token: capture, text: '(' [4..5]
# type: literal, token: literal, text: 'cd' [5..7]
# type: group, token: close, text: ')' [7..8]
# type: quantifier, token: zero_or_more, text: '*' [8..9]
# type: set, token: open, text: '[' [9..10]
# type: set, token: range, text: 'e-h' [10..13]
# type: set, token: close, text: ']' [13..14]
# type: quantifier, token: one_or_more, text: '+' [14..15]
# type: group, token: close, text: ')' [15..16]

A one-liner that uses map on the result of the scan to return the textual
parts of the pattern:

Regexp::Scanner.scan(/(cat?([bhm]at)){3,5}/).map { |token| token[2] }
# => ["(", "cat", "?", "(", "[", "b", "h", "m", "]", "at", ")", ")", "{3,5}"]

Notes

The scanner performs basic syntax error checking, like detecting missing
balancing punctuation and premature end of pattern. Flavor validity checks
are performed in the lexer, which uses a syntax object.
If the input is a Ruby Regexp object, the scanner calls #source on it to
get its string representation. #source does not include the options of
the expression (m, i, and x). To include the options in the scan, #to_s
should be called on the Regexp before passing it to the scanner or the
lexer. For the parser, however, this is not necessary. It automatically
exposes the options of a passed Regexp in the returned root expression.
To keep the scanner simple(r) and fairly reusable for other purposes, it
does not perform lexical analysis on the tokens, sticking to the task
of identifying the smallest possible tokens and leaving lexical analysis
to the lexer.
The MRI implementation may accept expressions that either conflict with
the documentation or are undocumented, like {} and ] (unescaped).
The scanner will try to support as many of these cases as possible.

Syntax

Defines the supported tokens for a specific engine implementation (aka a
flavor). Syntax classes act as lookup tables, and are layered to create
flavor variations. Syntax only comes into play in the lexer.

Example

The following fetches syntax objects for Ruby 2.0, 1.9, 1.8, and
checks a few of their implementation features.

require 'regexp_parser'

ruby_20 = Regexp::Syntax.for 'ruby/2.0'
ruby_20.implements? :quantifier,  :zero_or_one             # => true
ruby_20.implements? :quantifier,  :zero_or_one_reluctant   # => true
ruby_20.implements? :quantifier,  :zero_or_one_possessive  # => true
ruby_20.implements? :conditional, :condition               # => true

ruby_19 = Regexp::Syntax.for 'ruby/1.9'
ruby_19.implements? :quantifier,  :zero_or_one             # => true
ruby_19.implements? :quantifier,  :zero_or_one_reluctant   # => true
ruby_19.implements? :quantifier,  :zero_or_one_possessive  # => true
ruby_19.implements? :conditional, :condition               # => false

ruby_18 = Regexp::Syntax.for 'ruby/1.8'
ruby_18.implements? :quantifier,  :zero_or_one             # => true
ruby_18.implements? :quantifier,  :zero_or_one_reluctant   # => true
ruby_18.implements? :quantifier,  :zero_or_one_possessive  # => false
ruby_18.implements? :conditional, :condition               # => false

Syntax objects can also be queried about their complete and relative feature sets.

require 'regexp_parser'

ruby_20 = Regexp::Syntax.for 'ruby/2.0' # => Regexp::Syntax::V2_0_0
ruby_20.added_features                  # => { conditional: [...], ... }
ruby_20.removed_features                # => { property: [:newline], ... }
ruby_20.features                        # => { anchor: [...], ... }

Notes

Variations on a token, for example a named group with angle brackets (< and >)
vs one with a pair of single quotes, are specified with an underscore followed
by two characters appended to the base token. In the previous named group example,
the tokens would be :named_ab (angle brackets) and :named_sq (single quotes).
These variations are normalized by the syntax to :named.

Lexer

Sits on top of the scanner and performs lexical analysis on the tokens that
it emits. Among its tasks are; breaking quantified literal runs, collecting the
emitted token attributes into Token objects, calculating their nesting depth,
normalizing tokens for the parser, and checking if the tokens are implemented by
the given syntax version.

See the Token Objects
wiki page for more information on Token objects.

Example

The following example lexes the given pattern, checks it against the Ruby 1.9
syntax, and prints the token objects' text indented to their level.

require 'regexp_parser'

Regexp::Lexer.lex(/a?(b(c))*[d]+/, 'ruby/1.9') do |token|
  puts "#{'  ' * token.level}#{token.text}"
end

# output
# a
# ?
# (
#   b
#   (
#     c
#   )
# )
# *
# [
# d
# ]
# +

A one-liner that returns an array of the textual parts of the given pattern.
Compare the output with that of the one-liner example of the Scanner; notably
how the sequence 'cat' is treated. The 't' is separated because it's followed
by a quantifier that only applies to it.

Regexp::Lexer.scan(/(cat?([b]at)){3,5}/).map { |token| token.text }
# => ["(", "ca", "t", "?", "(", "[", "b", "]", "at", ")", ")", "{3,5}"]

Notes

The syntax argument is optional. It defaults to the version of the Ruby
interpreter in use, as returned by RUBY_VERSION.
The lexer normalizes some tokens, as noted in the Syntax section above.

Parser

Sits on top of the lexer and transforms the "stream" of Token objects emitted
by it into a tree of Expression objects represented by an instance of the
Expression::Root class.

See the Expression Objects
wiki page for attributes and methods.

Example

This example uses the tree traversal method #each_expression
and the method #strfregexp to print each object in the tree.

include_root  = true
indent_offset = include_root ? 1 : 0

tree.each_expression(include_root) do |exp|
  puts exp.strfregexp("%>> %c", indent_offset)
end

# Output
# > Regexp::Expression::Root
#   > Regexp::Expression::Literal
#   > Regexp::Expression::Group::Capture
#     > Regexp::Expression::Literal
#     > Regexp::Expression::Group::Capture
#       > Regexp::Expression::Literal
#     > Regexp::Expression::Literal
#   > Regexp::Expression::Group::Named
#     > Regexp::Expression::CharacterSet

Note: quantifiers do not appear in the output because they are members of the
Expression class. See the next section for details.

Another example, using #traverse for a more fine-grained tree traversal:

require 'regexp_parser'

regex = /a?(b+(c)d)*(?<name>[0-9]+)/

tree = Regexp::Parser.parse(regex, 'ruby/2.1')

tree.traverse do |event, exp|
  puts "#{event}: #{exp.type} `#{exp.to_s}`"
end

# Output
# visit: literal `a?`
# enter: group `(b+(c)d)*`
# visit: literal `b+`
# enter: group `(c)`
# visit: literal `c`
# exit: group `(c)`
# visit: literal `d`
# exit: group `(b+(c)d)*`
# enter: group `(?<name>[0-9]+)`
# visit: set `[0-9]+`
# exit: group `(?<name>[0-9]+)`

See the traverse.rb and strfregexp.rb files under lib/regexp_parser/expression/methods
for more information on these methods.

Supported Syntax

The three modules support all the regular expression syntax features of Ruby 1.8,
1.9, 2.x and 3.x:

Note that not all of these are available in all versions of Ruby

Syntax Feature	Examples	⋯
Alternation	`a\|b\|c`	✓
Anchors	`\A`, `^`, `\b`	✓
Character Classes	`[abc]`, `[^\\]`, `[a-d&&aeiou]`	✓
Character Types	`\d`, `\H`, `\s`	✓
Cluster Types	`\R`, `\X`	✓
Conditional Exps.	`(?(cond)yes-subexp)`, `(?(cond)yes-subexp\|no-subexp)`	✓
Escape Sequences	`\t`, `\\+`, `\?`	✓
Free Space	whitespace and `# Comments` (x modifier)	✓
Grouped Exps.		⋱
Assertions		⋱
Lookahead	`(?=abc)`	✓
Negative Lookahead	`(?!abc)`	✓
Lookbehind	`(?<=abc)`	✓
Negative Lookbehind	`(?<!abc)`	✓
Atomic	`(?>abc)`	✓
Absence	`(?~abc)`	✓
Back-references		⋱
Named	`\k<name>`	✓
Nest Level	`\k<n-1>`	✓
Numbered	`\k<1>`	✓
Relative	`\k<-2>`	✓
Traditional	`\1` through `\9`	✓
Capturing	`(abc)`	✓
Comments	`(?# comment text)`	✓
Named	`(?<name>abc)`, `(?'name'abc)`	✓
Options	`(?mi-x:abc)`, `(?a:\s\w+)`, `(?i)`	✓
Passive	`(?:abc)`	✓
Subexp. Calls	`\g<name>`, `\g<1>`	✓
Keep	`\K`, `(ab\Kc\|d\Ke)f`	✓
Literals (utf-8)	`Ruby`, `ルビー`, `روبي`	✓
POSIX Classes	`[:alpha:]`, `[:^digit:]`	✓
Quantifiers		⋱
Greedy	`?`, `*`, `+`, `{m,M}`	✓
Reluctant (Lazy)	`??`, `*?`, `+?` [1]	✓
Possessive	`?+`, `*+`, `++` [1]	✓
String Escapes		⋱
Control [2]	`\C-C`, `\cD`	✓
Hex	`\x20`, `\xE2\x82\xAC`	✓
Meta [2]	`\M-c`, `\M-\C-C`, `\M-\cC`, `\C-\M-C`, `\c\M-C`	✓
Octal	`\0`, `\01`, `\012`	✓
Unicode	`\uHHHH`, `\u{H+ H+}`	✓
Unicode Properties	(Unicode 15.0.0)	⋱
Age	`\p{Age=5.2}`, `\P{age=7.0}`, `\p{^age=8.0}`	✓
Blocks	`\p{InArmenian}`, `\P{InKhmer}`, `\p{^InThai}`	✓
Classes	`\p{Alpha}`, `\P{Space}`, `\p{^Alnum}`	✓
Derived	`\p{Math}`, `\P{Lowercase}`, `\p{^Cased}`	✓
General Categories	`\p{Lu}`, `\P{Cs}`, `\p{^sc}`	✓
Scripts	`\p{Arabic}`, `\P{Hiragana}`, `\p{^Greek}`	✓
Simple	`\p{Dash}`, `\p{Extender}`, `\p{^Hyphen}`	✓

[1]: Ruby does not support lazy or possessive interval quantifiers.
Any + or ? that follows an interval quantifier will be treated as another,
chained quantifier. See also #3,
#69.

[2]: As of Ruby 3.1, meta and control sequences are pre-processed to hex
escapes when used in Regexp literals,
so they will only reach the scanner and will only be emitted if a String or a Regexp
that has been built with the ::new constructor is scanned.

Inapplicable Features

Some Regexp options are not relevant to parsing. The option o modifies how Ruby
deduplicates the Regexp object and does not appear in its source or options.
Other such modifiers include the encoding modifiers e, n, s and u
See.
These are not seen by the scanner.

The following features are not currently enabled for Ruby by its regular
expressions library (Onigmo). They are not supported by the scanner.

Quotes: \Q...\E [See]
Capture History: (?@...), (?@<name>...) [See]

See something missing? Please submit an issue

Note: Attempting to process expressions with unsupported syntax features can raise
an error, or incorrectly return tokens/objects as literals.

Testing

To run the tests simply run rake from the root directory.

The default task generates the scanner's code from the Ragel source files and runs
all the specs, thus it requires Ragel to be installed.

Note that changes to Ragel files will not be reflected when running rspec on its own,
so to run individual tests you might want to run:

rake ragel && rspec spec/scanner/properties_spec.rb

Building

Building the scanner and the gem requires Ragel
to be installed. The build tasks will automatically invoke the 'ragel' task to generate
the Ruby scanner code.

The project uses the standard rubygems package tasks, so:

To build the gem, run:

rake build

To install the gem from the cloned project, run:

rake install

References

Example Projects

Projects using regexp_parser.

capybara is an integration testing tool
that uses regexp_parser to convert Regexps to css/xpath selectors.
js_regex converts Ruby regular expressions
to JavaScript-compatible regular expressions.
meta_re is a regular expression preprocessor
with alias support.
mutant manipulates your regular expressions
(amongst others) to see if your tests cover their behavior.
repper is a regular expression
pretty-printer and formatter for Ruby.
rubocop is a linter for Ruby that
uses regexp_parser to lint Regexps.
twitter-cldr-rb is a localization helper
that uses regexp_parser to generate examples of postal codes.

Documentation and books used while working on this project.

Ruby Flavors

Oniguruma Regular Expressions (Ruby 1.9.x) link
Onigmo Regular Expressions (Ruby >= 2.0) link

Regular Expressions

Mastering Regular Expressions, By Jeffrey E.F. Friedl (2nd Edition) book
Regular Expression Flavor Comparison link
Enumerating the strings of regular languages link
Stack Overflow Regular Expressions FAQ link

Unicode

Unicode Explained, By Jukka K. Korpela. book
Unicode Derived Properties link
Unicode Property Aliases link
Unicode Regular Expressions link
Unicode Standard Annex #44 link

Copyright

Owner metadata

Name: Ammar Ali
Login: ammar
Email:
Kind: user
Description:
Website:
Location: Ramallah, Palestine
Twitter:
Company:
Icon url: https://avatars.githubusercontent.com/u/2959?v=4
Repositories: 5
Last ynced at: 2023-04-09T03:55:19.256Z
Profile URL: https://github.com/ammar

GitHub Events

Total

Issues event: 6
Watch event: 1
Delete event: 2
Issue comment event: 10
Push event: 24
Pull request event: 11
Fork event: 1
Create event: 8

Last Year

Issues event: 4
Issue comment event: 7
Push event: 15
Pull request event: 9
Create event: 4

Committers metadata

Last synced: 2 days ago

Total Commits: 800
Total Committers: 18
Avg Commits per committer: 44.444
Development Distribution Score (DDS): 0.431

Commits in past year: 24
Committers in past year: 3
Avg Commits per committer in past year: 8.0
Development Distribution Score (DDS) in past year: 0.167

Name	Email	Commits
Janosch Müller	j**4@g**m	455
Ammar Ali	a**i@g**m	298
John Backus	j**s@g**m	10
Ammar	a**r@m**l	8
Daniel Gollahon	d**n@g**m	6
Garen Torikian	g**n@g**m	4
Geremia Taglialatela	t**v@g**m	4
Owen Stephens	o**n@o**k	3
Akira Matsuda	r**e@d**p	2
Earlopain	1****n	2
Andy Triggs	a**s@g**m	1
Bartek Bułat	b****z	1
Daniel Vandersluis	d**s@g**m	1
Koichi ITO	k**o@g**m	1
Masafumi Koba	4****s	1
Masataka Pocke Kuwabara	k**a@p**e	1
Dana Scheider	d**r@r**m	1
Thomas Walpole	t**e@g**m	1

Committer domains:

Issue and Pull Request metadata

Last synced: 15 days ago

Total issues: 55
Total pull requests: 56
Average time to close issues: 3 months
Average time to close pull requests: 26 days
Total issue authors: 31
Total pull request authors: 18
Average comments per issue: 2.93
Average comments per pull request: 2.32
Merged pull request: 53
Bot issues: 0
Bot pull requests: 0

Past year issues: 5
Past year pull requests: 11
Past year average time to close issues: 5 days
Past year average time to close pull requests: 7 days
Past year issue authors: 4
Past year pull request authors: 4
Past year average comments per issue: 0.8
Past year average comments per pull request: 0.18
Past year merged pull request: 9
Past year bot issues: 0
Past year bot pull requests: 0

More stats: https://issues.ecosyste.ms/repositories/lookup?url=https://github.com/ammar/regexp_parser

Top Issue Authors

backus (9)
jaynetics (6)
mbj (5)
calfeld-zz (3)
camertron (3)
dgollahon (2)
shahinasm (2)
tagliala (2)
gjtorikian (1)
knu (1)
JasonBarnabe (1)
graaff (1)
owst (1)
bobziuchkovski (1)
jhart-r7 (1)

Top Pull Request Authors

jaynetics (20)
tagliala (6)
backus (6)
Earlopain (4)
dvandersluis (2)
dgollahon (2)
amatsuda (2)
ammar (2)
owst (2)
koic (2)
pocke (1)
barthez (1)
andyt (1)
ybiquitous (1)
twalpole (1)

Top Issue Labels

scanner (2)
parser (1)

Top Pull Request Labels

Package metadata

Total packages: 13
Total downloads:
- rubygems: 1,151,373,047 total
Total docker downloads: 7,080,483,812
Total dependent packages: 18 (may contain duplicates)
Total dependent repositories: 242,464 (may contain duplicates)
Total versions: 219
Total maintainers: 2

gem.coop: regexp_parser

A library for tokenizing, lexing, and parsing Ruby regular expressions.

Homepage: https://github.com/ammar/regexp_parser
Documentation: http://www.rubydoc.info/gems/regexp_parser/
Licenses: MIT
Latest release: 2.11.3 (published 6 months ago)
Last Synced: 2026-03-01T09:02:52.667Z (2 days ago)
Versions: 70
Dependent Packages: 0
Dependent Repositories: 0
Downloads: 575,571,159 Total
Docker Downloads: 3,540,241,906
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 0.016%
- Docker downloads count: 0.022%
- Downloads: 0.041%
Maintainers (2)
- jaynetics
- ammar_

rubygems.org: regexp_parser

A library for tokenizing, lexing, and parsing Ruby regular expressions.

Homepage: https://github.com/ammar/regexp_parser
Documentation: http://www.rubydoc.info/gems/regexp_parser/
Licenses: MIT
Latest release: 2.11.3 (published 6 months ago)
Last Synced: 2026-03-02T07:32:26.950Z (1 day ago)
Versions: 70
Dependent Packages: 18
Dependent Repositories: 242,464
Downloads: 575,801,888 Total
Docker Downloads: 3,540,241,906
Rankings:
- Downloads: 0.052%
- Docker downloads count: 0.064%
- Dependent repos count: 0.091%
- Dependent packages count: 1.182%
- Average: 1.949%
- Stargazers count: 4.685%
- Forks count: 5.622%
Maintainers (2)
- jaynetics
- ammar_

proxy.golang.org: github.com/ammar/regexp_parser

Homepage:
Documentation: https://pkg.go.dev/github.com/ammar/regexp_parser#section-documentation
Licenses: mit
Latest release: v2.11.3+incompatible (published 6 months ago)
Last Synced: 2026-02-28T11:02:02.362Z (3 days ago)
Versions: 69
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Stargazers count: 4.016%
- Forks count: 4.693%
- Average: 7.272%
- Dependent packages count: 9.576%
- Dependent repos count: 10.802%

ubuntu-20.04: ruby-regexp-parser

Homepage: http://github.com/ammar/regexp_parser
Licenses:
Latest release: 1.6.0-1 (published 18 days ago)
Last Synced: 2026-02-13T07:21:41.729Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

debian-11: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Documentation: https://packages.debian.org/bullseye/ruby-regexp-parser
Licenses:
Latest release: 1.7.1-1 (published 21 days ago)
Last Synced: 2026-02-13T08:24:18.796Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

ubuntu-23.10: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Licenses:
Latest release: 2.6.1-1 (published 18 days ago)
Last Synced: 2026-02-13T18:31:25.306Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

ubuntu-23.04: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Licenses:
Latest release: 2.6.1-1 (published 20 days ago)
Last Synced: 2026-02-11T06:48:26.227Z (20 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

ubuntu-24.10: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Licenses:
Latest release: 2.6.1-1 (published 22 days ago)
Last Synced: 2026-02-09T17:09:16.166Z (22 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

debian-10: ruby-regexp-parser

Homepage: http://github.com/ammar/regexp_parser
Documentation: https://packages.debian.org/buster/ruby-regexp-parser
Licenses:
Latest release: 1.2.0-1 (published 20 days ago)
Last Synced: 2026-02-13T04:25:08.860Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

debian-12: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Documentation: https://packages.debian.org/bookworm/ruby-regexp-parser
Licenses:
Latest release: 2.6.1-1 (published 19 days ago)
Last Synced: 2026-02-12T23:39:38.814Z (19 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

ubuntu-22.04: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Licenses:
Latest release: 2.1.1-2 (published 18 days ago)
Last Synced: 2026-02-13T13:24:33.192Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

ubuntu-24.04: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Licenses:
Latest release: 2.6.1-1 (published 25 days ago)
Last Synced: 2026-02-06T15:56:17.554Z (25 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:

debian-13: ruby-regexp-parser

Homepage: https://github.com/ammar/regexp_parser
Documentation: https://packages.debian.org/trixie/ruby-regexp-parser
Licenses:
Latest release: 2.6.1-1 (published 19 days ago)
Last Synced: 2026-02-13T13:19:04.961Z (18 days ago)
Versions: 1
Dependent Packages: 0
Dependent Repositories: 0
Rankings:
- Dependent repos count: 0.0%
- Dependent packages count: 0.0%
- Average: 100%

Dependencies

Gemfile rubygems

benchmark-ips ~> 2.1 development
gouteur >= 0 development
ice_nine ~> 0.11.2 development
rake ~> 13.0 development
regexp_property_values ~> 1.3 development
rspec ~> 3.10 development
rubocop ~> 1.7 development

.github/workflows/gouteur.yml actions

actions/checkout v2 composite
ruby/setup-ruby v1 composite

.github/workflows/lint.yml actions

actions/cache v1 composite
actions/checkout v2 composite
ruby/setup-ruby v1 composite

.github/workflows/tests.yml actions

actions/checkout v2 composite
ruby/setup-ruby v1 composite

regexp_parser.gemspec rubygems

Score: 30.7052857037073

https://github.com/ammar/regexp_parser

Keywords from Contributors

Repository metadata

README.md

Regexp::Parser

Requirements

Install

Usage

Components

Scanner

Example

Notes

Syntax

Example

Notes

Lexer

Example

Notes

Parser

Example

Supported Syntax

Inapplicable Features

Testing

Building

References

Example Projects

Ruby Flavors

Regular Expressions

Unicode

Copyright

Owner metadata

GitHub Events

Total

Last Year

Committers metadata

Committer domains:

Issue and Pull Request metadata

Top Issue Authors

Top Pull Request Authors

Top Issue Labels

Top Pull Request Labels

Package metadata

gem.coop: regexp_parser

rubygems.org: regexp_parser

proxy.golang.org: github.com/ammar/regexp_parser

ubuntu-20.04: ruby-regexp-parser

debian-11: ruby-regexp-parser

ubuntu-23.10: ruby-regexp-parser

ubuntu-23.04: ruby-regexp-parser

ubuntu-24.10: ruby-regexp-parser

debian-10: ruby-regexp-parser

debian-12: ruby-regexp-parser

ubuntu-22.04: ruby-regexp-parser

ubuntu-24.04: ruby-regexp-parser

debian-13: ruby-regexp-parser

Dependencies