Merge pull request #124 from cristaloleg/use-one-name-for-receiver

*: use only one name for receiver

8 files changed, 54 insertions, 54 deletions

diff --git a/plumbing/object/commit.go b/plumbing/object/commit.go
index 113cb29..98664a1 100644
--- a/plumbing/object/commit.go
+++ b/plumbing/object/commit.go
@@ -243,16 +243,16 @@ func (c *Commit) Decode(o plumbing.EncodedObject) (err error) {
 }
 
 // Encode transforms a Commit into a plumbing.EncodedObject.
-func (b *Commit) Encode(o plumbing.EncodedObject) error {
-	return b.encode(o, true)
+func (c *Commit) Encode(o plumbing.EncodedObject) error {
+	return c.encode(o, true)
 }
 
 // EncodeWithoutSignature export a Commit into a plumbing.EncodedObject without the signature (correspond to the payload of the PGP signature).
-func (b *Commit) EncodeWithoutSignature(o plumbing.EncodedObject) error {
-	return b.encode(o, false)
+func (c *Commit) EncodeWithoutSignature(o plumbing.EncodedObject) error {
+	return c.encode(o, false)
 }
 
-func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
+func (c *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 	o.SetType(plumbing.CommitObject)
 	w, err := o.Writer()
 	if err != nil {
@@ -261,11 +261,11 @@ func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 
 	defer ioutil.CheckClose(w, &err)
 
-	if _, err = fmt.Fprintf(w, "tree %s\n", b.TreeHash.String()); err != nil {
+	if _, err = fmt.Fprintf(w, "tree %s\n", c.TreeHash.String()); err != nil {
 		return err
 	}
 
-	for _, parent := range b.ParentHashes {
+	for _, parent := range c.ParentHashes {
 		if _, err = fmt.Fprintf(w, "parent %s\n", parent.String()); err != nil {
 			return err
 		}
@@ -275,7 +275,7 @@ func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 		return err
 	}
 
-	if err = b.Author.Encode(w); err != nil {
+	if err = c.Author.Encode(w); err != nil {
 		return err
 	}
 
@@ -283,11 +283,11 @@ func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 		return err
 	}
 
-	if err = b.Committer.Encode(w); err != nil {
+	if err = c.Committer.Encode(w); err != nil {
 		return err
 	}
 
-	if b.PGPSignature != "" && includeSig {
+	if c.PGPSignature != "" && includeSig {
 		if _, err = fmt.Fprint(w, "\n"+headerpgp+" "); err != nil {
 			return err
 		}
@@ -296,14 +296,14 @@ func (b *Commit) encode(o plumbing.EncodedObject, includeSig bool) (err error) {
 		// newline. Use join for this so it's clear that a newline should not be
 		// added after this section, as it will be added when the message is
 		// printed.
-		signature := strings.TrimSuffix(b.PGPSignature, "\n")
+		signature := strings.TrimSuffix(c.PGPSignature, "\n")
 		lines := strings.Split(signature, "\n")
 		if _, err = fmt.Fprint(w, strings.Join(lines, "\n ")); err != nil {
 			return err
 		}
 	}
 
-	if _, err = fmt.Fprintf(w, "\n\n%s", b.Message); err != nil {
+	if _, err = fmt.Fprintf(w, "\n\n%s", c.Message); err != nil {
 		return err
 	}
 
diff --git a/plumbing/object/patch.go b/plumbing/object/patch.go
index 1135a40..9b5f438 100644
--- a/plumbing/object/patch.go
+++ b/plumbing/object/patch.go
@@ -121,12 +121,12 @@ type Patch struct {
 	filePatches []fdiff.FilePatch
 }
 
-func (t *Patch) FilePatches() []fdiff.FilePatch {
-	return t.filePatches
+func (p *Patch) FilePatches() []fdiff.FilePatch {
+	return p.filePatches
 }
 
-func (t *Patch) Message() string {
-	return t.message
+func (p *Patch) Message() string {
+	return p.message
 }
 
 func (p *Patch) Encode(w io.Writer) error {
@@ -198,12 +198,12 @@ func (tf *textFilePatch) Files() (from fdiff.File, to fdiff.File) {
 	return
 }
 
-func (t *textFilePatch) IsBinary() bool {
-	return len(t.chunks) == 0
+func (tf *textFilePatch) IsBinary() bool {
+	return len(tf.chunks) == 0
 }
 
-func (t *textFilePatch) Chunks() []fdiff.Chunk {
-	return t.chunks
+func (tf *textFilePatch) Chunks() []fdiff.Chunk {
+	return tf.chunks
 }
 
 // textChunk is an implementation of fdiff.Chunk interface
diff --git a/plumbing/protocol/packp/ulreq.go b/plumbing/protocol/packp/ulreq.go
index 44db8e4..ddec06e 100644
--- a/plumbing/protocol/packp/ulreq.go
+++ b/plumbing/protocol/packp/ulreq.go
@@ -109,42 +109,42 @@ func NewUploadRequestFromCapabilities(adv *capability.List) *UploadRequest {
 //   - is a DepthReference is given capability.DeepenNot MUST be present
 //   - MUST contain only maximum of one of capability.Sideband and capability.Sideband64k
 //   - MUST contain only maximum of one of capability.MultiACK and capability.MultiACKDetailed
-func (r *UploadRequest) Validate() error {
-	if len(r.Wants) == 0 {
+func (req *UploadRequest) Validate() error {
+	if len(req.Wants) == 0 {
 		return fmt.Errorf("want can't be empty")
 	}
 
-	if err := r.validateRequiredCapabilities(); err != nil {
+	if err := req.validateRequiredCapabilities(); err != nil {
 		return err
 	}
 
-	if err := r.validateConflictCapabilities(); err != nil {
+	if err := req.validateConflictCapabilities(); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (r *UploadRequest) validateRequiredCapabilities() error {
+func (req *UploadRequest) validateRequiredCapabilities() error {
 	msg := "missing capability %s"
 
-	if len(r.Shallows) != 0 && !r.Capabilities.Supports(capability.Shallow) {
+	if len(req.Shallows) != 0 && !req.Capabilities.Supports(capability.Shallow) {
 		return fmt.Errorf(msg, capability.Shallow)
 	}
 
-	switch r.Depth.(type) {
+	switch req.Depth.(type) {
 	case DepthCommits:
-		if r.Depth != DepthCommits(0) {
-			if !r.Capabilities.Supports(capability.Shallow) {
+		if req.Depth != DepthCommits(0) {
+			if !req.Capabilities.Supports(capability.Shallow) {
 				return fmt.Errorf(msg, capability.Shallow)
 			}
 		}
 	case DepthSince:
-		if !r.Capabilities.Supports(capability.DeepenSince) {
+		if !req.Capabilities.Supports(capability.DeepenSince) {
 			return fmt.Errorf(msg, capability.DeepenSince)
 		}
 	case DepthReference:
-		if !r.Capabilities.Supports(capability.DeepenNot) {
+		if !req.Capabilities.Supports(capability.DeepenNot) {
 			return fmt.Errorf(msg, capability.DeepenNot)
 		}
 	}
@@ -152,15 +152,15 @@ func (r *UploadRequest) validateRequiredCapabilities() error {
 	return nil
 }
 
-func (r *UploadRequest) validateConflictCapabilities() error {
+func (req *UploadRequest) validateConflictCapabilities() error {
 	msg := "capabilities %s and %s are mutually exclusive"
-	if r.Capabilities.Supports(capability.Sideband) &&
-		r.Capabilities.Supports(capability.Sideband64k) {
+	if req.Capabilities.Supports(capability.Sideband) &&
+		req.Capabilities.Supports(capability.Sideband64k) {
 		return fmt.Errorf(msg, capability.Sideband, capability.Sideband64k)
 	}
 
-	if r.Capabilities.Supports(capability.MultiACK) &&
-		r.Capabilities.Supports(capability.MultiACKDetailed) {
+	if req.Capabilities.Supports(capability.MultiACK) &&
+		req.Capabilities.Supports(capability.MultiACKDetailed) {
 		return fmt.Errorf(msg, capability.MultiACK, capability.MultiACKDetailed)
 	}
 
diff --git a/plumbing/protocol/packp/ulreq_decode.go b/plumbing/protocol/packp/ulreq_decode.go
index 449b729..895a3bf 100644
--- a/plumbing/protocol/packp/ulreq_decode.go
+++ b/plumbing/protocol/packp/ulreq_decode.go
@@ -14,9 +14,9 @@ import (
 
 // Decode reads the next upload-request form its input and
 // stores it in the UploadRequest.
-func (u *UploadRequest) Decode(r io.Reader) error {
+func (req *UploadRequest) Decode(r io.Reader) error {
 	d := newUlReqDecoder(r)
-	return d.Decode(u)
+	return d.Decode(req)
 }
 
 type ulReqDecoder struct {
diff --git a/plumbing/protocol/packp/ulreq_encode.go b/plumbing/protocol/packp/ulreq_encode.go
index 4863076..c451e23 100644
--- a/plumbing/protocol/packp/ulreq_encode.go
+++ b/plumbing/protocol/packp/ulreq_encode.go
@@ -15,9 +15,9 @@ import (
 // All the payloads will end with a newline character.  Wants and
 // shallows are sorted alphabetically.  A depth of 0 means no depth
 // request is sent.
-func (u *UploadRequest) Encode(w io.Writer) error {
+func (req *UploadRequest) Encode(w io.Writer) error {
 	e := newUlReqEncoder(w)
-	return e.Encode(u)
+	return e.Encode(req)
 }
 
 type ulReqEncoder struct {
diff --git a/plumbing/protocol/packp/updreq.go b/plumbing/protocol/packp/updreq.go
index b63b023..4d927d8 100644
--- a/plumbing/protocol/packp/updreq.go
+++ b/plumbing/protocol/packp/updreq.go
@@ -68,12 +68,12 @@ func NewReferenceUpdateRequestFromCapabilities(adv *capability.List) *ReferenceU
 	return r
 }
 
-func (r *ReferenceUpdateRequest) validate() error {
-	if len(r.Commands) == 0 {
+func (req *ReferenceUpdateRequest) validate() error {
+	if len(req.Commands) == 0 {
 		return ErrEmptyCommands
 	}
 
-	for _, c := range r.Commands {
+	for _, c := range req.Commands {
 		if err := c.validate(); err != nil {
 			return err
 		}
diff --git a/plumbing/protocol/packp/updreq_encode.go b/plumbing/protocol/packp/updreq_encode.go
index 6a79653..2545e93 100644
--- a/plumbing/protocol/packp/updreq_encode.go
+++ b/plumbing/protocol/packp/updreq_encode.go
@@ -14,33 +14,33 @@ var (
 )
 
 // Encode writes the ReferenceUpdateRequest encoding to the stream.
-func (r *ReferenceUpdateRequest) Encode(w io.Writer) error {
-	if err := r.validate(); err != nil {
+func (req *ReferenceUpdateRequest) Encode(w io.Writer) error {
+	if err := req.validate(); err != nil {
 		return err
 	}
 
 	e := pktline.NewEncoder(w)
 
-	if err := r.encodeShallow(e, r.Shallow); err != nil {
+	if err := req.encodeShallow(e, req.Shallow); err != nil {
 		return err
 	}
 
-	if err := r.encodeCommands(e, r.Commands, r.Capabilities); err != nil {
+	if err := req.encodeCommands(e, req.Commands, req.Capabilities); err != nil {
 		return err
 	}
 
-	if r.Packfile != nil {
-		if _, err := io.Copy(w, r.Packfile); err != nil {
+	if req.Packfile != nil {
+		if _, err := io.Copy(w, req.Packfile); err != nil {
 			return err
 		}
 
-		return r.Packfile.Close()
+		return req.Packfile.Close()
 	}
 
 	return nil
 }
 
-func (r *ReferenceUpdateRequest) encodeShallow(e *pktline.Encoder,
+func (req *ReferenceUpdateRequest) encodeShallow(e *pktline.Encoder,
 	h *plumbing.Hash) error {
 
 	if h == nil {
@@ -51,7 +51,7 @@ func (r *ReferenceUpdateRequest) encodeShallow(e *pktline.Encoder,
 	return e.Encodef("%s%s", shallow, objId)
 }
 
-func (r *ReferenceUpdateRequest) encodeCommands(e *pktline.Encoder,
+func (req *ReferenceUpdateRequest) encodeCommands(e *pktline.Encoder,
 	cmds []*Command, cap *capability.List) error {
 
 	if err := e.Encodef("%s\x00%s",
diff --git a/storage/memory/storage.go b/storage/memory/storage.go
index fdf8fcf..a8e5669 100644
--- a/storage/memory/storage.go
+++ b/storage/memory/storage.go
@@ -195,10 +195,10 @@ func (o *ObjectStorage) DeleteOldObjectPackAndIndex(plumbing.Hash, time.Time) er
 
 var errNotSupported = fmt.Errorf("Not supported")
 
-func (s *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error) {
+func (o *ObjectStorage) LooseObjectTime(hash plumbing.Hash) (time.Time, error) {
 	return time.Time{}, errNotSupported
 }
-func (s *ObjectStorage) DeleteLooseObject(plumbing.Hash) error {
+func (o *ObjectStorage) DeleteLooseObject(plumbing.Hash) error {
 	return errNotSupported
 }