bobzhang/asciidoctor/regex

bobzhang/asciidoctor/regex does not have a README file

RegexError

pub suberror RegexError {
  RegexError(pattern~ : String, pos~ : Int, message~ : String)
} derive(@moonbitlang/core/debug.Debug
Debug)

Error raised when a pattern (or a flag string) cannot be compiled.

RegexError::to_repr

source

fn RegexError::to_repr(RegexError) -> @moonbitlang/core/debug.Repr
Repr

RegexTimeout

source

pub suberror RegexTimeout {
  RegexTimeout(pattern~ : String, limit~ : Int)
} derive(@moonbitlang/core/debug.Debug
Debug)

Raised when a search exceeds its backtracking step budget (the analogue of Ruby's Regexp::TimeoutError). limit is the budget that was exhausted.

RegexTimeout::to_repr

source

fn RegexTimeout::to_repr(RegexTimeout) -> @moonbitlang/core/debug.Repr
Repr

MatchData

source

pub struct MatchData {
  input : String
  // private fields
}

Result of a successful match.

MatchData::at

source

fn MatchData::at(self : MatchData, i : Int) -> String

Captured text of group i, or "" if it did not participate.

MatchData::begin

source

fn MatchData::begin(self : MatchData, i? : Int) -> Int

Start offset of group i (-1 if unset).

MatchData::end

source

fn MatchData::end(self : MatchData, i? : Int) -> Int

End offset of group i (-1 if unset).

MatchData::expand

source

fn MatchData::expand(self : MatchData, template : String) -> String

Expands a Ruby replacement template: \0/\&, \1..\9, \k<name>, \` , \', \\.

MatchData::group

source

fn MatchData::group(self : MatchData, i : Int) -> String?

Captured text of group i (0 = whole match), or None if the group did not participate.

MatchData::groups

source

fn MatchData::groups(self : MatchData) -> Array[String?]

All groups (including group 0) as optional strings.

MatchData::has

source

fn MatchData::has(self : MatchData, i : Int) -> Bool

Whether group i participated in the match.

MatchData::has_names

source

fn MatchData::has_names(self : MatchData) -> Bool

Whether the pattern has named groups.

MatchData::matched

source

fn MatchData::matched(self : MatchData) -> String

The whole matched text.

MatchData::named

source

fn MatchData::named(self : MatchData, name : String) -> String?

Text of a named group.

MatchData::post_match

source

fn MatchData::post_match(self : MatchData) -> String

Text after the match.

MatchData::pre_match

source

fn MatchData::pre_match(self : MatchData) -> String

Text before the match.

MatchData::size

source

fn MatchData::size(self : MatchData) -> Int

Number of groups including group 0.

Regex

source

pub struct Regex {
  source : String
  // private fields
}

A compiled regular expression using Ruby (Onigmo) syntax and semantics, operating on UTF-16 strings with absolute code-unit offsets.

Semantics follow Ruby: ^/$ are always line anchors, the m flag makes . match newlines (dot-all), \w/\d/\s are ASCII-only while \b and \p{Word} are Unicode-aware, and an unset group never matches a backreference. Matching works on code points: a match never starts or ends inside a surrogate pair, even though offsets are reported in UTF-16 code units.

Each search operation runs under a step budget (see compile); the try_* methods raise RegexTimeout when it is exhausted, the other methods abort.

Regex::find

source

fn Regex::find(self : Regex, s : String, start? : Int) -> MatchData?

Finds the first match at or after start (Ruby's String#match(re, start)). A start inside a surrogate pair is rounded up to the next code point.

Regex::find_all

source

fn Regex::find_all(self : Regex, s : String) -> Array[MatchData]

All successive non-overlapping matches (Ruby's scan).

Regex::group_count

source

fn Regex::group_count(self : Regex) -> Int

Number of capture groups.

Regex::gsub

source

fn Regex::gsub(self : Regex, s : String, template : String) -> String

Ruby's gsub(re, template).

Regex::match_at

source

fn Regex::match_at(self : Regex, s : String, pos : Int) -> MatchData?

Matches only at position pos (like Ruby's \G-anchored match). There is no match at an offset inside a surrogate pair.

Regex::matches

source

fn Regex::matches(self : Regex, s : String) -> Bool

Whether the pattern matches anywhere in s (Ruby's match?).

Regex::replace

source

fn Regex::replace(self : Regex, s : String, f : (MatchData) -> String) -> String

Replaces every match with the result of f (Ruby's gsub with a block).

Regex::replace_first

source

fn Regex::replace_first(self : Regex, s : String, f : (MatchData) -> String) -> String

Replaces the first match with the result of f (Ruby's sub with a block).

Regex::split

source

fn Regex::split(self : Regex, s : String, limit? : Int) -> Array[String]

Ruby's String#split(re, limit). With limit == 0 (default) trailing empty strings are removed; captured groups are included in the result.

Regex::sub

source

fn Regex::sub(self : Regex, s : String, template : String) -> String

Ruby's sub(re, template).

Regex::to_string

source

fn Regex::to_string(self : Regex) -> String

The pattern source in Ruby literal form, e.g. /a+/.

Regex::try_find

source

fn Regex::try_find(self : Regex, s : String, start? : Int) -> MatchData? raise RegexTimeout

Like find, but raises RegexTimeout when the step budget runs out.

Regex::try_find_all

source

fn Regex::try_find_all(self : Regex, s : String) -> Array[MatchData] raise RegexTimeout

Like find_all, but raises RegexTimeout when the step budget (shared by the whole scan) runs out.

Regex::try_match_at

source

fn Regex::try_match_at(self : Regex, s : String, pos : Int) -> MatchData? raise RegexTimeout

Like match_at, but raises RegexTimeout when the step budget runs out.

Regex::try_replace

source

fn Regex::try_replace(self : Regex, s : String, f : (MatchData) -> String, once? : Bool) -> String raise RegexTimeout

Like replace (or replace_first when once is true), but raises RegexTimeout when the step budget (shared by the whole operation) runs out.

Regex::try_split

source

fn Regex::try_split(self : Regex, s : String, limit? : Int) -> Array[String] raise RegexTimeout

Like split, but raises RegexTimeout when the step budget (shared by the whole operation) runs out.

compile

source

fn compile(pattern : String, flags? : String, step_limit? : Int) -> Regex raise RegexError

Compiles pattern. flags may contain Ruby's options: m (dot-all), i (ignore case, using Unicode simple case folding; multi-character folds such as ß = ss are not supported) and x (extended: whitespace and # comments outside classes are ignored). Any other flag is an error. The inline forms (?imx-imx) and (?imx-imx:...) are supported too.

step_limit bounds the backtracking work of each search operation (a step is one branch or one sub-match); 0 selects the default, which is generous (10M steps plus roughly the square of the input length, see step_limit_for) so that it only trips on catastrophic backtracking.

Patterns that Onigmo rejects, or that would exceed internal limits (group nesting beyond 256, programs beyond 1M instructions), raise RegexError.

test {
  let re = @regex.compile("(\\w+)@(\\w+)")
  guard re.find("mail: joe@example") is Some(m) else { fail("no match") }
  debug_inspect(m.group(2), content="Some(\"example\")")
  inspect(@regex.compile("HELLO", flags="i").matches("hello"), content="true")
}

re

source

fn re(pattern : String, flags? : String, step_limit? : Int) -> Regex

Like compile but aborts on an invalid pattern. Intended for literal patterns.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#RegexError

#RegexError::to_repr

#RegexTimeout

#RegexTimeout::to_repr

#MatchData

#MatchData::at

#MatchData::begin

#MatchData::end

#MatchData::expand

#MatchData::group

#MatchData::groups

#MatchData::has

#MatchData::has_names

#MatchData::matched

#MatchData::named

#MatchData::post_match

#MatchData::pre_match

#MatchData::size

#Regex

#Regex::find

#Regex::find_all

#Regex::group_count

#Regex::gsub

#Regex::match_at

#Regex::matches

#Regex::replace

#Regex::replace_first

#Regex::split

#Regex::sub

#Regex::to_string

#Regex::try_find

#Regex::try_find_all

#Regex::try_match_at

#Regex::try_replace

#Regex::try_split

#compile

#re

Source Files

RegexError

RegexError::to_repr

RegexTimeout

RegexTimeout::to_repr

MatchData

MatchData::at

MatchData::begin

MatchData::end

MatchData::expand

MatchData::group

MatchData::groups

MatchData::has

MatchData::has_names

MatchData::matched

MatchData::named

MatchData::post_match

MatchData::pre_match

MatchData::size

Regex

Regex::find

Regex::find_all

Regex::group_count

Regex::gsub

Regex::match_at

Regex::matches

Regex::replace

Regex::replace_first

Regex::split

Regex::sub

Regex::to_string

Regex::try_find

Regex::try_find_all

Regex::try_match_at

Regex::try_replace

Regex::try_split

compile

re