onigleam - v1.0.0

onigleam

Types

ConversionResult

Result of a successful conversion with details

pub type ConversionResult {
  ConversionResult(
    pattern: String,
    regexp_options: regexp.Options,
    capture_names: dict.Dict(String, Int),
    warnings: List(String),
  )
}

Constructors 

  • ConversionResult(
  pattern: String,
  regexp_options: regexp.Options,
  capture_names: dict.Dict(String, Int),
  warnings: List(String),
)

    Arguments

    pattern

    The generated pattern string

    regexp_options

    Options to pass to gleam_regexp

    capture_names

    Mapping of capture group names to their 1-based index

    warnings

    Any warnings generated during conversion

ParseError 

pub type ParseError =
  errors.ParseError

TokenizeError 

pub type TokenizeError =
  errors.TokenizeError

TransformError 

pub type TransformError =
  errors.TransformError

Values

convert 

pub fn convert(
  pattern: String,
) -> Result(ConversionResult, errors.ConversionError)

Convert with default options

Convenience function using default options. Use this for simple conversions.

Example

import onigleam

let assert Ok(result) = onigleam.convert("[a-z]+")
result.pattern  // "[a-z]+"

convert_textmate 

pub fn convert_textmate(
  pattern: String,
) -> Result(ConversionResult, errors.ConversionError)

Convert for TextMate grammar use

TextMate grammars often have patterns with orphan backreferences (references to capture groups that may not exist in the current pattern). This function enables the allow_orphan_backrefs option which treats these as warnings instead of errors.

Example

import onigleam

// This pattern references group 1 which doesn't exist
let assert Ok(result) = onigleam.convert_textmate("\\1")
// Returns Ok with a warning instead of an error

convert_with_flags 

pub fn convert_with_flags(
  pattern: String,
  flags: String,
) -> Result(ConversionResult, errors.ConversionError)

Convert with flags

Convenience function that sets Oniguruma flags.

Example

// Case-insensitive matching
let assert Ok(result) = onigleam.convert_with_flags("abc", "i")

format_error 

pub fn format_error(error: errors.ConversionError) -> String

Format a conversion error as a human-readable string

Example

import onigleam

case onigleam.convert("(?>atomic)") {
  Ok(result) -> result.pattern
  Error(err) -> onigleam.format_error(err)
  // "Atomic groups (?>...) cannot be emulated in gleam_regexp"
}

to_regexp 

pub fn to_regexp(
  pattern: String,
  opts: options.ToRegexpOptions,
) -> Result(regexp.Regexp, errors.ConversionError)

Convert an Oniguruma pattern directly to a compiled gleam_regexp

This is a convenience function that combines to_regexp_details with regexp.compile.

Example

import onigleam
import onigleam/options

let assert Ok(re) = onigleam.to_regexp(
  "\\d+",
  options.default_options(),
)

to_regexp_details 

pub fn to_regexp_details(
  pattern: String,
  options: options.ToRegexpOptions,
) -> Result(ConversionResult, errors.ConversionError)

Convert an Oniguruma pattern to a gleam_regexp pattern string with details

Returns the pattern string, regexp options, capture name mapping, and any warnings.

Example

import onigleam
import onigleam/options
import gleam/regexp

let assert Ok(result) = onigleam.to_regexp_details(
  "(?<name>\\w+)",
  options.default_options(),
)

// Use the pattern with gleam_regexp
let assert Ok(re) = regexp.compile(result.pattern, result.regexp_options)
✨ Search Document