reject/ereject extension

Author: foxcpp

AGENTS.md

@@ -44,6 +44,10 @@ go run ./cmd/sieve-run -scriptPath ./cmd/sieve-run/test.sieve -eml ./cmd/sieve-r
 - Some upstream tests are intentionally disabled with documented reasons (`tests/base_test.go`); preserve these expectations unless fixing underlying parser/address behavior.
 - `interp/dovecot_testsuite.go` intentionally treats `test_error` checks as no-op pass (go-sieve stops on first error; Pigeonhole collects multiple). `test_imap_metadata_set` is unimplemented and will error if used in `.svtest` files.
 - `CmdDovecotTest.Execute` copies `RuntimeData` via `d.Copy()` for isolation between test blocks — commands inside `test { ... }` do not affect outer state.
+- New upstream tests should be added to `tests/` as `.svtest` files, not as Go unit tests, to preserve the Dovecot test suite as the canonical source of accepted-invalid-script cases.
+- New features should be added with both Go unit tests (for API-level validation) and `.svtest` cases (to preserve Dovecot test suite coverage).
+- Tests that expect certain MTA behavior should be added to `tests/execute.go`. `ExecuteTestEnvironment` is an interface to mock MTA environment that applies actions and provides access to results (e.g. sent messages); use it for tests that care about action semantics. For tests that only care about script acceptance/rejection, `RunDovecotTest` without extra parameters is sufficient. 
+- Tests added to `tests/execute.go` should pass with the simple `simpleExecuteRuntime` implemented in `tests/execute_test.go`. This ensures that go-sieve is able to provide enough data to the MTA to execute correct decisions.
 
 ## Known caveats to preserve
 - `README.md` lists accepted-invalid-script gaps and address parsing caveats; avoid changes that silently alter these behaviors without targeted tests.

README.md

@@ -1,8 +1,12 @@
 go-sieve
 ====================
 
-Sieve email filtering language ([RFC 5228])
-implementation in Go.
+Sieve email filtering language ([RFC 5228]) interpreter implementation in Go.
+
+## Features
+
+* Binary representation for faster load/execute cycles (`Script.Save`, `sieve.RestoreSaved`).
+* Integration tests harness for MTA integration testing (see `tests/execute.go`).
 
 ## Supported extensions
 
@@ -12,6 +16,8 @@ implementation in Go.
 - imap4flags ([RFC 5232])
 - variables ([RFC 5229])
 - relational ([RFC 5231])
+- copy ([RFC 3894])
+- reject/ereject ([RFC 5429])
 
 ## Example
 
@@ -27,4 +33,5 @@ See ./cmd/sieve-run.
 [RFC 5229]: https://datatracker.ietf.org/doc/html/rfc5229
 [RFC 5232]: https://datatracker.ietf.org/doc/html/rfc5232
 [RFC 5231]: https://datatracker.ietf.org/doc/html/rfc5231
-
+[RFC 3894]: https://datatracker.ietf.org/doc/html/rfc3894
+[RFC 5429]: https://datatracker.ietf.org/doc/html/rfc5429

interp/action.go

@@ -224,6 +224,30 @@ func (c CmdRemoveFlag) Execute(_ context.Context, d *RuntimeData) error {
 	return nil
 }
 
+type CmdReject struct {
+	Reason string
+}
+
+func (c CmdReject) Execute(ctx context.Context, d *RuntimeData) error {
+	if err := d.OnAction(ctx, ActionReject{Reason: expandVars(d, c.Reason)}, d); err != nil {
+		return err
+	}
+	d.ImplicitKeep = false
+	return nil
+}
+
+type CmdEReject struct {
+	Reason string
+}
+
+func (c CmdEReject) Execute(ctx context.Context, d *RuntimeData) error {
+	if err := d.OnAction(ctx, ActionEReject{Reason: expandVars(d, c.Reason)}, d); err != nil {
+		return err
+	}
+	d.ImplicitKeep = false
+	return nil
+}
+
 func init() {
 	gob.Register(CmdStop{})
 	gob.Register(CmdFileInto{})
@@ -233,4 +257,6 @@ func init() {
 	gob.Register(CmdSetFlag{})
 	gob.Register(CmdAddFlag{})
 	gob.Register(CmdRemoveFlag{})
+	gob.Register(CmdReject{})
+	gob.Register(CmdEReject{})
 }

interp/applied_action.go

@@ -32,5 +32,19 @@ type ActionRedirect struct {
 	Copy    bool
 }
 
-func (ActionRedirect) testActionName() string            { return "redirect" }
+func (ActionRedirect) testActionName() string              { return "redirect" }
 func (a ActionRedirect) cancelsImplicitKeep() bool { return !a.Copy }
+
+type ActionReject struct {
+	Reason string
+}
+
+func (ActionReject) testActionName() string    { return "reject" }
+func (ActionReject) cancelsImplicitKeep() bool { return true }
+
+type ActionEReject struct {
+	Reason string
+}
+
+func (ActionEReject) testActionName() string    { return "ereject" }
+func (ActionEReject) cancelsImplicitKeep() bool { return true }

interp/dovecot_testsuite.go

@@ -399,7 +399,9 @@ func (t TestDovecotResultAction) Check(_ context.Context, d *RuntimeData) (bool,
 	if t.isCount() {
 		entryCount := uint64(0)
 		if t.Index != nil {
-			if *t.Index < len(d.AppliedActions) {
+			// Pigeonhole uses 1-based indexing for :index in test_result_action.
+			idx := *t.Index - 1
+			if idx >= 0 && idx < len(d.AppliedActions) {
 				entryCount++
 			}
 		} else {
@@ -410,10 +412,12 @@ func (t TestDovecotResultAction) Check(_ context.Context, d *RuntimeData) (bool,
 	}
 
 	if t.Index != nil {
-		if *t.Index >= len(d.AppliedActions) {
+		// Pigeonhole uses 1-based indexing for :index in test_result_action.
+		idx := *t.Index - 1
+		if idx < 0 || idx >= len(d.AppliedActions) {
 			return false, nil
 		}
-		action := d.AppliedActions[*t.Index]
+		action := d.AppliedActions[idx]
 
 		ok, err := t.matcherTest.tryMatch(d, action.testActionName())
 		if err != nil {

interp/load.go

@@ -23,6 +23,8 @@ var supportedRequires = map[string]struct{}{
 	"variables":  {},
 	"relational": {},
 	"copy":        {},
+	"reject":      {},
+	"ereject":     {},
 }
 
 var (
@@ -50,6 +52,9 @@ func init() {
 		"removeflag": loadRemoveFlag,
 		// RFC 5229 (variables extension)
 		"set": loadSet,
+		// RFC 5429 (reject/ereject extensions)
+		"reject":  loadReject,
+		"ereject": loadEReject,
 		// vnd.dovecot.testsuite
 		"test":                loadDovecotTest,
 		"test_set":            loadDovecotTestSet,

interp/load_action.go

@@ -163,6 +163,50 @@ func loadDiscard(s *Script, pcmd parser.Cmd) (Cmd, error) {
 	return cmd, err
 }
 
+func loadReject(s *Script, pcmd parser.Cmd) (Cmd, error) {
+	if !s.RequiresExtension("reject") {
+		return nil, parser.ErrorAt(pcmd.Position, "missing require 'reject'")
+	}
+	cmd := CmdReject{}
+	err := LoadSpec(s, &Spec{
+		Pos: []SpecPosArg{
+			{
+				MinStrCount: 1,
+				MaxStrCount: 1,
+				MatchStr: func(val []string) {
+					cmd.Reason = val[0]
+				},
+			},
+		},
+	}, pcmd.Position, pcmd.Args, pcmd.Tests, pcmd.Block)
+	if err != nil {
+		return nil, err
+	}
+	return cmd, nil
+}
+
+func loadEReject(s *Script, pcmd parser.Cmd) (Cmd, error) {
+	if !s.RequiresExtension("ereject") {
+		return nil, parser.ErrorAt(pcmd.Position, "missing require 'ereject'")
+	}
+	cmd := CmdEReject{}
+	err := LoadSpec(s, &Spec{
+		Pos: []SpecPosArg{
+			{
+				MinStrCount: 1,
+				MaxStrCount: 1,
+				MatchStr: func(val []string) {
+					cmd.Reason = val[0]
+				},
+			},
+		},
+	}, pcmd.Position, pcmd.Args, pcmd.Tests, pcmd.Block)
+	if err != nil {
+		return nil, err
+	}
+	return cmd, nil
+}
+
 func loadFlagCmd(s *Script, pcmd parser.Cmd) (variable string, flags []string, err error) {
 	var arg1, arg2 []string
 	err = LoadSpec(s, &Spec{

interp/load_dovecot.go

@@ -266,7 +266,15 @@ func loadDovecotResultAction(s *Script, test parser.Test) (Test, error) {
 			},
 		},
 	}), test.Position, test.Args, test.Tests, nil)
-	return loaded, err
+	if err != nil {
+		return nil, err
+	}
+
+	if err := loaded.setKey(s, loaded.Key); err != nil {
+		return nil, err
+	}
+
+	return loaded, nil
 }
 
 func loadDovecotResultReset(s *Script, cmd parser.Cmd) (Cmd, error) {

interp/load_test.go

@@ -67,6 +67,7 @@ if envelope :is "from" "test@example.org" {
 					Comparator: ComparatorASCIICaseMap,
 					Match:      MatchIs,
 					Key:        []string{"test@example.org"},
+					matchCnt:   1,
 				},
 				AddressPart: All,
 				Field:       []string{"from"},
@@ -92,10 +93,10 @@ removeflag "flag2";
 			Flags: Flags{"flag1", "flag2"},
 		},
 		CmdSetFlag{
-			Flags: Flags{"flag1", "flag2"},
+			Flags: Flags{"flag2", "flag1"},
 		},
 		CmdAddFlag{
-			Flags: Flags{"flag1", "flag2"},
+			Flags: Flags{"flag2", "flag1"},
 		},
 		CmdRemoveFlag{
 			Flags: Flags{"flag2"},

interp/runtime.go

@@ -46,6 +46,9 @@ type ExecuteTestMessage struct {
 	Flags    []string
 }
 
+// ExecuteTestEnvironment is a mock MTA interface used for integration tests. It is possible to test
+// the actual execution of actions (fileinto, redirect, keep, etc.) using this interface in a particular
+// MTA implementation.
 type ExecuteTestEnvironment interface {
 	CreateMailbox(name string) error
 	// GetDefaultMailbox returns the mailbox name used by keep action.