Fix linter errors thrown by lll (#3970)

* Fix long line errors in abci, crypto, and libs packages

* Fix long lines in p2p and rpc packages

* Fix long lines in abci, state, and tools packages

* Fix long lines in behaviour and blockchain packages

* Fix long lines in cmd and config packages

* Begin fixing long lines in consensus package

* Finish fixing long lines in consensus package

* Add lll exclusion for lines containing URLs

* Fix long lines in crypto package

* Fix long lines in evidence package

* Fix long lines in mempool and node packages

* Fix long lines in libs package

* Fix long lines in lite package

* Fix new long line in node package

* Fix long lines in p2p package

* Ignore gocritic warning

* Fix long lines in privval package

* Fix long lines in rpc package

* Fix long lines in scripts package

* Fix long lines in state package

* Fix long lines in tools package

* Fix long lines in types package

* Enable lll linter

libs/cli/flags/log_level.go

@@ -66,7 +66,11 @@ func ParseLogLevel(lvl string, logger log.Logger, defaultLogLevelValue string) (
 			case "none":
 				option = log.AllowNoneWith("module", module)
 			default:
-				return nil, fmt.Errorf("Expected either \"info\", \"debug\", \"error\" or \"none\" log level, given %s (pair %s, list %s)", level, item, list)
+				return nil,
+					fmt.Errorf("Expected either \"info\", \"debug\", \"error\" or \"none\" log level, given %s (pair %s, list %s)",
+						level,
+						item,
+						list)
 			}
 			options = append(options, option)
 

libs/common/async.go

@@ -126,7 +126,9 @@ func Parallel(tasks ...Task) (trs *TaskResultSet, ok bool) {
 	var taskResultChz = make([]TaskResultCh, len(tasks)) // To return.
 	var taskDoneCh = make(chan bool, len(tasks))         // A "wait group" channel, early abort if any true received.
 	var numPanics = new(int32)                           // Keep track of panics to set ok=false later.
-	ok = true                                            // We will set it to false iff any tasks panic'd or returned abort.
+
+	// We will set it to false iff any tasks panic'd or returned abort.
+	ok = true
 
 	// Start all tasks in parallel in separate goroutines.
 	// When the task is complete, it will appear in the

libs/common/bit_array_test.go

@@ -102,7 +102,15 @@ func TestSub(t *testing.T) {
 		require.Nil(t, err)
 
 		got, _ := json.Marshal(bA.Sub(o))
-		require.Equal(t, tc.expectedBA, string(got), "%s minus %s doesn't equal %s", tc.initBA, tc.subtractingBA, tc.expectedBA)
+		require.Equal(
+			t,
+			tc.expectedBA,
+			string(got),
+			"%s minus %s doesn't equal %s",
+			tc.initBA,
+			tc.subtractingBA,
+			tc.expectedBA,
+		)
 	}
 }
 

libs/common/cmap_test.go

@@ -35,7 +35,12 @@ func TestIterateKeysWithValues(t *testing.T) {
 	// Delete 1 Key
 	cmap.Delete("key1")
 
-	assert.NotEqual(t, len(keys), len(cmap.Keys()), "[]keys and []Keys() should not be equal, they are copies, one item was removed")
+	assert.NotEqual(
+		t,
+		len(keys),
+		len(cmap.Keys()),
+		"[]keys and []Keys() should not be equal, they are copies, one item was removed",
+	)
 }
 
 func TestContains(t *testing.T) {

libs/log/filter.go

@@ -72,10 +72,14 @@ func (l *filter) Error(msg string, keyvals ...interface{}) {
 //     logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"))
 //		 logger.With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto"
 //
-//     logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam"))
+//     logger = log.NewFilter(logger, log.AllowError(),
+//				log.AllowInfoWith("module", "crypto"),
+// 				log.AllowNoneWith("user", "Sam"))
 //		 logger.With("module", "crypto", "user", "Sam").Info("Hello") # returns nil
 //
-//     logger = log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam"))
+//     logger = log.NewFilter(logger,
+// 				log.AllowError(),
+// 				log.AllowInfoWith("module", "crypto"), log.AllowNoneWith("user", "Sam"))
 //		 logger.With("user", "Sam").With("module", "crypto").Info("Hello") # produces "I... Hello module=crypto user=Sam"
 func (l *filter) With(keyvals ...interface{}) Logger {
 	keyInAllowedKeyvals := false

libs/log/filter_test.go

@@ -79,7 +79,10 @@ func TestLevelContext(t *testing.T) {
 	logger = logger.With("context", "value")
 
 	logger.Error("foo", "bar", "baz")
-	if want, have := `{"_msg":"foo","bar":"baz","context":"value","level":"error"}`, strings.TrimSpace(buf.String()); want != have {
+
+	want := `{"_msg":"foo","bar":"baz","context":"value","level":"error"}`
+	have := strings.TrimSpace(buf.String())
+	if want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
 	}
 
@@ -97,13 +100,22 @@ func TestVariousAllowWith(t *testing.T) {
 
 	logger1 := log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("context", "value"))
 	logger1.With("context", "value").Info("foo", "bar", "baz")
-	if want, have := `{"_msg":"foo","bar":"baz","context":"value","level":"info"}`, strings.TrimSpace(buf.String()); want != have {
+
+	want := `{"_msg":"foo","bar":"baz","context":"value","level":"info"}`
+	have := strings.TrimSpace(buf.String())
+	if want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
 	}
 
 	buf.Reset()
 
-	logger2 := log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("context", "value"), log.AllowNoneWith("user", "Sam"))
+	logger2 := log.NewFilter(
+		logger,
+		log.AllowError(),
+		log.AllowInfoWith("context", "value"),
+		log.AllowNoneWith("user", "Sam"),
+	)
+
 	logger2.With("context", "value", "user", "Sam").Info("foo", "bar", "baz")
 	if want, have := ``, strings.TrimSpace(buf.String()); want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
@@ -111,9 +123,18 @@ func TestVariousAllowWith(t *testing.T) {
 
 	buf.Reset()
 
-	logger3 := log.NewFilter(logger, log.AllowError(), log.AllowInfoWith("context", "value"), log.AllowNoneWith("user", "Sam"))
+	logger3 := log.NewFilter(
+		logger,
+		log.AllowError(),
+		log.AllowInfoWith("context", "value"),
+		log.AllowNoneWith("user", "Sam"),
+	)
+
 	logger3.With("user", "Sam").With("context", "value").Info("foo", "bar", "baz")
-	if want, have := `{"_msg":"foo","bar":"baz","context":"value","level":"info","user":"Sam"}`, strings.TrimSpace(buf.String()); want != have {
+
+	want = `{"_msg":"foo","bar":"baz","context":"value","level":"info","user":"Sam"}`
+	have = strings.TrimSpace(buf.String())
+	if want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
 	}
 }

libs/log/tracing_logger_test.go

@@ -20,22 +20,45 @@ func TestTracingLogger(t *testing.T) {
 	err1 := errors.New("Courage is grace under pressure.")
 	err2 := errors.New("It does not matter how slowly you go, so long as you do not stop.")
 	logger1.With("err1", err1).Info("foo", "err2", err2)
+
+	want := strings.Replace(
+		strings.Replace(
+			`{"_msg":"foo","err1":"`+
+				fmt.Sprintf("%+v", err1)+
+				`","err2":"`+
+				fmt.Sprintf("%+v", err2)+
+				`","level":"info"}`,
+			"\t", "", -1,
+		), "\n", "", -1)
 	have := strings.Replace(strings.Replace(strings.TrimSpace(buf.String()), "\\n", "", -1), "\\t", "", -1)
-	if want := strings.Replace(strings.Replace(`{"_msg":"foo","err1":"`+fmt.Sprintf("%+v", err1)+`","err2":"`+fmt.Sprintf("%+v", err2)+`","level":"info"}`, "\t", "", -1), "\n", "", -1); want != have {
+	if want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
 	}
 
 	buf.Reset()
 
-	logger.With("err1", stderr.New("Opportunities don't happen. You create them.")).Info("foo", "err2", stderr.New("Once you choose hope, anything's possible."))
-	if want, have := `{"_msg":"foo","err1":"Opportunities don't happen. You create them.","err2":"Once you choose hope, anything's possible.","level":"info"}`, strings.TrimSpace(buf.String()); want != have {
+	logger.With(
+		"err1", stderr.New("Opportunities don't happen. You create them."),
+	).Info(
+		"foo", "err2", stderr.New("Once you choose hope, anything's possible."),
+	)
+
+	want = `{"_msg":"foo",` +
+		`"err1":"Opportunities don't happen. You create them.",` +
+		`"err2":"Once you choose hope, anything's possible.",` +
+		`"level":"info"}`
+	have = strings.TrimSpace(buf.String())
+	if want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
 	}
 
 	buf.Reset()
 
 	logger.With("user", "Sam").With("context", "value").Info("foo", "bar", "baz")
-	if want, have := `{"_msg":"foo","bar":"baz","context":"value","level":"info","user":"Sam"}`, strings.TrimSpace(buf.String()); want != have {
+
+	want = `{"_msg":"foo","bar":"baz","context":"value","level":"info","user":"Sam"}`
+	have = strings.TrimSpace(buf.String())
+	if want != have {
 		t.Errorf("\nwant '%s'\nhave '%s'", want, have)
 	}
 }

libs/pubsub/pubsub.go

@@ -146,7 +146,11 @@ func (s *Server) BufferCapacity() int {
 // outCapacity can be used to set a capacity for Subscription#Out channel (1 by
 // default). Panics if outCapacity is less than or equal to zero. If you want
 // an unbuffered channel, use SubscribeUnbuffered.
-func (s *Server) Subscribe(ctx context.Context, clientID string, query Query, outCapacity ...int) (*Subscription, error) {
+func (s *Server) Subscribe(
+	ctx context.Context,
+	clientID string,
+	query Query,
+	outCapacity ...int) (*Subscription, error) {
 	outCap := 1
 	if len(outCapacity) > 0 {
 		if outCapacity[0] <= 0 {

libs/pubsub/pubsub_test.go

@@ -140,14 +140,26 @@ func TestDifferentClients(t *testing.T) {
 	require.NoError(t, err)
 	assertReceive(t, "Iceman", subscription1.Out())
 
-	subscription2, err := s.Subscribe(ctx, "client-2", query.MustParse("tm.events.type='NewBlock' AND abci.account.name='Igor'"))
+	subscription2, err := s.Subscribe(
+		ctx,
+		"client-2",
+		query.MustParse("tm.events.type='NewBlock' AND abci.account.name='Igor'"),
+	)
 	require.NoError(t, err)
-	err = s.PublishWithEvents(ctx, "Ultimo", map[string][]string{"tm.events.type": {"NewBlock"}, "abci.account.name": {"Igor"}})
+	err = s.PublishWithEvents(
+		ctx,
+		"Ultimo",
+		map[string][]string{"tm.events.type": {"NewBlock"}, "abci.account.name": {"Igor"}},
+	)
 	require.NoError(t, err)
 	assertReceive(t, "Ultimo", subscription1.Out())
 	assertReceive(t, "Ultimo", subscription2.Out())
 
-	subscription3, err := s.Subscribe(ctx, "client-3", query.MustParse("tm.events.type='NewRoundStep' AND abci.account.name='Igor' AND abci.invoice.number = 10"))
+	subscription3, err := s.Subscribe(
+		ctx,
+		"client-3",
+		query.MustParse("tm.events.type='NewRoundStep' AND abci.account.name='Igor' AND abci.invoice.number = 10"),
+	)
 	require.NoError(t, err)
 	err = s.PublishWithEvents(ctx, "Valeria Richards", map[string][]string{"tm.events.type": {"NewRoundStep"}})
 	require.NoError(t, err)
@@ -344,7 +356,11 @@ func benchmarkNClients(n int, b *testing.B) {
 
 	ctx := context.Background()
 	for i := 0; i < n; i++ {
-		subscription, err := s.Subscribe(ctx, clientID, query.MustParse(fmt.Sprintf("abci.Account.Owner = 'Ivan' AND abci.Invoices.Number = %d", i)))
+		subscription, err := s.Subscribe(
+			ctx,
+			clientID,
+			query.MustParse(fmt.Sprintf("abci.Account.Owner = 'Ivan' AND abci.Invoices.Number = %d", i)),
+		)
 		if err != nil {
 			b.Fatal(err)
 		}
@@ -363,7 +379,11 @@ func benchmarkNClients(n int, b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		s.PublishWithEvents(ctx, "Gamora", map[string][]string{"abci.Account.Owner": {"Ivan"}, "abci.Invoices.Number": {string(i)}})
+		s.PublishWithEvents(
+			ctx,
+			"Gamora",
+			map[string][]string{"abci.Account.Owner": {"Ivan"}, "abci.Invoices.Number": {string(i)}},
+		)
 	}
 }
 

libs/pubsub/query/query.go

@@ -120,26 +120,36 @@ func (q *Query) Conditions() []Condition {
 			if strings.ContainsAny(number, ".") { // if it looks like a floating-point number
 				value, err := strconv.ParseFloat(number, 64)
 				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as float64 (should never happen if the grammar is correct)", err, number))
+					panic(fmt.Sprintf("got %v while trying to parse %s as float64 (should never happen if the grammar is correct)",
+						err,
+						number))
 				}
 				conditions = append(conditions, Condition{tag, op, value})
 			} else {
 				value, err := strconv.ParseInt(number, 10, 64)
 				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as int64 (should never happen if the grammar is correct)", err, number))
+					panic(fmt.Sprintf("got %v while trying to parse %s as int64 (should never happen if the grammar is correct)",
+						err,
+						number))
 				}
 				conditions = append(conditions, Condition{tag, op, value})
 			}
 		case ruletime:
 			value, err := time.Parse(TimeLayout, buffer[begin:end])
 			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)", err, buffer[begin:end]))
+				panic(fmt.Sprintf(
+					"got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)",
+					err,
+					buffer[begin:end]))
 			}
 			conditions = append(conditions, Condition{tag, op, value})
 		case ruledate:
 			value, err := time.Parse("2006-01-02", buffer[begin:end])
 			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)", err, buffer[begin:end]))
+				panic(fmt.Sprintf(
+					"got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)",
+					err,
+					buffer[begin:end]))
 			}
 			conditions = append(conditions, Condition{tag, op, value})
 		}
@@ -199,7 +209,10 @@ func (q *Query) Matches(events map[string][]string) bool {
 			if strings.ContainsAny(number, ".") { // if it looks like a floating-point number
 				value, err := strconv.ParseFloat(number, 64)
 				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as float64 (should never happen if the grammar is correct)", err, number))
+					panic(fmt.Sprintf(
+						"got %v while trying to parse %s as float64 (should never happen if the grammar is correct)",
+						err,
+						number))
 				}
 				if !match(tag, op, reflect.ValueOf(value), events) {
 					return false
@@ -207,7 +220,10 @@ func (q *Query) Matches(events map[string][]string) bool {
 			} else {
 				value, err := strconv.ParseInt(number, 10, 64)
 				if err != nil {
-					panic(fmt.Sprintf("got %v while trying to parse %s as int64 (should never happen if the grammar is correct)", err, number))
+					panic(fmt.Sprintf(
+						"got %v while trying to parse %s as int64 (should never happen if the grammar is correct)",
+						err,
+						number))
 				}
 				if !match(tag, op, reflect.ValueOf(value), events) {
 					return false
@@ -216,7 +232,10 @@ func (q *Query) Matches(events map[string][]string) bool {
 		case ruletime:
 			value, err := time.Parse(TimeLayout, buffer[begin:end])
 			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)", err, buffer[begin:end]))
+				panic(fmt.Sprintf(
+					"got %v while trying to parse %s as time.Time / RFC3339 (should never happen if the grammar is correct)",
+					err,
+					buffer[begin:end]))
 			}
 			if !match(tag, op, reflect.ValueOf(value), events) {
 				return false
@@ -224,7 +243,10 @@ func (q *Query) Matches(events map[string][]string) bool {
 		case ruledate:
 			value, err := time.Parse("2006-01-02", buffer[begin:end])
 			if err != nil {
-				panic(fmt.Sprintf("got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)", err, buffer[begin:end]))
+				panic(fmt.Sprintf(
+					"got %v while trying to parse %s as time.Time / '2006-01-02' (should never happen if the grammar is correct)",
+					err,
+					buffer[begin:end]))
 			}
 			if !match(tag, op, reflect.ValueOf(value), events) {
 				return false

libs/pubsub/query/query_test.go

@@ -31,28 +31,72 @@ func TestMatches(t *testing.T) {
 		{"account.balance < 1000.0", map[string][]string{"account.balance": {"900"}}, false, true},
 		{"apples.kg <= 4", map[string][]string{"apples.kg": {"4.0"}}, false, true},
 		{"body.weight >= 4.5", map[string][]string{"body.weight": {fmt.Sprintf("%v", float32(4.5))}}, false, true},
-		{"oranges.kg < 4 AND watermellons.kg > 10", map[string][]string{"oranges.kg": {"3"}, "watermellons.kg": {"12"}}, false, true},
+		{
+			"oranges.kg < 4 AND watermellons.kg > 10",
+			map[string][]string{"oranges.kg": {"3"}, "watermellons.kg": {"12"}},
+			false,
+			true,
+		},
 		{"peaches.kg < 4", map[string][]string{"peaches.kg": {"5"}}, false, false},
 
-		{"tx.date > DATE 2017-01-01", map[string][]string{"tx.date": {time.Now().Format(query.DateLayout)}}, false, true},
+		{
+			"tx.date > DATE 2017-01-01",
+			map[string][]string{"tx.date": {time.Now().Format(query.DateLayout)}},
+			false,
+			true,
+		},
 		{"tx.date = DATE 2017-01-01", map[string][]string{"tx.date": {txDate}}, false, true},
 		{"tx.date = DATE 2018-01-01", map[string][]string{"tx.date": {txDate}}, false, false},
 
-		{"tx.time >= TIME 2013-05-03T14:45:00Z", map[string][]string{"tx.time": {time.Now().Format(query.TimeLayout)}}, false, true},
+		{
+			"tx.time >= TIME 2013-05-03T14:45:00Z",
+			map[string][]string{"tx.time": {time.Now().Format(query.TimeLayout)}},
+			false,
+			true,
+		},
 		{"tx.time = TIME 2013-05-03T14:45:00Z", map[string][]string{"tx.time": {txTime}}, false, false},
 
 		{"abci.owner.name CONTAINS 'Igor'", map[string][]string{"abci.owner.name": {"Igor,Ivan"}}, false, true},
 		{"abci.owner.name CONTAINS 'Igor'", map[string][]string{"abci.owner.name": {"Pavel,Ivan"}}, false, false},
 
 		{"abci.owner.name = 'Igor'", map[string][]string{"abci.owner.name": {"Igor", "Ivan"}}, false, true},
-		{"abci.owner.name = 'Ivan'", map[string][]string{"abci.owner.name": {"Igor", "Ivan"}}, false, true},
-		{"abci.owner.name = 'Ivan' AND abci.owner.name = 'Igor'", map[string][]string{"abci.owner.name": {"Igor", "Ivan"}}, false, true},
-		{"abci.owner.name = 'Ivan' AND abci.owner.name = 'John'", map[string][]string{"abci.owner.name": {"Igor", "Ivan"}}, false, false},
-
-		{"tm.events.type='NewBlock'", map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}}, false, true},
+		{
+			"abci.owner.name = 'Ivan'",
+			map[string][]string{"abci.owner.name": {"Igor", "Ivan"}},
+			false,
+			true,
+		},
+		{
+			"abci.owner.name = 'Ivan' AND abci.owner.name = 'Igor'",
+			map[string][]string{"abci.owner.name": {"Igor", "Ivan"}},
+			false,
+			true,
+		},
+		{
+			"abci.owner.name = 'Ivan' AND abci.owner.name = 'John'",
+			map[string][]string{"abci.owner.name": {"Igor", "Ivan"}},
+			false,
+			false,
+		},
+		{
+			"tm.events.type='NewBlock'",
+			map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}},
+			false,
+			true,
+		},
 		{"app.name = 'fuzzed'", map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}}, false, true},
-		{"tm.events.type='NewBlock' AND app.name = 'fuzzed'", map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}}, false, true},
-		{"tm.events.type='NewHeader' AND app.name = 'fuzzed'", map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}}, false, false},
+		{
+			"tm.events.type='NewBlock' AND app.name = 'fuzzed'",
+			map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}},
+			false,
+			true,
+		},
+		{
+			"tm.events.type='NewHeader' AND app.name = 'fuzzed'",
+			map[string][]string{"tm.events.type": {"NewBlock"}, "app.name": {"fuzzed"}},
+			false,
+			false,
+		},
 	}
 
 	for _, tc := range testCases {
@@ -84,9 +128,25 @@ func TestConditions(t *testing.T) {
 		s          string
 		conditions []query.Condition
 	}{
-		{s: "tm.events.type='NewBlock'", conditions: []query.Condition{{Tag: "tm.events.type", Op: query.OpEqual, Operand: "NewBlock"}}},
-		{s: "tx.gas > 7 AND tx.gas < 9", conditions: []query.Condition{{Tag: "tx.gas", Op: query.OpGreater, Operand: int64(7)}, {Tag: "tx.gas", Op: query.OpLess, Operand: int64(9)}}},
-		{s: "tx.time >= TIME 2013-05-03T14:45:00Z", conditions: []query.Condition{{Tag: "tx.time", Op: query.OpGreaterEqual, Operand: txTime}}},
+		{
+			s: "tm.events.type='NewBlock'",
+			conditions: []query.Condition{
+				{Tag: "tm.events.type", Op: query.OpEqual, Operand: "NewBlock"},
+			},
+		},
+		{
+			s: "tx.gas > 7 AND tx.gas < 9",
+			conditions: []query.Condition{
+				{Tag: "tx.gas", Op: query.OpGreater, Operand: int64(7)},
+				{Tag: "tx.gas", Op: query.OpLess, Operand: int64(9)},
+			},
+		},
+		{
+			s: "tx.time >= TIME 2013-05-03T14:45:00Z",
+			conditions: []query.Condition{
+				{Tag: "tx.time", Op: query.OpGreaterEqual, Operand: txTime},
+			},
+		},
 	}
 
 	for _, tc := range testCases {