christiangeorgelucas/regex-tools

package nodes

import (
	"context"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// FindAll returns every non-overlapping match of an RE2 pattern in input,
// leftmost-first, each with its full text, byte offsets, and numbered
// capture groups. limit caps how many matches come back (default 1000,
// hard-capped at 10000); truncated reports whether the cap was hit.
func FindAll(ctx context.Context, ax axiom.Context, input *gen.RegexFindAllRequest) (*gen.RegexFindAllResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexFindAllResult{Error: code}, nil
	}

	limit := clampFindLimit(input.GetLimit())
	// Ask for one more than the cap so we can tell whether there were more
	// matches beyond it (truncated) without a second, unbounded pass.
	all := re.FindAllStringSubmatchIndex(input.GetInput(), limit+1)

	truncated := len(all) > limit
	if truncated {
		all = all[:limit]
	}

	matches := make([]*gen.RegexMatch, 0, len(all))
	for _, idx := range all {
		matches = append(matches, matchFromIndex(input.GetInput(), idx))
	}

	return &gen.RegexFindAllResult{
		Matches:   matches,
		Count:     int32(len(matches)),
		Truncated: truncated,
	}, nil
}

package nodes

import (
	"context"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// FindFirst returns the leftmost match of an RE2 pattern in input, with the
// full matched text, its byte offsets, and every numbered capture group's
// text and offsets. found is false when the pattern does not match at all.
func FindFirst(ctx context.Context, ax axiom.Context, input *gen.RegexFindRequest) (*gen.RegexFindResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexFindResult{Error: code}, nil
	}
	idx := re.FindStringSubmatchIndex(input.GetInput())
	if idx == nil {
		return &gen.RegexFindResult{Found: false}, nil
	}
	return &gen.RegexFindResult{
		Found: true,
		Match: matchFromIndex(input.GetInput(), idx),
	}, nil
}

package nodes

import (
	"context"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// FindNamedGroups extracts every match's named capture groups as a direct
// name→value map, e.g. pattern `(?P<year>\d{4})-(?P<month>\d{2})` on
// "2026-07" yields {"year":"2026","month":"07"}. A named group that did not
// participate in a given match is omitted from that match's map. limit and
// truncation behave exactly as FindAll's.
func FindNamedGroups(ctx context.Context, ax axiom.Context, input *gen.RegexNamedGroupsRequest) (*gen.RegexNamedGroupsResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexNamedGroupsResult{Error: code}, nil
	}

	names := re.SubexpNames() // names[0] is always "" (whole match)
	namesPresent := false
	for _, n := range names {
		if n != "" {
			namesPresent = true
			break
		}
	}

	limit := clampFindLimit(input.GetLimit())
	all := re.FindAllStringSubmatchIndex(input.GetInput(), limit+1)

	truncated := len(all) > limit
	if truncated {
		all = all[:limit]
	}

	text := input.GetInput()
	results := make([]*gen.RegexNamedGroupMatch, 0, len(all))
	for _, idx := range all {
		groups := make(map[string]string)
		for i := 1; i < len(names); i++ {
			if names[i] == "" {
				continue
			}
			gs, ge := idx[2*i], idx[2*i+1]
			if gs < 0 {
				continue // group did not participate in this match
			}
			groups[names[i]] = text[gs:ge]
		}
		results = append(results, &gen.RegexNamedGroupMatch{Groups: groups})
	}

	return &gen.RegexNamedGroupsResult{
		Matches:           results,
		Count:             int32(len(results)),
		Truncated:         truncated,
		GroupNamesPresent: namesPresent,
	}, nil
}

package nodes

import (
	"context"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// Replace substitutes only the first (leftmost) match of an RE2 pattern in
// input with replacement, which may reference capture groups via Go's
// expand syntax ($1, ${1}, ${name}; $$ for a literal dollar). replaced is
// false (output equals input unchanged) when the pattern does not match.
func Replace(ctx context.Context, ax axiom.Context, input *gen.RegexReplaceRequest) (*gen.RegexReplaceResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexReplaceResult{Error: code}, nil
	}

	text := input.GetInput()
	idx := re.FindStringSubmatchIndex(text)
	if idx == nil {
		return &gen.RegexReplaceResult{Output: text, Replaced: false}, nil
	}

	expanded := re.ExpandString(nil, input.GetReplacement(), text, idx)
	output := text[:idx[0]] + string(expanded) + text[idx[1]:]
	return &gen.RegexReplaceResult{Output: output, Replaced: true}, nil
}

package nodes

import (
	"context"
	"strings"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// ReplaceAll substitutes every non-overlapping match of an RE2 pattern in
// input with replacement (same $1/${name} backreference syntax as Replace),
// returning the resulting text and how many substitutions were made. RE2's
// linear-time guarantee bounds the match search itself; a large result (a
// zero-width match repeated many times with a long replacement) is the
// platform's payload/memory concern, not this node's, so it's returned in
// full rather than truncated.
func ReplaceAll(ctx context.Context, ax axiom.Context, input *gen.RegexReplaceAllRequest) (*gen.RegexReplaceAllResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexReplaceAllResult{Error: code}, nil
	}

	text := input.GetInput()
	allIdx := re.FindAllStringSubmatchIndex(text, -1)
	if len(allIdx) == 0 {
		return &gen.RegexReplaceAllResult{Output: text, Replacements: 0}, nil
	}

	var b strings.Builder
	b.Grow(len(text))
	last := 0
	for _, idx := range allIdx {
		b.WriteString(text[last:idx[0]])
		b.Write(re.ExpandString(nil, input.GetReplacement(), text, idx))
		last = idx[1]
	}
	b.WriteString(text[last:])

	return &gen.RegexReplaceAllResult{
		Output:       b.String(),
		Replacements: int32(len(allIdx)),
	}, nil
}

package nodes

import (
	"context"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// Split slices input on every match of an RE2 pattern, returning the pieces
// strictly between (and around) matches, in order. A positive limit caps
// the result at that many pieces, Go regexp.Split-style, with the
// remainder folded into the last piece; limit <= 0 (including an omitted
// field, since proto3 has no way to distinguish "not set" from "explicitly
// zero") means "every piece" rather than Go's own literal n==0 "no pieces"
// behavior — a default of "return nothing" would be a footgun for any
// caller that simply omits limit. A large piece count for an unbounded
// request is the platform's response-size concern, not this node's.
func Split(ctx context.Context, ax axiom.Context, input *gen.RegexSplitRequest) (*gen.RegexSplitResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexSplitResult{Error: code}, nil
	}

	text := input.GetInput()
	requested := int(input.GetLimit())

	n := -1 // "every piece" (Go's regexp.Split unbounded sentinel)
	if requested > 0 {
		n = requested
	}

	parts := re.Split(text, n)
	return &gen.RegexSplitResult{
		Parts: parts,
		Count: int32(len(parts)),
	}, nil
}

package nodes

import (
	"context"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// Test reports whether an RE2 pattern matches anywhere in input, using Go's
// linear-time regexp engine — so an adversarial pattern cannot cause
// catastrophic-backtracking ReDoS. Pure function; safe to call repeatedly.
func Test(ctx context.Context, ax axiom.Context, input *gen.RegexTestRequest) (*gen.RegexTestResult, error) {
	re, code := compilePattern(input.GetPattern(), input.GetFlags())
	if code != "" {
		return &gen.RegexTestResult{Error: code}, nil
	}
	return &gen.RegexTestResult{Matched: re.MatchString(input.GetInput())}, nil
}

package nodes

import (
	"context"
	"fmt"
	"regexp"
	"strings"

	"christiangeorgelucas/regex-tools/axiom"
	gen "christiangeorgelucas/regex-tools/gen"
)

// ValidatePattern compile-checks an RE2 pattern without matching it against
// any input. When invalid, error_message holds Go regexp/syntax's own
// human-readable compile error (naming the offending construct — e.g. an
// unsupported PCRE-only backreference or lookaround RE2 deliberately does
// not support). When valid, group_count and group_names report the
// pattern's numbered capture groups in source order.
func ValidatePattern(ctx context.Context, ax axiom.Context, input *gen.RegexValidateRequest) (*gen.RegexValidateResult, error) {
	pattern := input.GetPattern()
	flags := input.GetFlags()

	if pattern == "" {
		return &gen.RegexValidateResult{Valid: false, ErrorMessage: "pattern must not be empty"}, nil
	}
	for _, c := range flags {
		if !strings.ContainsRune(validFlagChars, c) {
			return &gen.RegexValidateResult{
				Valid:        false,
				ErrorMessage: fmt.Sprintf("invalid flag %q: only i, m, s, U are supported", string(c)),
			}, nil
		}
	}

	full := pattern
	if flags != "" {
		full = "(?" + flags + ")" + pattern
	}
	re, err := regexp.Compile(full)
	if err != nil {
		return &gen.RegexValidateResult{Valid: false, ErrorMessage: err.Error()}, nil
	}

	names := re.SubexpNames() // names[0] is always "" (whole match)
	groupNames := make([]string, 0, len(names)-1)
	if len(names) > 1 {
		groupNames = append(groupNames, names[1:]...)
	}

	return &gen.RegexValidateResult{
		Valid:      true,
		GroupCount: int32(len(groupNames)),
		GroupNames: groupNames,
	}, nil
}