entity/dag: proper base operation for simplified implementation

- reduce boilerplace necessary to implement an operation
- consolidate what an operation is in the core, which in turn pave the way for a generic cache layer mechanism
- avoid the previously complex unmarshalling process
- support operation metadata from the core
- simplified testing

1 files changed, 8 insertions, 95 deletions

diff --git a/bug/op_set_metadata.go b/bug/op_set_metadata.go
index 28496fd8..962eaa6c 100644
--- a/bug/op_set_metadata.go
+++ b/bug/op_set_metadata.go
@@ -1,108 +1,21 @@
 package bug
 
 import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/pkg/errors"
-
 	"github.com/MichaelMure/git-bug/entity"
+	"github.com/MichaelMure/git-bug/entity/dag"
 	"github.com/MichaelMure/git-bug/identity"
-	"github.com/MichaelMure/git-bug/util/text"
 )
 
-var _ Operation = &SetMetadataOperation{}
-
-type SetMetadataOperation struct {
-	OpBase
-	Target      entity.Id         `json:"target"`
-	NewMetadata map[string]string `json:"new_metadata"`
-}
-
-func (op *SetMetadataOperation) Id() entity.Id {
-	return idOperation(op, &op.OpBase)
-}
-
-func (op *SetMetadataOperation) Apply(snapshot *Snapshot) {
-	for _, target := range snapshot.Operations {
-		if target.Id() == op.Target {
-			// Apply the metadata in an immutable way: if a metadata already
-			// exist, it's not possible to override it.
-			for key, value := range op.NewMetadata {
-				target.setExtraMetadataImmutable(key, value)
-			}
-			return
-		}
-	}
-}
-
-func (op *SetMetadataOperation) Validate() error {
-	if err := op.OpBase.Validate(op, SetMetadataOp); err != nil {
-		return err
-	}
-
-	if err := op.Target.Validate(); err != nil {
-		return errors.Wrap(err, "target invalid")
-	}
-
-	for key, val := range op.NewMetadata {
-		if !text.SafeOneLine(key) {
-			return fmt.Errorf("metadata key is unsafe")
-		}
-		if !text.Safe(val) {
-			return fmt.Errorf("metadata value is not fully printable")
-		}
-	}
-
-	return nil
-}
-
-// UnmarshalJSON is a two step JSON unmarshalling
-// This workaround is necessary to avoid the inner OpBase.MarshalJSON
-// overriding the outer op's MarshalJSON
-func (op *SetMetadataOperation) UnmarshalJSON(data []byte) error {
-	// Unmarshal OpBase and the op separately
-
-	base := OpBase{}
-	err := json.Unmarshal(data, &base)
-	if err != nil {
-		return err
-	}
-
-	aux := struct {
-		Target      entity.Id         `json:"target"`
-		NewMetadata map[string]string `json:"new_metadata"`
-	}{}
-
-	err = json.Unmarshal(data, &aux)
-	if err != nil {
-		return err
-	}
-
-	op.OpBase = base
-	op.Target = aux.Target
-	op.NewMetadata = aux.NewMetadata
-
-	return nil
-}
-
-// Sign post method for gqlgen
-func (op *SetMetadataOperation) IsAuthored() {}
-
-func NewSetMetadataOp(author identity.Interface, unixTime int64, target entity.Id, newMetadata map[string]string) *SetMetadataOperation {
-	return &SetMetadataOperation{
-		OpBase:      newOpBase(SetMetadataOp, author, unixTime),
-		Target:      target,
-		NewMetadata: newMetadata,
-	}
+func NewSetMetadataOp(author identity.Interface, unixTime int64, target entity.Id, newMetadata map[string]string) *dag.SetMetadataOperation[*Snapshot] {
+	return dag.NewSetMetadataOp[*Snapshot](SetMetadataOp, author, unixTime, target, newMetadata)
 }
 
 // Convenience function to apply the operation
-func SetMetadata(b Interface, author identity.Interface, unixTime int64, target entity.Id, newMetadata map[string]string) (*SetMetadataOperation, error) {
-	SetMetadataOp := NewSetMetadataOp(author, unixTime, target, newMetadata)
-	if err := SetMetadataOp.Validate(); err != nil {
+func SetMetadata(b Interface, author identity.Interface, unixTime int64, target entity.Id, newMetadata map[string]string) (*dag.SetMetadataOperation[*Snapshot], error) {
+	op := NewSetMetadataOp(author, unixTime, target, newMetadata)
+	if err := op.Validate(); err != nil {
 		return nil, err
 	}
-	b.Append(SetMetadataOp)
-	return SetMetadataOp, nil
+	b.Append(op)
+	return op, nil
 }