golint fixes

encoder.go

@@ -116,7 +116,7 @@ type dataEncoder struct {
 
 // newDataEncoder constructs a dataEncoder.
 func newDataEncoder(t dataEncoderType) *dataEncoder {
-	var d *dataEncoder = &dataEncoder{}
+	d := &dataEncoder{}
 
 	switch t {
 	case dataEncoderType1To9:
@@ -168,7 +168,7 @@ func (d *dataEncoder) encode(data []byte) (*bitset.Bitset, error) {
 	d.optimised = nil
 
 	if len(data) == 0 {
-		return nil, errors.New("No data to encode")
+		return nil, errors.New("no data to encode")
 	}
 
 	// Classify data into unoptimised segments.
@@ -181,7 +181,7 @@ func (d *dataEncoder) encode(data []byte) (*bitset.Bitset, error) {
 	}
 
 	// Encode data.
-	var encoded *bitset.Bitset = bitset.New()
+	encoded := bitset.New()
 	for _, s := range d.optimised {
 		d.encodeDataRaw(s.data, s.dataMode, encoded)
 	}
@@ -193,8 +193,8 @@ func (d *dataEncoder) encode(data []byte) (*bitset.Bitset, error) {
 // e.g. "123ZZ#!#!" =>
 // [numeric, 3, "123"] [alphanumeric, 2, "ZZ"] [byte, 4, "#!#!"].
 func (d *dataEncoder) classifyDataModes() {
-	var start int = 0
-	var mode dataMode = dataModeNone
+	var start int
+	mode := dataModeNone
 
 	for i, v := range d.data {
 		newMode := dataModeNone
@@ -271,7 +271,7 @@ func (d *dataEncoder) optimiseDataModes() error {
 			}
 		}
 
-		var optimised segment = segment{dataMode: mode,
+		optimised := segment{dataMode: mode,
 			data: make([]byte, 0, numChars)}
 
 		for k := i; k < j; k++ {
@@ -289,8 +289,8 @@ func (d *dataEncoder) optimiseDataModes() error {
 // encodeDataRaw encodes data in dataMode. The encoded data is appended to
 // encoded.
 func (d *dataEncoder) encodeDataRaw(data []byte, dataMode dataMode, encoded *bitset.Bitset) {
-	var modeIndicator *bitset.Bitset = d.modeIndicator(dataMode)
-	var charCountBits int = d.charCountBits(dataMode)
+	modeIndicator := d.modeIndicator(dataMode)
+	charCountBits := d.charCountBits(dataMode)
 
 	// Append mode indicator.
 	encoded.Append(modeIndicator)
@@ -304,8 +304,9 @@ func (d *dataEncoder) encodeDataRaw(data []byte, dataMode dataMode, encoded *bit
 		for i := 0; i < len(data); i += 3 {
 			charsRemaining := len(data) - i
 
-			var value uint32 = 0
-			var bitsUsed int = 1
+			var value uint32
+			bitsUsed := 1
+
 			for j := 0; j < charsRemaining && j < 3; j++ {
 				value *= 10
 				value += uint32(data[i+j] - 0x30)
@@ -317,13 +318,13 @@ func (d *dataEncoder) encodeDataRaw(data []byte, dataMode dataMode, encoded *bit
 		for i := 0; i < len(data); i += 2 {
 			charsRemaining := len(data) - i
 
-			var value uint32 = 0
+			var value uint32
 			for j := 0; j < charsRemaining && j < 2; j++ {
 				value *= 45
 				value += encodeAlphanumericCharacter(data[i+j])
 			}
 
-			var bitsUsed int = 6
+			bitsUsed := 6
 			if charsRemaining > 1 {
 				bitsUsed = 11
 			}
@@ -382,20 +383,20 @@ func (d *dataEncoder) charCountBits(dataMode dataMode) int {
 // An error is returned if the mode is not supported, or the length requested is
 // too long to be represented.
 func (d *dataEncoder) encodedLength(dataMode dataMode, n int) (int, error) {
-	var modeIndicator *bitset.Bitset = d.modeIndicator(dataMode)
-	var charCountBits int = d.charCountBits(dataMode)
+	modeIndicator := d.modeIndicator(dataMode)
+	charCountBits := d.charCountBits(dataMode)
 
 	if modeIndicator == nil {
-		return 0, errors.New("Mode not supported")
+		return 0, errors.New("mode not supported")
 	}
 
 	maxLength := (1 << uint8(charCountBits)) - 1
 
 	if n > maxLength {
-		return 0, errors.New("Length too long to be represented")
+		return 0, errors.New("length too long to be represented")
 	}
 
-	var length int = modeIndicator.Len() + charCountBits
+	length := modeIndicator.Len() + charCountBits
 
 	switch dataMode {
 	case dataModeNumeric:

encoder_test.go

@@ -70,7 +70,7 @@ func TestByteModeLengthCalculations(t *testing.T) {
 	}{}
 
 	for i, test := range tests {
-		var encoder *dataEncoder = newDataEncoder(test.dataEncoderType)
+		encoder := newDataEncoder(test.dataEncoderType)
 		var resultLength int
 
 		resultLength, err := encoder.encodedLength(test.dataMode, test.numSymbols)
@@ -126,9 +126,9 @@ func TestSingleModeEncodings(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		var encoder *dataEncoder = newDataEncoder(test.dataEncoderType)
+		encoder := newDataEncoder(test.dataEncoderType)
+		encoded := bitset.New()
 
-		var encoded *bitset.Bitset = bitset.New()
 		encoder.encodeDataRaw([]byte(test.data), test.dataMode, encoded)
 
 		if !test.expected.Equals(encoded) {
@@ -244,9 +244,9 @@ func TestOptimiseEncoding(t *testing.T) {
 			numTotalChars += v.numChars
 		}
 
-		var data []byte = make([]byte, numTotalChars)
+		data := make([]byte, numTotalChars)
 
-		var i int = 0
+		i := 0
 		for _, v := range test.actual {
 			for j := 0; j < v.numChars; j++ {
 				switch v.dataMode {
@@ -264,14 +264,14 @@ func TestOptimiseEncoding(t *testing.T) {
 			}
 		}
 
-		var encoder *dataEncoder = newDataEncoder(test.dataEncoderType)
+		encoder := newDataEncoder(test.dataEncoderType)
 
 		_, err := encoder.encode(data)
 
 		if err != nil {
 			t.Errorf("Got %s, expected valid encoding", err.Error())
 		} else {
-			var ok bool = true
+			ok := true
 
 			if len(encoder.optimised) != len(test.optimised) {
 				ok = false
@@ -294,7 +294,8 @@ func TestOptimiseEncoding(t *testing.T) {
 }
 
 func testModeSegmentsString(segments []testModeSegment) string {
-	var result string = "["
+	result := "["
+
 	for i, segment := range segments {
 		if i > 0 {
 			result += ", "
@@ -310,7 +311,8 @@ func testModeSegmentsString(segments []testModeSegment) string {
 }
 
 func segmentsString(segments []segment) string {
-	var result string = "["
+	result := "["
+
 	for i, segment := range segments {
 		if i > 0 {
 			result += ", "

qrcode.go

@@ -137,10 +137,10 @@ func New(content string, level RecoveryLevel) (*QRCode, error) {
 	if err != nil {
 		return nil, err
 	} else if chosenVersion == nil {
-		return nil, errors.New("Content too long to encode")
+		return nil, errors.New("content too long to encode")
 	}
 
-	var q *QRCode = &QRCode{
+	q := &QRCode{
 		Content: content,
 
 		Level:         level,
@@ -180,13 +180,13 @@ func newWithForcedVersion(content string, version int, level RecoveryLevel) (*QR
 		return nil, err
 	}
 
-	var chosenVersion *qrCodeVersion = getQRCodeVersion(level, version)
+	chosenVersion := getQRCodeVersion(level, version)
 
 	if chosenVersion == nil {
-		return nil, errors.New("Cannot find QR Code version")
+		return nil, errors.New("cannot find QR Code version")
 	}
 
-	var q *QRCode = &QRCode{
+	q := &QRCode{
 		Content: content,
 
 		Level:         level,
@@ -234,9 +234,8 @@ func (q *QRCode) Image(size int) image.Image {
 	// Center the symbol within the image.
 	offset := (size - realSize*pixelsPerModule) / 2
 
-	var rect image.Rectangle = image.Rectangle{Min: image.Point{0, 0}, Max: image.Point{size, size}}
-
-	var img *image.RGBA = image.NewRGBA(rect)
+	rect := image.Rectangle{Min: image.Point{0, 0}, Max: image.Point{size, size}}
+	img := image.NewRGBA(rect)
 
 	for i := 0; i < size; i++ {
 		for j := 0; j < size; j++ {
@@ -244,7 +243,7 @@ func (q *QRCode) Image(size int) image.Image {
 		}
 	}
 
-	var bitmap [][]bool = q.symbol.bitmap()
+	bitmap := q.symbol.bitmap()
 	for y, row := range bitmap {
 		for x, v := range row {
 			if v {
@@ -267,7 +266,7 @@ func (q *QRCode) Image(size int) image.Image {
 // size is both the image width and height in pixels. If size is too small then
 // a larger image is silently returned.
 func (q *QRCode) PNG(size int) ([]byte, error) {
-	var img image.Image = q.Image(size)
+	img := q.Image(size)
 
 	var b bytes.Buffer
 	err := png.Encode(&b, img)
@@ -302,10 +301,10 @@ func (q *QRCode) encode(numTerminatorBits int) {
 	q.addTerminatorBits(numTerminatorBits)
 	q.addPadding()
 
-	var encoded *bitset.Bitset = q.encodeBlocks()
+	encoded := q.encodeBlocks()
 
-	var numMasks int = 8
-	var penalty int = 0
+	const numMasks int = 8
+	penalty := 0
 
 	for mask := 0; mask < numMasks; mask++ {
 		var s *symbol
@@ -317,7 +316,7 @@ func (q *QRCode) encode(numTerminatorBits int) {
 			log.Panic(err.Error())
 		}
 
-		var p int = s.penaltyScore()
+		p := s.penaltyScore()
 
 		//log.Printf("mask=%d p=%3d p1=%3d p2=%3d p3=%3d p4=%d\n", mask, p, s.penalty1(), s.penalty2(), s.penalty3(), s.penalty4())
 
@@ -351,18 +350,19 @@ func (q *QRCode) encodeBlocks() *bitset.Bitset {
 		ecStartOffset int
 	}
 
-	var block []dataBlock = make([]dataBlock, q.version.numBlocks())
+	block := make([]dataBlock, q.version.numBlocks())
+
+	start := 0
+	end := 0
+	blockID := 0
 
-	var start int = 0
-	var end int = 0
-	var blockID int = 0
 	for _, b := range q.version.block {
 		for j := 0; j < b.numBlocks; j++ {
 			start = end
 			end = start + b.numDataCodewords*8
 
 			// Apply error correction to each block.
-			var numErrorCodewords int = b.numCodewords - b.numDataCodewords
+			numErrorCodewords := b.numCodewords - b.numDataCodewords
 			block[blockID].data = reedsolomon.Encode(q.data.Substr(start, end), numErrorCodewords)
 			block[blockID].ecStartOffset = end - start
 
@@ -380,7 +380,7 @@ func (q *QRCode) encodeBlocks() *bitset.Bitset {
 	result := bitset.New()
 
 	// Combine data blocks.
-	var working bool = true
+	working := true
 	for i := 0; working; i += 8 {
 		working = false
 
@@ -401,7 +401,7 @@ func (q *QRCode) encodeBlocks() *bitset.Bitset {
 		working = false
 
 		for j, b := range block {
-			var offset int = i + block[j].ecStartOffset
+			offset := i + block[j].ecStartOffset
 			if offset >= block[j].data.Len() {
 				continue
 			}
@@ -422,9 +422,9 @@ func (q *QRCode) encodeBlocks() *bitset.Bitset {
 func max(a int, b int) int {
 	if a > b {
 		return a
-	} else {
-		return b
 	}
+
+	return b
 }
 
 // addPadding pads the encoded data upto the full length required.
@@ -439,7 +439,7 @@ func (q *QRCode) addPadding() {
 	q.data.AppendNumBools(q.version.numBitsToPadToCodeword(q.data.Len()), false)
 
 	// Pad codewords 0b11101100 and 0b00010001.
-	var padding [2]*bitset.Bitset = [2]*bitset.Bitset{
+	padding := [2]*bitset.Bitset{
 		bitset.New(true, true, true, false, true, true, false, false),
 		bitset.New(false, false, false, true, false, false, false, true),
 	}

qrcode_decode_test.go

@@ -142,13 +142,13 @@ func TestDecodeFuzz(t *testing.T) {
 		t.Skip("Decode fuzz tests not enabled")
 	}
 
-	var r *rand.Rand = rand.New(rand.NewSource(0))
+	r := rand.New(rand.NewSource(0))
 
-	const kIterations int = 32
-	const kMaxLength int = 128
+	const iterations int = 32
+	const maxLength int = 128
 
-	for i := 0; i < kIterations; i++ {
-		len := r.Intn(kMaxLength-1) + 1
+	for i := 0; i < iterations; i++ {
+		len := r.Intn(maxLength-1) + 1
 
 		var content string
 		for j := 0; j < len; j++ {
@@ -179,7 +179,7 @@ func zbarimgCheck(q *QRCode) error {
 
 	if s != q.Content {
 		q.WriteFile(256, fmt.Sprintf("%x.png", q.Content))
-		return fmt.Errorf("Got '%s' (%x) expected '%s' (%x)", s, s, q.Content, q.Content)
+		return fmt.Errorf("got '%s' (%x) expected '%s' (%x)", s, s, q.Content, q.Content)
 	}
 
 	return nil
@@ -194,7 +194,7 @@ func zbarimgDecode(q *QRCode) (string, error) {
 		return "", err
 	}
 
-	var cmd *exec.Cmd = exec.Command("zbarimg", "--quiet", "-Sdisable",
+	cmd := exec.Command("zbarimg", "--quiet", "-Sdisable",
 		"-Sqrcode.enable", "/dev/stdin")
 
 	var out bytes.Buffer

regular_symbol.go

@@ -106,7 +106,7 @@ var (
 
 func buildRegularSymbol(version qrCodeVersion, mask int,
 	data *bitset.Bitset) (*symbol, error) {
-	var m *regularSymbol = &regularSymbol{
+	m := &regularSymbol{
 		version: version,
 		mask:    mask,
 		data:    data,
@@ -130,10 +130,10 @@ func buildRegularSymbol(version qrCodeVersion, mask int,
 }
 
 func (m *regularSymbol) addFinderPatterns() {
-	var fpSize int = finderPatternSize
-	var fp [][]bool = finderPattern
-	var fpHBorder [][]bool = finderPatternHorizontalBorder
-	var fpVBorder [][]bool = finderPatternVerticalBorder
+	fpSize := finderPatternSize
+	fp := finderPattern
+	fpHBorder := finderPatternHorizontalBorder
+	fpVBorder := finderPatternVerticalBorder
 
 	// Top left Finder Pattern.
 	m.symbol.set2dPattern(0, 0, fp)
@@ -164,7 +164,7 @@ func (m *regularSymbol) addAlignmentPatterns() {
 }
 
 func (m *regularSymbol) addTimingPatterns() {
-	var value bool = true
+	value := true
 
 	for i := finderPatternSize + 1; i < m.size-finderPatternSize; i++ {
 		m.symbol.set(i, finderPatternSize-1, value)
@@ -175,10 +175,10 @@ func (m *regularSymbol) addTimingPatterns() {
 }
 
 func (m *regularSymbol) addFormatInfo() {
-	var fpSize int = finderPatternSize
-	var l int = formatInfoLengthBits - 1
+	fpSize := finderPatternSize
+	l := formatInfoLengthBits - 1
 
-	var f *bitset.Bitset = m.version.formatInfo(m.mask)
+	f := m.version.formatInfo(m.mask)
 
 	// Bits 0-7, under the top right finder pattern.
 	for i := 0; i <= 7; i++ {
@@ -210,10 +210,10 @@ func (m *regularSymbol) addFormatInfo() {
 }
 
 func (m *regularSymbol) addVersionInfo() {
-	var fpSize int = finderPatternSize
+	fpSize := finderPatternSize
 
-	var v *bitset.Bitset = m.version.versionInfo()
-	var l int = versionInfoLengthBits - 1
+	v := m.version.versionInfo()
+	l := versionInfoLengthBits - 1
 
 	if v == nil {
 		return
@@ -236,11 +236,11 @@ const (
 )
 
 func (m *regularSymbol) addData() (bool, error) {
-	var xOffset int = 1
-	var dir direction = up
+	xOffset := 1
+	dir := up
 
-	var x int = m.size - 2
-	var y int = m.size - 1
+	x := m.size - 2
+	y := m.size - 1
 
 	for i := 0; i < m.data.Len(); i++ {
 		var mask bool

regular_symbol_test.go

@@ -12,10 +12,9 @@ import (
 
 func TestBuildRegularSymbol(t *testing.T) {
 	for k := 0; k <= 7; k++ {
-		var v *qrCodeVersion = getQRCodeVersion(Low, 1)
-		var s *symbol
+		v := getQRCodeVersion(Low, 1)
 
-		var data *bitset.Bitset = bitset.New()
+		data := bitset.New()
 		for i := 0; i < 26; i++ {
 			data.AppendNumBools(8, false)
 		}

symbol.go

@@ -90,9 +90,9 @@ func (m *symbol) set2dPattern(x int, y int, v [][]bool) {
 
 // bitmap returns the entire symbol, including the quiet zone.
 func (m *symbol) bitmap() [][]bool {
-	var module [][]bool = make([][]bool, len(m.module))
+	module := make([][]bool, len(m.module))
 
-	for i, _ := range m.module {
+	for i := range m.module {
 		module[i] = m.module[i][:]
 	}
 
@@ -142,7 +142,7 @@ func (m *symbol) penaltyScore() int {
 // 0-5: score = 0
 // 6+ : score = penaltyWeight1 + (numAdjacentModules - 5)
 func (m *symbol) penalty1() int {
-	var penalty int = 0
+	penalty := 0
 
 	for x := 0; x < m.symbolSize; x++ {
 		lastValue := m.get(x, 0)
@@ -159,7 +159,7 @@ func (m *symbol) penalty1() int {
 				if count == 6 {
 					penalty += penaltyWeight1 + 1
 				} else if count > 6 {
-					penalty += 1
+					penalty++
 				}
 			}
 		}
@@ -180,7 +180,7 @@ func (m *symbol) penalty1() int {
 				if count == 6 {
 					penalty += penaltyWeight1 + 1
 				} else if count > 6 {
-					penalty += 1
+					penalty++
 				}
 			}
 		}
@@ -193,7 +193,7 @@ func (m *symbol) penalty1() int {
 //
 // m*n: score = penaltyWeight2 * (m-1) * (n-1).
 func (m *symbol) penalty2() int {
-	var penalty int = 0
+	penalty := 0
 
 	for y := 1; y < m.symbolSize; y++ {
 		for x := 1; x < m.symbolSize; x++ {
@@ -217,7 +217,7 @@ func (m *symbol) penalty2() int {
 //
 // Existence of the pattern scores penaltyWeight3.
 func (m *symbol) penalty3() int {
-	var penalty int = 0
+	penalty := 0
 
 	for y := 0; y < m.symbolSize; y++ {
 		var bitBuffer int16 = 0x00
@@ -272,8 +272,8 @@ func (m *symbol) penalty3() int {
 
 // penalty4 returns the penalty score...
 func (m *symbol) penalty4() int {
-	var numModules int = m.symbolSize * m.symbolSize
-	var numDarkModules int = 0
+	numModules := m.symbolSize * m.symbolSize
+	numDarkModules := 0
 
 	for x := 0; x < m.symbolSize; x++ {
 		for y := 0; y < m.symbolSize; y++ {
@@ -283,7 +283,7 @@ func (m *symbol) penalty4() int {
 		}
 	}
 
-	var numDarkModuleDeviation int = numModules/2 - numDarkModules
+	numDarkModuleDeviation := numModules/2 - numDarkModules
 	if numDarkModuleDeviation < 0 {
 		numDarkModuleDeviation *= -1
 	}

symbol_test.go

@@ -6,10 +6,10 @@ package qrcode
 import "testing"
 
 func TestSymbolBasic(t *testing.T) {
-	var size int = 10
-	var quietZoneSize int = 4
+	size := 10
+	quietZoneSize := 4
 
-	var m *symbol = newSymbol(size, quietZoneSize)
+	m := newSymbol(size, quietZoneSize)
 
 	if m.size != size+quietZoneSize*2 {
 		t.Errorf("Symbol size is %d, expected %d", m.size, size+quietZoneSize*2)
@@ -28,7 +28,7 @@ func TestSymbolBasic(t *testing.T) {
 				t.Errorf("New symbol is not empty")
 			}
 
-			var value bool = i*j%2 == 0
+			value := i*j%2 == 0
 			m.set(i, j, value)
 
 			v = m.get(i, j)
@@ -302,7 +302,7 @@ func TestSymbolPenalties(t *testing.T) {
 	}
 
 	for i, test := range tests {
-		var s *symbol = newSymbol(len(test.pattern[0]), 4)
+		s := newSymbol(len(test.pattern[0]), 4)
 		s.set2dPattern(0, 0, test.pattern)
 
 		penalty1 := s.penalty1()
@@ -310,7 +310,8 @@ func TestSymbolPenalties(t *testing.T) {
 		penalty3 := s.penalty3()
 		penalty4 := s.penalty4()
 
-		var ok bool = true
+		ok := true
+
 		if test.expectedPenalty1 != -1 && test.expectedPenalty1 != penalty1 {
 			ok = false
 		}

version.go

@@ -2965,7 +2965,7 @@ func (v qrCodeVersion) numDataBits() int {
 //
 // On success the chosen QR Code version is returned.
 func chooseQRCodeVersion(level RecoveryLevel, encoder *dataEncoder, numDataBits int) *qrCodeVersion {
-	var chosenVersion *qrCodeVersion = nil
+	var chosenVersion *qrCodeVersion
 
 	for _, v := range versions {
 		if v.level != level {

version_test.go

@@ -54,7 +54,7 @@ func TestFormatInfo(t *testing.T) {
 	}
 
 	for i, test := range tests {
-		var v *qrCodeVersion = getQRCodeVersion(test.level, 1)
+		v := getQRCodeVersion(test.level, 1)
 
 		result := v.formatInfo(test.maskPattern)