Merge pull request #6 from grid-x/fix/skip_linting_2

jhedev · web-flow · commit ca14cd1056f8 · 2018-03-24T10:47:00.000+01:00
fix/skip_linting_2
diff --git a/.buildkite/pipeline.yaml b/.buildkite/pipeline.yaml
@@ -9,8 +9,8 @@ steps:
   label: ":golang: Build"
   agents:
   - "queue=default"
-#- command:
-#  - "make ci_lint"
-#  label: ":llama: Linting"
-#  agents:
-#  - "queue=default"
+- command:
+  - "make ci_lint"
+  label: ":llama: Linting"
+  agents:
+  - "queue=default"
diff --git a/Makefile b/Makefile
@@ -16,11 +16,11 @@ test:
 
 .PHONY: lint
 lint:
-	golint -set_exit_status $(shell glide nv)
+	golint -set_exit_status
 
 .PHONY: build
 build:
-	go build $(shell glide nv)
+	go build
 
 ci_test:
 	${GO_RUN} "make test"
diff --git a/api.go b/api.go
@@ -4,6 +4,7 @@
 
 package modbus
 
+// Client declares the functionality of a Modbus client regardless of the underlying transport stream.
 type Client interface {
 	// Bit access
 
diff --git a/asciiclient.go b/asciiclient.go
@@ -43,7 +43,7 @@ func ASCIIClient(address string) Client {
 
 // asciiPackager implements Packager interface.
 type asciiPackager struct {
-	SlaveId byte
+	SlaveID byte
 }
 
 // Encode encodes PDU in a ASCII frame:
@@ -59,7 +59,7 @@ func (mb *asciiPackager) Encode(pdu *ProtocolDataUnit) (adu []byte, err error) {
 	if _, err = buf.WriteString(asciiStart); err != nil {
 		return
 	}
-	if err = writeHex(&buf, []byte{mb.SlaveId, pdu.FunctionCode}); err != nil {
+	if err = writeHex(&buf, []byte{mb.SlaveID, pdu.FunctionCode}); err != nil {
 		return
 	}
 	if err = writeHex(&buf, pdu.Data); err != nil {
@@ -68,7 +68,7 @@ func (mb *asciiPackager) Encode(pdu *ProtocolDataUnit) (adu []byte, err error) {
 	// Exclude the beginning colon and terminating CRLF pair characters
 	var lrc lrc
 	lrc.reset()
-	lrc.pushByte(mb.SlaveId).pushByte(pdu.FunctionCode).pushBytes(pdu.Data)
+	lrc.pushByte(mb.SlaveID).pushByte(pdu.FunctionCode).pushBytes(pdu.Data)
 	if err = writeHex(&buf, []byte{lrc.value()}); err != nil {
 		return
 	}
diff --git a/asciiclient_test.go b/asciiclient_test.go
@@ -11,7 +11,7 @@ import (
 
 func TestASCIIEncoding(t *testing.T) {
 	encoder := asciiPackager{}
-	encoder.SlaveId = 17
+	encoder.SlaveID = 17
 
 	pdu := ProtocolDataUnit{}
 	pdu.FunctionCode = 3
@@ -29,7 +29,7 @@ func TestASCIIEncoding(t *testing.T) {
 
 func TestASCIIDecoding(t *testing.T) {
 	decoder := asciiPackager{}
-	decoder.SlaveId = 247
+	decoder.SlaveID = 247
 	adu := []byte(":F7031389000A60\r\n")
 
 	pdu, err := decoder.Decode(adu)
@@ -48,7 +48,7 @@ func TestASCIIDecoding(t *testing.T) {
 
 func BenchmarkASCIIEncoder(b *testing.B) {
 	encoder := asciiPackager{
-		SlaveId: 10,
+		SlaveID: 10,
 	}
 	pdu := ProtocolDataUnit{
 		FunctionCode: 1,
@@ -64,7 +64,7 @@ func BenchmarkASCIIEncoder(b *testing.B) {
 
 func BenchmarkASCIIDecoder(b *testing.B) {
 	decoder := asciiPackager{
-		SlaveId: 10,
+		SlaveID: 10,
 	}
 	adu := []byte(":F7031389000A60\r\n")
 	for i := 0; i < b.N; i++ {
diff --git a/client.go b/client.go
@@ -486,7 +486,7 @@ func dataBlockSuffix(suffix []byte, value ...uint16) []byte {
 }
 
 func responseError(response *ProtocolDataUnit) error {
-	mbError := &ModbusError{FunctionCode: response.FunctionCode}
+	mbError := &Error{FunctionCode: response.FunctionCode}
 	if response.Data != nil && len(response.Data) > 0 {
 		mbError.ExceptionCode = response.Data[0]
 	}
diff --git a/modbus.go b/modbus.go
@@ -12,42 +12,60 @@ import (
 )
 
 const (
-	// Bit access
+	// FuncCodeReadDiscreteInputs for bit wise access
 	FuncCodeReadDiscreteInputs = 2
-	FuncCodeReadCoils          = 1
-	FuncCodeWriteSingleCoil    = 5
+	// FuncCodeReadCoils for bit wise access
+	FuncCodeReadCoils = 1
+	// FuncCodeWriteSingleCoil for bit wise access
+	FuncCodeWriteSingleCoil = 5
+	// FuncCodeWriteMultipleCoils for bit wise access
 	FuncCodeWriteMultipleCoils = 15
 
-	// 16-bit access
-	FuncCodeReadInputRegisters         = 4
-	FuncCodeReadHoldingRegisters       = 3
-	FuncCodeWriteSingleRegister        = 6
-	FuncCodeWriteMultipleRegisters     = 16
+	// FuncCodeReadInputRegisters 16-bit wise access
+	FuncCodeReadInputRegisters = 4
+	// FuncCodeReadHoldingRegisters 16-bit wise access
+	FuncCodeReadHoldingRegisters = 3
+	// FuncCodeWriteSingleRegister 16-bit wise access
+	FuncCodeWriteSingleRegister = 6
+	// FuncCodeWriteMultipleRegisters 16-bit wise access
+	FuncCodeWriteMultipleRegisters = 16
+	// FuncCodeReadWriteMultipleRegisters 16-bit wise access
 	FuncCodeReadWriteMultipleRegisters = 23
-	FuncCodeMaskWriteRegister          = 22
-	FuncCodeReadFIFOQueue              = 24
+	// FuncCodeMaskWriteRegister 16-bit wise access
+	FuncCodeMaskWriteRegister = 22
+	// FuncCodeReadFIFOQueue 16-bit wise access
+	FuncCodeReadFIFOQueue = 24
 )
 
 const (
-	ExceptionCodeIllegalFunction                    = 1
-	ExceptionCodeIllegalDataAddress                 = 2
-	ExceptionCodeIllegalDataValue                   = 3
-	ExceptionCodeServerDeviceFailure                = 4
-	ExceptionCodeAcknowledge                        = 5
-	ExceptionCodeServerDeviceBusy                   = 6
-	ExceptionCodeMemoryParityError                  = 8
-	ExceptionCodeGatewayPathUnavailable             = 10
+	// ExceptionCodeIllegalFunction error code
+	ExceptionCodeIllegalFunction = 1
+	// ExceptionCodeIllegalDataAddress error code
+	ExceptionCodeIllegalDataAddress = 2
+	// ExceptionCodeIllegalDataValue error code
+	ExceptionCodeIllegalDataValue = 3
+	// ExceptionCodeServerDeviceFailure error code
+	ExceptionCodeServerDeviceFailure = 4
+	// ExceptionCodeAcknowledge error code
+	ExceptionCodeAcknowledge = 5
+	// ExceptionCodeServerDeviceBusy error code
+	ExceptionCodeServerDeviceBusy = 6
+	// ExceptionCodeMemoryParityError error code
+	ExceptionCodeMemoryParityError = 8
+	// ExceptionCodeGatewayPathUnavailable error code
+	ExceptionCodeGatewayPathUnavailable = 10
+	// ExceptionCodeGatewayTargetDeviceFailedToRespond error code
 	ExceptionCodeGatewayTargetDeviceFailedToRespond = 11
 )
 
-// ModbusError implements error interface.
-type ModbusError struct {
+// Error implements error interface.
+type Error struct {
 	FunctionCode  byte
 	ExceptionCode byte
 }
 
 // Error converts known modbus exception code to error message.
-func (e *ModbusError) Error() string {
+func (e *Error) Error() string {
 	var name string
 	switch e.ExceptionCode {
 	case ExceptionCodeIllegalFunction:
diff --git a/rtuclient.go b/rtuclient.go
@@ -41,7 +41,7 @@ func RTUClient(address string) Client {
 
 // rtuPackager implements Packager interface.
 type rtuPackager struct {
-	SlaveId byte
+	SlaveID byte
 }
 
 // Encode encodes PDU in a RTU frame:
@@ -57,7 +57,7 @@ func (mb *rtuPackager) Encode(pdu *ProtocolDataUnit) (adu []byte, err error) {
 	}
 	adu = make([]byte, length)
 
-	adu[0] = mb.SlaveId
+	adu[0] = mb.SlaveID
 	adu[1] = pdu.FunctionCode
 	copy(adu[2:], pdu.Data)
 
diff --git a/rtuclient_test.go b/rtuclient_test.go
@@ -11,7 +11,7 @@ import (
 
 func TestRTUEncoding(t *testing.T) {
 	encoder := rtuPackager{}
-	encoder.SlaveId = 0x01
+	encoder.SlaveID = 0x01
 
 	pdu := ProtocolDataUnit{}
 	pdu.FunctionCode = 0x03
@@ -70,7 +70,7 @@ func TestCalculateResponseLength(t *testing.T) {
 
 func BenchmarkRTUEncoder(b *testing.B) {
 	encoder := rtuPackager{
-		SlaveId: 10,
+		SlaveID: 10,
 	}
 	pdu := ProtocolDataUnit{
 		FunctionCode: 1,
@@ -86,7 +86,7 @@ func BenchmarkRTUEncoder(b *testing.B) {
 
 func BenchmarkRTUDecoder(b *testing.B) {
 	decoder := rtuPackager{
-		SlaveId: 10,
+		SlaveID: 10,
 	}
 	adu := []byte{0x01, 0x10, 0x8A, 0x00, 0x00, 0x03, 0xAA, 0x10}
 	for i := 0; i < b.N; i++ {
diff --git a/tcpclient.go b/tcpclient.go
@@ -26,6 +26,7 @@ const (
 	tcpIdleTimeout = 60 * time.Second
 )
 
+// ErrTCPHeaderLength informs about a wrong header length.
 type ErrTCPHeaderLength int
 
 func (length ErrTCPHeaderLength) Error() string {
@@ -57,9 +58,9 @@ func TCPClient(address string) Client {
 // tcpPackager implements Packager interface.
 type tcpPackager struct {
 	// For synchronization between messages of server & client
-	transactionId uint32
+	transactionID uint32
 	// Broadcast address is 0
-	SlaveId byte
+	SlaveID byte
 }
 
 // Encode adds modbus application protocol header:
@@ -73,15 +74,15 @@ func (mb *tcpPackager) Encode(pdu *ProtocolDataUnit) (adu []byte, err error) {
 	adu = make([]byte, tcpHeaderSize+1+len(pdu.Data))
 
 	// Transaction identifier
-	transactionId := atomic.AddUint32(&mb.transactionId, 1)
-	binary.BigEndian.PutUint16(adu, uint16(transactionId))
+	transactionID := atomic.AddUint32(&mb.transactionID, 1)
+	binary.BigEndian.PutUint16(adu, uint16(transactionID))
 	// Protocol identifier
 	binary.BigEndian.PutUint16(adu[2:], tcpProtocolIdentifier)
-	// Length = sizeof(SlaveId) + sizeof(FunctionCode) + Data
+	// Length = sizeof(SlaveID) + sizeof(FunctionCode) + Data
 	length := uint16(1 + 1 + len(pdu.Data))
 	binary.BigEndian.PutUint16(adu[4:], length)
 	// Unit identifier
-	adu[6] = mb.SlaveId
+	adu[6] = mb.SlaveID
 
 	// PDU
 	adu[tcpHeaderSize] = pdu.FunctionCode
diff --git a/tcpclient_test.go b/tcpclient_test.go
@@ -31,8 +31,8 @@ func TestTCPEncoding(t *testing.T) {
 
 func TestTCPDecoding(t *testing.T) {
 	packager := tcpPackager{}
-	packager.transactionId = 1
-	packager.SlaveId = 17
+	packager.transactionID = 1
+	packager.SlaveID = 17
 	adu := []byte{0, 1, 0, 0, 0, 6, 17, 3, 0, 120, 0, 3}
 
 	pdu, err := packager.Decode(adu)
@@ -95,7 +95,7 @@ func TestErrTCPHeaderLength_Error(t *testing.T) {
 
 func BenchmarkTCPEncoder(b *testing.B) {
 	encoder := tcpPackager{
-		SlaveId: 10,
+		SlaveID: 10,
 	}
 	pdu := ProtocolDataUnit{
 		FunctionCode: 1,
@@ -111,7 +111,7 @@ func BenchmarkTCPEncoder(b *testing.B) {
 
 func BenchmarkTCPDecoder(b *testing.B) {
 	decoder := tcpPackager{
-		SlaveId: 10,
+		SlaveID: 10,
 	}
 	adu := []byte{0, 1, 0, 0, 0, 6, 17, 3, 0, 120, 0, 3}
 	for i := 0; i < b.N; i++ {
diff --git a/test/asciiclient_test.go b/test/asciiclient_test.go
@@ -19,7 +19,7 @@ const (
 func TestASCIIClient(t *testing.T) {
 	// Diagslave does not support broadcast id.
 	handler := modbus.NewASCIIClientHandler(asciiDevice)
-	handler.SlaveId = 17
+	handler.SlaveID = 17
 	ClientTestAll(t, modbus.NewClient(handler))
 }
 
@@ -29,7 +29,7 @@ func TestASCIIClientAdvancedUsage(t *testing.T) {
 	handler.DataBits = 8
 	handler.Parity = "E"
 	handler.StopBits = 1
-	handler.SlaveId = 12
+	handler.SlaveID = 12
 	handler.Logger = log.New(os.Stdout, "ascii: ", log.LstdFlags)
 	err := handler.Connect()
 	if err != nil {
diff --git a/test/rtuclient_test.go b/test/rtuclient_test.go
@@ -19,7 +19,7 @@ const (
 func TestRTUClient(t *testing.T) {
 	// Diagslave does not support broadcast id.
 	handler := modbus.NewRTUClientHandler(rtuDevice)
-	handler.SlaveId = 17
+	handler.SlaveID = 17
 	ClientTestAll(t, modbus.NewClient(handler))
 }
 
@@ -29,7 +29,7 @@ func TestRTUClientAdvancedUsage(t *testing.T) {
 	handler.DataBits = 8
 	handler.Parity = "E"
 	handler.StopBits = 1
-	handler.SlaveId = 11
+	handler.SlaveID = 11
 	handler.Logger = log.New(os.Stdout, "rtu: ", log.LstdFlags)
 	err := handler.Connect()
 	if err != nil {
diff --git a/test/tcpclient_test.go b/test/tcpclient_test.go
@@ -25,7 +25,7 @@ func TestTCPClient(t *testing.T) {
 func TestTCPClientAdvancedUsage(t *testing.T) {
 	handler := modbus.NewTCPClientHandler(tcpDevice)
 	handler.Timeout = 5 * time.Second
-	handler.SlaveId = 1
+	handler.SlaveID = 1
 	handler.Logger = log.New(os.Stdout, "tcp: ", log.LstdFlags)
 	handler.Connect()
 	defer handler.Close()

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ func ASCIIClient(address string) Client {`
`43`	`43`
`44`	`44`	`// asciiPackager implements Packager interface.`
`45`	`45`	`type asciiPackager struct {`
`46`		`- SlaveId byte`
	`46`	`+ SlaveID byte`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`// Encode encodes PDU in a ASCII frame:`
`@@ -59,7 +59,7 @@ func (mb asciiPackager) Encode(pdu ProtocolDataUnit) (adu []byte, err error) {`
`59`	`59`	`if _, err = buf.WriteString(asciiStart); err != nil {`
`60`	`60`	`return`
`61`	`61`	`}`
`62`		`- if err = writeHex(&buf, []byte{mb.SlaveId, pdu.FunctionCode}); err != nil {`
	`62`	`+ if err = writeHex(&buf, []byte{mb.SlaveID, pdu.FunctionCode}); err != nil {`
`63`	`63`	`return`
`64`	`64`	`}`
`65`	`65`	`if err = writeHex(&buf, pdu.Data); err != nil {`
`@@ -68,7 +68,7 @@ func (mb asciiPackager) Encode(pdu ProtocolDataUnit) (adu []byte, err error) {`
`68`	`68`	`// Exclude the beginning colon and terminating CRLF pair characters`
`69`	`69`	`var lrc lrc`
`70`	`70`	`lrc.reset()`
`71`		`- lrc.pushByte(mb.SlaveId).pushByte(pdu.FunctionCode).pushBytes(pdu.Data)`
	`71`	`+ lrc.pushByte(mb.SlaveID).pushByte(pdu.FunctionCode).pushBytes(pdu.Data)`
`72`	`72`	`if err = writeHex(&buf, []byte{lrc.value()}); err != nil {`
`73`	`73`	`return`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -486,7 +486,7 @@ func dataBlockSuffix(suffix []byte, value ...uint16) []byte {`
`486`	`486`	`}`
`487`	`487`
`488`	`488`	`func responseError(response *ProtocolDataUnit) error {`
`489`		`- mbError := &ModbusError{FunctionCode: response.FunctionCode}`
	`489`	`+ mbError := &Error{FunctionCode: response.FunctionCode}`
`490`	`490`	`if response.Data != nil && len(response.Data) > 0 {`
`491`	`491`	`mbError.ExceptionCode = response.Data[0]`
`492`	`492`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ func RTUClient(address string) Client {`
`41`	`41`
`42`	`42`	`// rtuPackager implements Packager interface.`
`43`	`43`	`type rtuPackager struct {`
`44`		`- SlaveId byte`
	`44`	`+ SlaveID byte`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`// Encode encodes PDU in a RTU frame:`
`@@ -57,7 +57,7 @@ func (mb rtuPackager) Encode(pdu ProtocolDataUnit) (adu []byte, err error) {`
`57`	`57`	`}`
`58`	`58`	`adu = make([]byte, length)`
`59`	`59`
`60`		`- adu[0] = mb.SlaveId`
	`60`	`+ adu[0] = mb.SlaveID`
`61`	`61`	`adu[1] = pdu.FunctionCode`
`62`	`62`	`copy(adu[2:], pdu.Data)`
`63`	`63`