lambdaisland.regal — lambdaisland/regal 0.1.175

Compile Regal syntax to regex patterns.

(regex [:cat :start [:class [\a \z] [\A \Z] [\0 \9] _ -] "@" [:repeat [:class [\0 \9]] 3 5] [:* [:not .]] [:alt "com" "org" "net"] :end]) #"\A[a-zA-Z0-9_-]\Q@\E[0-9]{3,5}[^.]*(?:\Qcom\E|\Qorg\E|\Qnet\E)\z"

*character-class* clj/s

*flavor* clj/s

-regal->ir clj/s multimethod

assert-line-break-not-in-class clj/s

(assert-line-break-not-in-class)

char-class-escape clj/s

(char-class-escape ch)

compile clj/s

(compile s)

Compile a regex pattern (string) to a regex.

current-flavor? clj/s

(current-flavor? f)

escape clj/s

(escape s)

Escape a regex pattern, so that, when compiled to a regex object, it will match all characters literally.

flavor-hierarchy clj/s

grouped clj/s

(grouped r)

left-pad clj/s

(left-pad s len pad)

left-pad-str clj/s

(left-pad-str s len pad)

non-whitespace-ranges-codes clj/s

Character ranges that are not whitespace (the opposite of the above)

non-whitespace-ranges-common clj/s

Character ranges that are not whitespace (the opposite of the above)

non-whitespace-ranges-re2 clj/s

Character ranges that are not whitespace (the opposite of the above)

normalize clj/s

(normalize form)

Returns a canonical, normalized version of a Regal form. Normalization is idempotent. This function is mostly here to allow us to do property-based testing on Regal itself, in particular we guarantee that for normalized form compiling to regex, then parsing again returns the same form. Might be useful for some other cases, e.g. if you want to memoize compiled regexes.

Parsing generally returns canonical (normalized) forms, so there is no need to normalize the result of lambdaisland.regal.parse/parse.

• Turns characters into strings (Java)
• removes unnecessary [:cat ...] groupings
• removes single element [:alt ...] grouping
• join consecutive strings
• remove [:class ...] groups that only wrap a single character or token (keyword)
• replace :null with [:char 0]
• replace [:not :whitespace] with :non-whitespace

pattern clj/s

(pattern form)

(pattern form opts)

Convert a Regal form to a regex pattern as a string.

quantifier->ir clj/s

(quantifier->ir q rs opts)

quote-char clj/s multimethod

regex clj/s

(regex form)

(regex form {:keys [resolver] :as opts})

Convert a Regal form into a platform-specific regex pattern object.

Can take an options map:

• :resolver a function/map used to resolve namespaced keywords inside Regal expressions.

regex-pattern clj/s

(regex-pattern r)

Regex to string, remove the slashes that JavaScript likes to add. This will drop any regex modifiers.

runtime-flavor clj/s

(runtime-flavor)

The regex flavor that the current runtime understands.

single-character? clj/s

(single-character? s)

tagged-form? clj/s

(tagged-form? tag form)

Is the given form a vector with the given tag as first element?

token->ir clj/s multimethod

unsupported-operation clj/s

(unsupported-operation op)

unsupported-operation-exception clj/s

(unsupported-operation-exception msg)

whitespace-char-codes clj/s

These are characters with the Unicode whitespace property. In JavaScript these are all matched by \s, except for NEXT LINE and MONGOLIAN VOWEL SEPARATOR. In Java \s only matches the ASCII one. In Regal :whitespace emulates the JavaScript semantics of \s.

whitespace-chars-common clj/s

whitespace-chars-re2 clj/s

with-flavor clj/s macro

(with-flavor flavor & body)

Set the flavor of regex to use for generating and parsing regex patterns. Defaults to the flavor understood by the runtime. flavor can be :ecma, :java8 (Java 8) or :java9 (Java 9 or later). Earlier Java versions are not officially supported, meaning some patterns will behave differently.