WIP 2bootstrap-rework-2

9 files changed, 45 insertions, 103 deletions

diff --git a/entities/identity/common.go b/entities/identity/common.go
index 88e30e338..749def636 100644
--- a/entities/identity/common.go
+++ b/entities/identity/common.go
@@ -3,6 +3,8 @@ package identity
 import (
 	"encoding/json"
 	"fmt"
+
+	bootstrap "github.com/MichaelMure/git-bug/entity/boostrap"
 )
 
 // Custom unmarshaling function to allow package user to delegate
@@ -10,7 +12,7 @@ import (
 // and a Bare.
 //
 // If the given message has a "id" field, it's considered being a proper Identity.
-func UnmarshalJSON(raw json.RawMessage) (Interface, error) {
+func UnmarshalJSON(raw json.RawMessage) (bootstrap.Identity, error) {
 	aux := &IdentityStub{}
 
 	// First try to decode and load as a normal Identity
diff --git a/entities/identity/identity.go b/entities/identity/identity.go
index 9effd1466..f71d0e4a8 100644
--- a/entities/identity/identity.go
+++ b/entities/identity/identity.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/pkg/errors"
 
+	"github.com/MichaelMure/git-bug/entity"
 	bootstrap "github.com/MichaelMure/git-bug/entity/boostrap"
 	"github.com/MichaelMure/git-bug/repository"
 	"github.com/MichaelMure/git-bug/util/lamport"
@@ -28,7 +29,7 @@ var ErrNoIdentitySet = errors.New("No identity is set.\n" +
 	"\"git bug user new\" or adopted with \"git bug user adopt\"")
 var ErrMultipleIdentitiesSet = errors.New("multiple user identities set")
 
-var _ Interface = &Identity{}
+var _ entity.Identity = &Identity{}
 var _ bootstrap.Entity = &Identity{}
 
 type Identity struct {
@@ -40,7 +41,7 @@ func NewIdentity(repo repository.RepoClock, name string, email string) (*Identit
 	return NewIdentityFull(repo, name, email, "", "", nil)
 }
 
-func NewIdentityFull(repo repository.RepoClock, name string, email string, login string, avatarUrl string, keys []*Key) (*Identity, error) {
+func NewIdentityFull(repo repository.RepoClock, name string, email string, login string, avatarUrl string, keys []bootstrap.Key) (*Identity, error) {
 	v, err := newVersion(repo, name, email, login, avatarUrl, keys)
 	if err != nil {
 		return nil, err
@@ -216,13 +217,13 @@ type Mutator struct {
 	Login     string
 	Email     string
 	AvatarUrl string
-	Keys      []*Key
+	Keys      []bootstrap.Key
 }
 
 // Mutate allow to create a new version of the Identity in one go
 func (i *Identity) Mutate(repo repository.RepoClock, f func(orig *Mutator)) error {
-	copyKeys := func(keys []*Key) []*Key {
-		result := make([]*Key, len(keys))
+	copyKeys := func(keys []bootstrap.Key) []bootstrap.Key {
+		result := make([]bootstrap.Key, len(keys))
 		for i, key := range keys {
 			result[i] = key.Clone()
 		}
@@ -466,15 +467,15 @@ func (i *Identity) AvatarUrl() string {
 }
 
 // Keys return the last version of the valid keys
-func (i *Identity) Keys() []*Key {
+func (i *Identity) Keys() []bootstrap.Key {
 	return i.lastVersion().keys
 }
 
 // SigningKey return the key that should be used to sign new messages. If no key is available, return nil.
-func (i *Identity) SigningKey(repo repository.RepoKeyring) (*Key, error) {
+func (i *Identity) SigningKey(repo repository.RepoKeyring) (bootstrap.Key, error) {
 	keys := i.Keys()
 	for _, key := range keys {
-		err := key.ensurePrivateKey(repo)
+		err := key.EnsurePrivateKey(repo)
 		if err == errNoPrivateKey {
 			continue
 		}
@@ -487,8 +488,8 @@ func (i *Identity) SigningKey(repo repository.RepoKeyring) (*Key, error) {
 }
 
 // ValidKeysAtTime return the set of keys valid at a given lamport time
-func (i *Identity) ValidKeysAtTime(clockName string, time lamport.Time) []*Key {
-	var result []*Key
+func (i *Identity) ValidKeysAtTime(clockName string, time lamport.Time) []bootstrap.Key {
+	var result []bootstrap.Key
 
 	var lastTime lamport.Time
 	for _, v := range i.versions {
diff --git a/entities/identity/identity_stub.go b/entities/identity/identity_stub.go
index 67a9db531..94208da10 100644
--- a/entities/identity/identity_stub.go
+++ b/entities/identity/identity_stub.go
@@ -9,7 +9,7 @@ import (
 	"github.com/MichaelMure/git-bug/util/timestamp"
 )
 
-var _ Interface = &IdentityStub{}
+var _ bootstrap.Identity = &IdentityStub{}
 
 // IdentityStub is an almost empty Identity, holding only the id.
 // When a normal Identity is serialized into JSON, only the id is serialized.
@@ -68,15 +68,15 @@ func (IdentityStub) AvatarUrl() string {
 	panic("identities needs to be properly loaded with identity.ReadLocal()")
 }
 
-func (IdentityStub) Keys() []*Key {
+func (IdentityStub) Keys() []bootstrap.Key {
 	panic("identities needs to be properly loaded with identity.ReadLocal()")
 }
 
-func (i *IdentityStub) SigningKey(repo repository.RepoKeyring) (*Key, error) {
+func (i *IdentityStub) SigningKey(repo repository.RepoKeyring) (bootstrap.Key, error) {
 	panic("identities needs to be properly loaded with identity.ReadLocal()")
 }
 
-func (IdentityStub) ValidKeysAtTime(_ string, _ lamport.Time) []*Key {
+func (IdentityStub) ValidKeysAtTime(_ string, _ lamport.Time) []bootstrap.Key {
 	panic("identities needs to be properly loaded with identity.ReadLocal()")
 }
 
diff --git a/entities/identity/identity_test.go b/entities/identity/identity_test.go
index e4ecfbe91..3da0c83e7 100644
--- a/entities/identity/identity_test.go
+++ b/entities/identity/identity_test.go
@@ -37,18 +37,18 @@ func TestIdentityCommitLoad(t *testing.T) {
 
 	// multiple versions
 
-	identity, err = NewIdentityFull(repo, "René Descartes", "rene.descartes@example.com", "", "", []*Key{generatePublicKey()})
+	identity, err = NewIdentityFull(repo, "René Descartes", "rene.descartes@example.com", "", "", []bootstrap.Key{generatePublicKey()})
 	require.NoError(t, err)
 
 	idBeforeCommit = identity.Id()
 
 	err = identity.Mutate(repo, func(orig *Mutator) {
-		orig.Keys = []*Key{generatePublicKey()}
+		orig.Keys = []bootstrap.Key{generatePublicKey()}
 	})
 	require.NoError(t, err)
 
 	err = identity.Mutate(repo, func(orig *Mutator) {
-		orig.Keys = []*Key{generatePublicKey()}
+		orig.Keys = []bootstrap.Key{generatePublicKey()}
 	})
 	require.NoError(t, err)
 
@@ -71,13 +71,13 @@ func TestIdentityCommitLoad(t *testing.T) {
 
 	err = identity.Mutate(repo, func(orig *Mutator) {
 		orig.Email = "rene@descartes.com"
-		orig.Keys = []*Key{generatePublicKey()}
+		orig.Keys = []bootstrap.Key{generatePublicKey()}
 	})
 	require.NoError(t, err)
 
 	err = identity.Mutate(repo, func(orig *Mutator) {
 		orig.Email = "rene@descartes.com"
-		orig.Keys = []*Key{generatePublicKey(), generatePublicKey()}
+		orig.Keys = []bootstrap.Key{generatePublicKey(), generatePublicKey()}
 	})
 	require.NoError(t, err)
 
@@ -134,35 +134,35 @@ func TestIdentity_ValidKeysAtTime(t *testing.T) {
 		versions: []*version{
 			{
 				times: map[string]lamport.Time{"foo": 100},
-				keys:  []*Key{pubKeyA},
+				keys:  []bootstrap.Key{pubKeyA},
 			},
 			{
 				times: map[string]lamport.Time{"foo": 200},
-				keys:  []*Key{pubKeyB},
+				keys:  []bootstrap.Key{pubKeyB},
 			},
 			{
 				times: map[string]lamport.Time{"foo": 201},
-				keys:  []*Key{pubKeyC},
+				keys:  []bootstrap.Key{pubKeyC},
 			},
 			{
 				times: map[string]lamport.Time{"foo": 201},
-				keys:  []*Key{pubKeyD},
+				keys:  []bootstrap.Key{pubKeyD},
 			},
 			{
 				times: map[string]lamport.Time{"foo": 300},
-				keys:  []*Key{pubKeyE},
+				keys:  []bootstrap.Key{pubKeyE},
 			},
 		},
 	}
 
 	require.Nil(t, identity.ValidKeysAtTime("foo", 10))
-	require.Equal(t, identity.ValidKeysAtTime("foo", 100), []*Key{pubKeyA})
-	require.Equal(t, identity.ValidKeysAtTime("foo", 140), []*Key{pubKeyA})
-	require.Equal(t, identity.ValidKeysAtTime("foo", 200), []*Key{pubKeyB})
-	require.Equal(t, identity.ValidKeysAtTime("foo", 201), []*Key{pubKeyD})
-	require.Equal(t, identity.ValidKeysAtTime("foo", 202), []*Key{pubKeyD})
-	require.Equal(t, identity.ValidKeysAtTime("foo", 300), []*Key{pubKeyE})
-	require.Equal(t, identity.ValidKeysAtTime("foo", 3000), []*Key{pubKeyE})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 100), []bootstrap.Key{pubKeyA})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 140), []bootstrap.Key{pubKeyA})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 200), []bootstrap.Key{pubKeyB})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 201), []bootstrap.Key{pubKeyD})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 202), []bootstrap.Key{pubKeyD})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 300), []bootstrap.Key{pubKeyE})
+	require.Equal(t, identity.ValidKeysAtTime("foo", 3000), []bootstrap.Key{pubKeyE})
 }
 
 // Test the immutable or mutable metadata search
@@ -235,7 +235,7 @@ func TestJSON(t *testing.T) {
 	require.NoError(t, err)
 
 	// deserialize, got a IdentityStub with the same id
-	var i Interface
+	var i bootstrap.Identity
 	i, err = UnmarshalJSON(data)
 	require.NoError(t, err)
 	require.Equal(t, identity.Id(), i.Id())
diff --git a/entities/identity/interface.go b/entities/identity/interface.go
deleted file mode 100644
index 88234341b..000000000
--- a/entities/identity/interface.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package identity
-
-import (
-	bootstrap "github.com/MichaelMure/git-bug/entity/boostrap"
-	"github.com/MichaelMure/git-bug/repository"
-	"github.com/MichaelMure/git-bug/util/lamport"
-	"github.com/MichaelMure/git-bug/util/timestamp"
-)
-
-type Interface interface {
-	bootstrap.Entity
-
-	// Name return the last version of the name
-	// Can be empty.
-	Name() string
-
-	// DisplayName return a non-empty string to display, representing the
-	// identity, based on the non-empty values.
-	DisplayName() string
-
-	// Email return the last version of the email
-	// Can be empty.
-	Email() string
-
-	// Login return the last version of the login
-	// Can be empty.
-	// Warning: this login can be defined when importing from a bridge but should *not* be
-	// used to identify an identity as multiple bridge with different login can map to the same
-	// identity. Use the metadata system for that usage instead.
-	Login() string
-
-	// AvatarUrl return the last version of the Avatar URL
-	// Can be empty.
-	AvatarUrl() string
-
-	// Keys return the last version of the valid keys
-	// Can be empty.
-	Keys() []*Key
-
-	// SigningKey return the key that should be used to sign new messages. If no key is available, return nil.
-	SigningKey(repo repository.RepoKeyring) (*Key, error)
-
-	// ValidKeysAtTime return the set of keys valid at a given lamport time for a given clock of another entity
-	// Can be empty.
-	ValidKeysAtTime(clockName string, time lamport.Time) []*Key
-
-	// LastModification return the timestamp at which the last version of the identity became valid.
-	LastModification() timestamp.Timestamp
-
-	// LastModificationLamports return the lamport times at which the last version of the identity became valid.
-	LastModificationLamports() map[string]lamport.Time
-
-	// IsProtected return true if the chain of git commits started to be signed.
-	// If that's the case, only signed commit with a valid key for this identity can be added.
-	IsProtected() bool
-
-	// Validate check if the Identity data is valid
-	Validate() error
-
-	// NeedCommit indicate that the in-memory state changed and need to be committed in the repository
-	NeedCommit() bool
-}
diff --git a/entities/identity/key.go b/entities/identity/key.go
index 87271dd56..b9bcc8c3a 100644
--- a/entities/identity/key.go
+++ b/entities/identity/key.go
@@ -13,6 +13,7 @@ import (
 	"github.com/ProtonMail/go-crypto/openpgp/packet"
 	"github.com/pkg/errors"
 
+	bootstrap "github.com/MichaelMure/git-bug/entity/boostrap"
 	"github.com/MichaelMure/git-bug/repository"
 )
 
@@ -75,7 +76,7 @@ func (k *Key) Validate() error {
 	return nil
 }
 
-func (k *Key) Clone() *Key {
+func (k *Key) Clone() bootstrap.Key {
 	clone := &Key{}
 
 	pub := *k.public
@@ -185,9 +186,9 @@ func (k *Key) loadPrivate(repo repository.RepoKeyring) error {
 	return nil
 }
 
-// ensurePrivateKey attempt to load the corresponding private key if it is not loaded already.
+// EnsurePrivateKey attempt to load the corresponding private key if it is not loaded already.
 // If no private key is found, returns errNoPrivateKey
-func (k *Key) ensurePrivateKey(repo repository.RepoKeyring) error {
+func (k *Key) EnsurePrivateKey(repo repository.RepoKeyring) error {
 	if k.private != nil {
 		return nil
 	}
diff --git a/entities/identity/key_test.go b/entities/identity/key_test.go
index 6e320dc20..88301a1e9 100644
--- a/entities/identity/key_test.go
+++ b/entities/identity/key_test.go
@@ -43,7 +43,7 @@ func TestStoreLoad(t *testing.T) {
 	err = json.Unmarshal(dataJSON, &read)
 	require.NoError(t, err)
 
-	err = read.ensurePrivateKey(repo)
+	err = read.EnsurePrivateKey(repo)
 	require.NoError(t, err)
 
 	require.Equal(t, k.public, read.public)
diff --git a/entities/identity/version.go b/entities/identity/version.go
index 2e30ead73..3f0a22d92 100644
--- a/entities/identity/version.go
+++ b/entities/identity/version.go
@@ -33,7 +33,7 @@ type version struct {
 	// The set of keys valid at that time, from this version onward, until they get removed
 	// in a new version. This allows to have multiple key for the same identity (e.g. one per
 	// device) as well as revoke key.
-	keys []*Key
+	keys []bootstrap.Key
 
 	// mandatory random bytes to ensure a better randomness of the data of the first
 	// version of an identity, used to later generate the ID
@@ -51,7 +51,7 @@ type version struct {
 	commitHash repository.Hash
 }
 
-func newVersion(repo repository.RepoClock, name string, email string, login string, avatarURL string, keys []*Key) (*version, error) {
+func newVersion(repo repository.RepoClock, name string, email string, login string, avatarURL string, keys []bootstrap.Key) (*version, error) {
 	clocks, err := repo.AllClocks()
 	if err != nil {
 		return nil, err
@@ -123,7 +123,7 @@ func (v *version) Clone() *version {
 		clone.times[name] = t
 	}
 
-	clone.keys = make([]*Key, len(v.keys))
+	clone.keys = make([]bootstrap.Key, len(v.keys))
 	for i, key := range v.keys {
 		clone.keys[i] = key.Clone()
 	}
diff --git a/entities/identity/version_test.go b/entities/identity/version_test.go
index 2ad43f3d4..3b45ba21f 100644
--- a/entities/identity/version_test.go
+++ b/entities/identity/version_test.go
@@ -32,7 +32,7 @@ func makeIdentityTestRepo(t *testing.T) repository.ClockedRepo {
 func TestVersionJSON(t *testing.T) {
 	repo := makeIdentityTestRepo(t)
 
-	keys := []*Key{
+	keys := []bootstrap.Key{
 		generatePublicKey(),
 		generatePublicKey(),
 	}