summercms/modules/party/registry_test.go

package party

import (
	"context"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"testing/fstest"

	"git.golem15.com/golem15/summercms/modules/backpack"
	"git.golem15.com/golem15/summercms/modules/bonfire"
	"git.golem15.com/golem15/summercms/modules/compass"
	"git.golem15.com/golem15/summercms/modules/pact"
	"git.golem15.com/golem15/summercms/modules/phrasebook"
	"git.golem15.com/golem15/summercms/modules/postcard"
	"git.golem15.com/golem15/summercms/modules/signpost"
)

type tracePlugin struct {
	id  string
	req []string
	log *[]string
}

func (p *tracePlugin) ID() string         { return p.id }
func (p *tracePlugin) Requires() []string { return p.req }

func (p *tracePlugin) Register(*backpack.App) error {
	*p.log = append(*p.log, p.id+":register")
	return nil
}

func (p *tracePlugin) Boot(*backpack.App) error {
	*p.log = append(*p.log, p.id+":boot")
	return nil
}

type configPlugin struct {
	id   string
	fsys fs.FS
	got  *int
}

func (p *configPlugin) ID() string         { return p.id }
func (p *configPlugin) Requires() []string { return nil }
func (p *configPlugin) ConfigFS() fs.FS    { return p.fsys }

func (p *configPlugin) Register(app *backpack.App) error {
	if app != nil && app.Config != nil {
		*p.got = app.Config.Int("golem15.hello.posts_per_page")
	}
	return nil
}

func (p *configPlugin) Boot(*backpack.App) error { return nil }

func TestActivateMergesHasConfigBeforeRegister(t *testing.T) {
	dir := t.TempDir()
	if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: app\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	cfg, err := compass.Load(dir)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	var got int
	p := &configPlugin{
		id:  "golem15.hello",
		got: &got,
		fsys: fstest.MapFS{
			"config/config.yaml": {Data: []byte("posts_per_page: 10\n")},
		},
	}
	app := backpack.New(cfg)
	if _, err := activate([]Plugin{p}, app, []string{"golem15.hello"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	if got != 10 {
		t.Fatalf("posts_per_page during Register = %d, want 10 (HasConfig must merge before Register)", got)
	}
}

func TestActivateMissingRequiresNamesIDsAndSkipsBoot(t *testing.T) {
	var log []string
	p := &tracePlugin{id: "golem15.greeter", req: []string{"golem15.hello"}, log: &log}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{p}, app, []string{"golem15.greeter"})
	if err == nil {
		t.Fatal("expected missing dependency error")
	}
	msg := err.Error()
	if !strings.Contains(msg, "golem15.greeter") || !strings.Contains(msg, "golem15.hello") {
		t.Fatalf("error %q should name both plugin IDs", msg)
	}
	if strings.Contains(strings.Join(log, ","), "boot") {
		t.Fatalf("Boot ran despite missing dependency: %v", log)
	}
}

func TestActivateCycleNamesIDsAndSkipsBoot(t *testing.T) {
	var log []string
	a := &tracePlugin{id: "golem15.a", req: []string{"golem15.b"}, log: &log}
	b := &tracePlugin{id: "golem15.b", req: []string{"golem15.a"}, log: &log}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{a, b}, app, []string{"golem15.a", "golem15.b"})
	if err == nil {
		t.Fatal("expected cycle error")
	}
	msg := err.Error()
	if !strings.Contains(msg, "golem15.a") || !strings.Contains(msg, "golem15.b") {
		t.Fatalf("error %q should name cycle members", msg)
	}
	if strings.Contains(strings.Join(log, ","), "boot") || strings.Contains(strings.Join(log, ","), "register") {
		t.Fatalf("lifecycle ran despite cycle: %v", log)
	}
}

func TestActivateDuplicateIDRejected(t *testing.T) {
	var log []string
	a := &tracePlugin{id: "golem15.hello", log: &log}
	dup := &tracePlugin{id: "golem15.hello", log: &log}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{a, dup}, app, []string{"golem15.hello"})
	if err == nil {
		t.Fatal("expected duplicate id error")
	}
	if !strings.Contains(err.Error(), "golem15.hello") {
		t.Fatalf("error %q should name the duplicate id", err)
	}
}

type bootProbe struct {
	id     string
	req    []string
	log    *[]string
	sawOpt *bool
	booted *[]string
}

func (p *bootProbe) ID() string         { return p.id }
func (p *bootProbe) Requires() []string { return p.req }

func (p *bootProbe) Register(*backpack.App) error {
	*p.log = append(*p.log, p.id+":register")
	return nil
}

func (p *bootProbe) Boot(app *backpack.App) error {
	if p.sawOpt != nil && p.id == "golem15.hello" {
		*p.sawOpt = app.HasPlugin("golem15.optional")
	}
	*p.log = append(*p.log, p.id+":boot")
	if p.booted != nil {
		*p.booted = append(*p.booted, p.id)
	}
	return nil
}

func TestActivateHasPluginSeesNotYetBootedPlugins(t *testing.T) {
	var log []string
	var saw bool
	hello := &bootProbe{id: "golem15.hello", log: &log, sawOpt: &saw}
	opt := &bootProbe{id: "golem15.optional", log: &log}
	app := backpack.New(&compass.Config{})
	if _, err := activate([]Plugin{opt, hello}, app, []string{"golem15.hello", "golem15.optional"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	if !saw {
		t.Fatal("HasPlugin(golem15.optional) was false during hello Boot; complete set must be visible before Boot")
	}
	want := []string{
		"golem15.hello:register",
		"golem15.optional:register",
		"golem15.hello:boot",
		"golem15.optional:boot",
	}
	if strings.Join(log, ",") != strings.Join(want, ",") {
		t.Fatalf("lifecycle = %v, want %v", log, want)
	}
}

func TestActivateIndependentPluginsKeepManifestOrder(t *testing.T) {
	var log []string
	a := &tracePlugin{id: "golem15.a", log: &log}
	b := &tracePlugin{id: "golem15.b", log: &log}
	c := &tracePlugin{id: "golem15.c", log: &log}
	app := backpack.New(&compass.Config{})
	got, err := activate([]Plugin{c, a, b}, app, []string{"golem15.c", "golem15.a", "golem15.b"})
	if err != nil {
		t.Fatalf("activate: %v", err)
	}
	if len(got) != 3 || got[0].ID() != "golem15.c" || got[1].ID() != "golem15.a" || got[2].ID() != "golem15.b" {
		t.Fatalf("order = %v", idsOf(got))
	}
}

func idsOf(plugins []Plugin) []string {
	out := make([]string, len(plugins))
	for i, p := range plugins {
		out[i] = p.ID()
	}
	return out
}

func TestActivateRunsAllRegisterBeforeAnyBoot(t *testing.T) {
	var log []string
	hello := &tracePlugin{id: "golem15.hello", log: &log}
	greeter := &tracePlugin{id: "golem15.greeter", req: []string{"golem15.hello"}, log: &log}
	app := backpack.New(&compass.Config{})

	got, err := activate([]Plugin{greeter, hello}, app, []string{"golem15.greeter", "golem15.hello"})
	if err != nil {
		t.Fatalf("activate: %v", err)
	}
	if len(got) != 2 {
		t.Fatalf("got %d plugins, want 2", len(got))
	}
	if got[0].ID() != "golem15.hello" || got[1].ID() != "golem15.greeter" {
		t.Fatalf("order = %s, %s", got[0].ID(), got[1].ID())
	}

	want := []string{
		"golem15.hello:register",
		"golem15.greeter:register",
		"golem15.hello:boot",
		"golem15.greeter:boot",
	}
	if strings.Join(log, ",") != strings.Join(want, ",") {
		t.Fatalf("lifecycle = %v, want %v", log, want)
	}
}

func TestActivateReorderedManifestStillTopoSorts(t *testing.T) {
	var log []string
	hello := &tracePlugin{id: "golem15.hello", log: &log}
	greeter := &tracePlugin{id: "golem15.greeter", req: []string{"golem15.hello"}, log: &log}
	extra := &tracePlugin{id: "golem15.extra", req: []string{"golem15.greeter"}, log: &log}
	app := backpack.New(&compass.Config{})
	got, err := activate(
		[]Plugin{extra, greeter, hello},
		app,
		[]string{"golem15.extra", "golem15.hello", "golem15.greeter"},
	)
	if err != nil {
		t.Fatalf("activate: %v", err)
	}
	if len(got) != 3 || got[0].ID() != "golem15.hello" || got[1].ID() != "golem15.greeter" || got[2].ID() != "golem15.extra" {
		t.Fatalf("order = %v, want hello, greeter, extra", idsOf(got))
	}
	want := []string{
		"golem15.hello:register",
		"golem15.greeter:register",
		"golem15.extra:register",
		"golem15.hello:boot",
		"golem15.greeter:boot",
		"golem15.extra:boot",
	}
	if strings.Join(log, ",") != strings.Join(want, ",") {
		t.Fatalf("lifecycle = %v, want %v", log, want)
	}
}

func TestActivateDuplicateManifestIDRejected(t *testing.T) {
	var log []string
	p := &tracePlugin{id: "golem15.hello", log: &log}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{p}, app, []string{"golem15.hello", "golem15.hello"})
	if err == nil {
		t.Fatal("expected duplicate manifest id error")
	}
	if !strings.Contains(err.Error(), "golem15.hello") {
		t.Fatalf("error %q should name the duplicate id", err)
	}
	if len(log) != 0 {
		t.Fatalf("lifecycle ran despite duplicate manifest: %v", log)
	}
}

func TestActivateUnregisteredPluginNamesID(t *testing.T) {
	app := backpack.New(&compass.Config{})
	_, err := activate(nil, app, []string{"golem15.missing"})
	if err == nil {
		t.Fatal("expected missing registered plugin error")
	}
	if !strings.Contains(err.Error(), "golem15.missing") {
		t.Fatalf("error %q should name the missing id", err)
	}
}

func TestActivateEmptyManifestIDRejected(t *testing.T) {
	var log []string
	p := &tracePlugin{id: "golem15.hello", log: &log}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{p}, app, []string{""})
	if err == nil {
		t.Fatal("expected empty plugin id error")
	}
}

func TestActivateNilAppRejected(t *testing.T) {
	_, err := Activate(nil, []string{"golem15.hello"})
	if err == nil {
		t.Fatal("expected nil app error")
	}
}

func TestActivatePublishesPlugins(t *testing.T) {
	var log []string
	a := &tracePlugin{id: "golem15.a", log: &log}
	b := &tracePlugin{id: "golem15.b", req: []string{"golem15.a"}, log: &log}
	app := backpack.New(&compass.Config{})
	if _, err := activate([]Plugin{b, a}, app, []string{"golem15.b", "golem15.a"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	activated, ok := app.Lookup[Activated]()
	if !ok || activated == nil {
		t.Fatal("Activate did not publish Activated")
	}
	if len(activated) != 2 {
		t.Fatalf("Activated has %d plugins, want 2", len(activated))
	}
	if activated[0].ID() != "golem15.a" || activated[1].ID() != "golem15.b" {
		t.Fatalf("Activated order = %q, %q; want golem15.a then golem15.b", activated[0].ID(), activated[1].ID())
	}
}

func TestActivatePublishesActivatedOrderAndRefusesSecond(t *testing.T) {
	var log []string
	a := &tracePlugin{id: "golem15.a", log: &log}
	b := &tracePlugin{id: "golem15.b", req: []string{"golem15.a"}, log: &log}
	app := backpack.New(&compass.Config{})
	ordered, err := activate([]Plugin{b, a}, app, []string{"golem15.b", "golem15.a"})
	if err != nil {
		t.Fatalf("activate: %v", err)
	}
	if len(ordered) != 2 || ordered[0].ID() != "golem15.a" || ordered[1].ID() != "golem15.b" {
		t.Fatalf("activation order = %v", ordered)
	}
	activated, ok := app.Lookup[Activated]()
	if !ok || len(activated) != 2 || activated[0].ID() != "golem15.a" {
		t.Fatalf("Activated = %#v ok=%v", activated, ok)
	}
	if _, err := activate([]Plugin{b, a}, app, []string{"golem15.b", "golem15.a"}); err == nil {
		t.Fatal("second Activate on the same app must error")
	}
}

func TestRegisterNilIsNoop(t *testing.T) {
	Register(nil)
}

func TestActivateHasPluginFalseForUnselected(t *testing.T) {
	var log []string
	hello := &tracePlugin{id: "golem15.hello", log: &log}
	opt := &tracePlugin{id: "golem15.optional", log: &log}
	app := backpack.New(&compass.Config{})
	if _, err := activate([]Plugin{hello, opt}, app, []string{"golem15.hello"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	if !app.HasPlugin("golem15.hello") {
		t.Fatal("selected plugin must be present")
	}
	if app.HasPlugin("golem15.optional") {
		t.Fatal("unselected registered plugin must not appear in HasPlugin")
	}
}

type commandsPlugin struct {
	tracePlugin
}

func (p *commandsPlugin) Commands() []bonfire.Command {
	return []bonfire.Command{{
		Name:        "demo:run",
		Description: "demo command",
	}}
}

func TestActivateDiscoversHasConfigAndHasCommands(t *testing.T) {
	var log []string
	var got int
	cfgPlugin := &configPlugin{
		id:  "golem15.hello",
		got: &got,
		fsys: fstest.MapFS{
			"config/config.yaml": {Data: []byte("posts_per_page: 4\n")},
		},
	}
	cmdPlugin := &commandsPlugin{tracePlugin: tracePlugin{id: "golem15.demo", log: &log}}
	plain := &tracePlugin{id: "golem15.plain", log: &log}

	dir := t.TempDir()
	if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: app\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	cfg, err := compass.Load(dir)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	app := backpack.New(cfg)
	gotPlugins, err := activate([]Plugin{cfgPlugin, cmdPlugin, plain}, app, []string{"golem15.hello", "golem15.demo", "golem15.plain"})
	if err != nil {
		t.Fatalf("activate: %v", err)
	}
	if got != 4 {
		t.Fatalf("HasConfig value during Register = %d, want 4", got)
	}

	var sawConfig, sawCommands, sawPlainCommands bool
	for _, p := range gotPlugins {
		if _, ok := p.(pact.HasConfig); ok && p.ID() == "golem15.hello" {
			sawConfig = true
		}
		if hc, ok := p.(pact.HasCommands); ok {
			if p.ID() == "golem15.demo" {
				cmds := hc.Commands()
				if len(cmds) != 1 || cmds[0].Name != "demo:run" {
					t.Fatalf("HasCommands commands = %+v", cmds)
				}
				sawCommands = true
			}
			if p.ID() == "golem15.plain" {
				sawPlainCommands = true
			}
		}
	}
	if !sawConfig {
		t.Fatal("golem15.hello should satisfy HasConfig")
	}
	if !sawCommands {
		t.Fatal("golem15.demo should satisfy HasCommands")
	}
	if sawPlainCommands {
		t.Fatal("plain plugin must not satisfy HasCommands")
	}
	if _, ok := any(plain).(pact.HasConfig); ok {
		t.Fatal("plain plugin must not satisfy HasConfig")
	}
}

type langPlugin struct {
	id   string
	fsys fs.FS
	got  *string
}

func (p *langPlugin) ID() string                   { return p.id }
func (p *langPlugin) Requires() []string           { return nil }
func (p *langPlugin) Register(*backpack.App) error { return nil }
func (p *langPlugin) LangFS() fs.FS                { return p.fsys }

func (p *langPlugin) Boot(app *backpack.App) error {
	if p.got == nil {
		return nil
	}
	tr, ok := app.Lookup[*phrasebook.Translator]()
	if !ok {
		return fmt.Errorf("translator missing at boot")
	}
	*p.got = tr.GetIn("en", p.id+"::lang.greeting", nil)
	return nil
}

func TestActivatePublishesTranslatorBeforeBoot(t *testing.T) {
	var got string
	p := &langPlugin{
		id:  "golem15.hello",
		got: &got,
		fsys: fstest.MapFS{
			"lang/en/lang.yaml": {Data: []byte("greeting: Hello\n")},
		},
	}
	app := backpack.New(&compass.Config{})
	if _, err := activate([]Plugin{p}, app, []string{"golem15.hello"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	if got != "Hello" {
		t.Fatalf("boot lookup = %q, want Hello (translator must be published before Boot)", got)
	}
}

func TestActivateMalformedLangFailsWithPluginContext(t *testing.T) {
	p := &langPlugin{
		id: "golem15.hello",
		fsys: fstest.MapFS{
			"lang/en.yaml": {Data: []byte("greeting: Hello\n")},
		},
	}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{p}, app, []string{"golem15.hello"})
	if err == nil {
		t.Fatal("expected malformed catalog error")
	}
	msg := err.Error()
	if !strings.Contains(msg, "golem15.hello") || !strings.Contains(msg, "malformed path") {
		t.Fatalf("error %q should name the plugin and path problem", msg)
	}
}

func TestActivateMalformedLangLeafNamesFileAndKey(t *testing.T) {
	p := &langPlugin{
		id: "golem15.hello",
		fsys: fstest.MapFS{
			"lang/en/lang.yaml": {Data: []byte("labels:\n  count: 1\n")},
		},
	}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{p}, app, []string{"golem15.hello"})
	if err == nil {
		t.Fatal("expected non-string leaf error")
	}
	msg := err.Error()
	for _, want := range []string{"golem15.hello", "lang/en/lang.yaml", "labels.count", "non-string leaf"} {
		if !strings.Contains(msg, want) {
			t.Fatalf("error %q missing %s", msg, want)
		}
	}
}

type mailPlugin struct {
	id        string
	fsys      fs.FS
	templates []string
	layouts   map[string]string
	sawMailer *bool
}

func (p *mailPlugin) ID() string                     { return p.id }
func (p *mailPlugin) Requires() []string             { return nil }
func (p *mailPlugin) Register(*backpack.App) error   { return nil }
func (p *mailPlugin) MailTemplatesFS() fs.FS         { return p.fsys }
func (p *mailPlugin) MailTemplates() []string        { return p.templates }
func (p *mailPlugin) MailLayouts() map[string]string { return p.layouts }

func (p *mailPlugin) Boot(app *backpack.App) error {
	if p.sawMailer == nil {
		return nil
	}
	_, ok := app.Lookup[postcard.Mailer]()
	*p.sawMailer = ok
	return nil
}

func TestActivatePublishesMailerBeforeBoot(t *testing.T) {
	var saw bool
	p := &mailPlugin{
		id:        "golem15.hello",
		sawMailer: &saw,
		templates: []string{"golem15.hello::mail.hello"},
		layouts:   map[string]string{"hello": "golem15.hello::mail.layouts.hello"},
		fsys: fstest.MapFS{
			"views/mail/hello.htm":         {Data: []byte("subject = \"Hi\"\nlayout = \"hello\"\n==\nHi.\n")},
			"views/mail/layouts/hello.htm": {Data: []byte("name = \"Hello\"\n==\n{{ .Content }}\n==\n<div>{{ .Content }}</div>\n")},
		},
	}
	app := backpack.New(&compass.Config{})
	if _, err := activate([]Plugin{p}, app, []string{"golem15.hello"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	if !saw {
		t.Fatal("mailer must be published before Boot")
	}
}

func TestActivateMissingMailTemplateFailsBootWithName(t *testing.T) {
	p := &mailPlugin{
		id:        "golem15.hello",
		templates: []string{"golem15.hello::mail.hello"},
		fsys:      fstest.MapFS{},
	}
	app := backpack.New(&compass.Config{})
	_, err := activate([]Plugin{p}, app, []string{"golem15.hello"})
	if err == nil {
		t.Fatal("expected missing template error")
	}
	msg := err.Error()
	if !strings.Contains(msg, "party: boot golem15.hello") || !strings.Contains(msg, "golem15.hello::mail.hello") {
		t.Fatalf("error %q should name the boot plugin and missing template", msg)
	}
}

// menuTypesPlugin registers one menu item type and records whether the
// signpost registry was published at Register and at Boot.
type menuTypesPlugin struct {
	id          string
	key         string
	log         *[]string
	atRegister  *bool
	atBoot      *bool
	typesAtBoot *int
}

func (p *menuTypesPlugin) ID() string         { return p.id }
func (p *menuTypesPlugin) Requires() []string { return nil }

func (p *menuTypesPlugin) MenuItemTypes() []pact.MenuItemType {
	*p.log = append(*p.log, p.id+":types")
	return []pact.MenuItemType{{Key: p.key, DefaultPattern: "/:slug", Resolve: func(context.Context, pact.MenuItemResolve) (*pact.ResolvedMenuItem, error) {
		return &pact.ResolvedMenuItem{}, nil
	}}}
}

func (p *menuTypesPlugin) Register(app *backpack.App) error {
	*p.log = append(*p.log, p.id+":register")
	_, ok := app.Lookup[*signpost.Registry]()
	*p.atRegister = ok
	return nil
}

func (p *menuTypesPlugin) Boot(app *backpack.App) error {
	*p.log = append(*p.log, p.id+":boot")
	reg, ok := app.Lookup[*signpost.Registry]()
	*p.atBoot = ok
	if ok {
		*p.typesAtBoot = len(reg.Types())
	}
	return nil
}

// TestActivateMenuItemTypesOrder pins the party hook: menu item types are
// collected after every Register and before the first Boot, so a Boot sees
// the full registry; a duplicate key fails activation naming both plugins and
// no plugin boots.
func TestActivateMenuItemTypesOrder(t *testing.T) {
	var log []string
	var reg1, boot1, reg2, boot2 bool
	var n1, n2 int
	a := &menuTypesPlugin{id: "acme.a", key: "acme-a", log: &log, atRegister: &reg1, atBoot: &boot1, typesAtBoot: &n1}
	b := &menuTypesPlugin{id: "acme.b", key: "acme-b", log: &log, atRegister: &reg2, atBoot: &boot2, typesAtBoot: &n2}
	app := backpack.New(&compass.Config{})
	if _, err := activate([]Plugin{a, b}, app, []string{"acme.a", "acme.b"}); err != nil {
		t.Fatalf("activate: %v", err)
	}
	if reg1 || reg2 {
		t.Fatal("the registry existed during Register")
	}
	if !boot1 || !boot2 || n1 != 2 || n2 != 2 {
		t.Fatalf("Boot saw registry %v/%v with %d/%d types, want both and 2", boot1, boot2, n1, n2)
	}
	want := "acme.a:register,acme.b:register,acme.a:types,acme.b:types,acme.a:boot,acme.b:boot"
	if got := strings.Join(log, ","); got != want {
		t.Fatalf("order = %s\nwant    %s", got, want)
	}

	log = nil
	dupA := &menuTypesPlugin{id: "acme.a", key: "acme-same", log: &log, atRegister: &reg1, atBoot: &boot1, typesAtBoot: &n1}
	dupB := &menuTypesPlugin{id: "acme.b", key: "acme-same", log: &log, atRegister: &reg2, atBoot: &boot2, typesAtBoot: &n2}
	_, err := activate([]Plugin{dupA, dupB}, backpack.New(&compass.Config{}), []string{"acme.a", "acme.b"})
	if err == nil || !strings.Contains(err.Error(), "party: menu item types") || !strings.Contains(err.Error(), "acme.a") || !strings.Contains(err.Error(), "acme.b") {
		t.Fatalf("duplicate error = %v", err)
	}
	for _, entry := range log {
		if strings.HasSuffix(entry, ":boot") {
			t.Fatalf("a plugin booted after the duplicate: %v", log)
		}
	}
}