code review 5639057: compress/gzip: NewWriter no longer returns an error.

src/pkg/compress/gzip/gunzip.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package gzip implements reading and writing of gzip format compressed files,
 // as specified in RFC 1952.
 package gzip
 
 import (
         "bufio"
         "compress/flate"
         "errors"
         "hash"
         "hash/crc32"
         "io"
         "time"
 )
 
-// BUG(nigeltao): Comments and Names don't properly map UTF-8 character codes outside of
-// the 0x00-0x7f range to ISO 8859-1 (Latin-1).
-
 const (
         gzipID1     = 0x1f
         gzipID2     = 0x8b
         gzipDeflate = 8
         flagText    = 1 << 0
         flagHdrCrc  = 1 << 1
         flagExtra   = 1 << 2
         flagName    = 1 << 3
         flagComment = 1 << 4
 )
 
 func makeReader(r io.Reader) flate.Reader {
         if rr, ok := r.(flate.Reader); ok {
                 return rr
         }
         return bufio.NewReader(r)
 }
 
 var ErrHeader = errors.New("invalid gzip header")
 var ErrChecksum = errors.New("gzip checksum error")
 
 // The gzip file stores a header giving metadata about the compressed file.
-// That header is exposed as the fields of the Compressor and Decompressor structs.
+// That header is exposed as the fields of the Writer and Reader structs.
 type Header struct {
         Comment string    // comment
         Extra   []byte    // "extra data"
         ModTime time.Time // modification time
         Name    string    // file name
         OS      byte      // operating system type
 }
 
-// An Decompressor is an io.Reader that can be read to retrieve
+// A Reader is an io.Reader that can be read to retrieve
 // uncompressed data from a gzip-format compressed file.
 //
 // In general, a gzip file can be a concatenation of gzip files,
-// each with its own header.  Reads from the Decompressor
+// each with its own header.  Reads from the Reader
 // return the concatenation of the uncompressed data of each.
-// Only the first header is recorded in the Decompressor fields.
+// Only the first header is recorded in the Reader fields.
 //
 // Gzip files store a length and checksum of the uncompressed data.
-// The Decompressor will return a ErrChecksum when Read
+// The Reader will return a ErrChecksum when Read
 // reaches the end of the uncompressed data if it does not
 // have the expected length or checksum.  Clients should treat data
-// returned by Read as tentative until they receive the successful
-// (zero length, nil error) Read marking the end of the data.
-type Decompressor struct {
+// returned by Read as tentative until they receive the io.EOF
+// marking the end of the data.
+type Reader struct {
         Header
         r            flate.Reader
         decompressor io.ReadCloser
         digest       hash.Hash32
         size         uint32
         flg          byte
         buf          [512]byte
         err          error
 }
 
-// NewReader creates a new Decompressor reading the given reader.
+// NewReader creates a new Reader reading the given reader.
 // The implementation buffers input and may read more data than necessary from r.
-// It is the caller's responsibility to call Close on the Decompressor when done.
-func NewReader(r io.Reader) (*Decompressor, error) {
-        z := new(Decompressor)
+// It is the caller's responsibility to call Close on the Reader when done.
+func NewReader(r io.Reader) (*Reader, error) {
+        z := new(Reader)
         z.r = makeReader(r)
         z.digest = crc32.NewIEEE()
         if err := z.readHeader(true); err != nil {
                 return nil, err
         }
         return z, nil
 }
 
 // GZIP (RFC 1952) is little-endian, unlike ZLIB (RFC 1950).
 func get4(p []byte) uint32 {
         return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
 }
 
-func (z *Decompressor) readString() (string, error) {
+func (z *Reader) readString() (string, error) {
         var err error
         needconv := false
         for i := 0; ; i++ {
                 if i >= len(z.buf) {
                         return "", ErrHeader
                 }
                 z.buf[i], err = z.r.ReadByte()
                 if err != nil {
                         return "", err
                 }
                 if z.buf[i] > 0x7f {
                         needconv = true
                 }
                 if z.buf[i] == 0 {
                         // GZIP (RFC 1952) specifies that strings are NUL-terminated ISO 8859-1 (Latin-1).
                         if needconv {
                                 s := make([]rune, 0, i)
                                 for _, v := range z.buf[0:i] {
                                         s = append(s, rune(v))
                                 }
                                 return string(s), nil
                         }
                         return string(z.buf[0:i]), nil
                 }
         }
         panic("not reached")
 }
 
-func (z *Decompressor) read2() (uint32, error) {
+func (z *Reader) read2() (uint32, error) {
         _, err := io.ReadFull(z.r, z.buf[0:2])
         if err != nil {
                 return 0, err
         }
         return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil
 }
 
-func (z *Decompressor) readHeader(save bool) error {
+func (z *Reader) readHeader(save bool) error {
         _, err := io.ReadFull(z.r, z.buf[0:10])
         if err != nil {
                 return err
         }
         if z.buf[0] != gzipID1 || z.buf[1] != gzipID2 || z.buf[2] != gzipDeflate {
                 return ErrHeader
         }
         z.flg = z.buf[3]
         if save {
                 z.ModTime = time.Unix(int64(get4(z.buf[4:8])), 0)
@@ skipping 45 matching lines @@
                 if n != sum {
                         return ErrHeader
                 }
         }
 
         z.digest.Reset()
         z.decompressor = flate.NewReader(z.r)
         return nil
 }
 
-func (z *Decompressor) Read(p []byte) (n int, err error) {
+func (z *Reader) Read(p []byte) (n int, err error) {
         if z.err != nil {
                 return 0, z.err
         }
         if len(p) == 0 {
                 return 0, nil
         }
 
         n, err = z.decompressor.Read(p)
         z.digest.Write(p[0:n])
         z.size += uint32(n)
@@ skipping 19 matching lines @@
                 z.err = err
                 return
         }
 
         // Yes.  Reset and read from it.
         z.digest.Reset()
         z.size = 0
         return z.Read(p)
 }
 
-// Calling Close does not close the wrapped io.Reader originally passed to NewReader.
-func (z *Decompressor) Close() error { return z.decompressor.Close() }
+// Close closes the Reader. It does not close the underlying io.Reader.
+func (z *Reader) Close() error { return z.decompressor.Close() }