Skip to content

Commit ffe6741

Browse files
bplommerbplommer
authored
Merge pull request #528 from fd4s/redundant-braces
Scalafmt rule to remove redundant braces
2 parents 105635c + e73c9f0 commit ffe6741

13 files changed

Lines changed: 45 additions & 86 deletions

‎.scalafmt.conf‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,3 +3,5 @@ style = default
33
maxColumn = 100
44
project.git = true
55
continuationIndent.defnSite = 2
6+
7+
rewrite.rules = [RedundantBraces]

‎modules/core/src/main/scala/fs2/kafka/CommittableConsumerRecord.scala‎

Lines changed: 7 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -79,12 +79,11 @@ object CommittableConsumerRecord {
7979
}
8080

8181
implicit def committableConsumerRecordEq[F[_], K: Eq, V: Eq]
82-
: Eq[CommittableConsumerRecord[F, K, V]] = {
82+
: Eq[CommittableConsumerRecord[F, K, V]] =
8383
Eq.instance {
8484
case (l, r) =>
8585
l.record === r.record && l.offset === r.offset
8686
}
87-
}
8887

8988
implicit def committableConsumerRecordBitraverse[F[_]]
9089
: Bitraverse[CommittableConsumerRecord[F, *, *]] =
@@ -93,49 +92,43 @@ object CommittableConsumerRecord {
9392
fab: CommittableConsumerRecord[F, A, B]
9493
)(f: A => G[C], g: B => G[D])(
9594
implicit G: Applicative[G]
96-
): G[CommittableConsumerRecord[F, C, D]] = {
95+
): G[CommittableConsumerRecord[F, C, D]] =
9796
fab.record.bitraverse(f, g).map { (cd: ConsumerRecord[C, D]) =>
9897
CommittableConsumerRecord(cd, fab.offset)
9998
}
100-
}
10199

102100
override def bifoldLeft[A, B, C](
103101
fab: CommittableConsumerRecord[F, A, B],
104102
c: C
105-
)(f: (C, A) => C, g: (C, B) => C): C = {
103+
)(f: (C, A) => C, g: (C, B) => C): C =
106104
fab.record.bifoldLeft(c)(f, g)
107-
}
108105

109106
override def bifoldRight[A, B, C](
110107
fab: CommittableConsumerRecord[F, A, B],
111108
c: Eval[C]
112-
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] = {
109+
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] =
113110
fab.record.bifoldRight(c)(f, g)
114-
}
115111
}
116112

117113
implicit def committableConsumerRecordTraverse[F[_], K]
118114
: Traverse[CommittableConsumerRecord[F, K, *]] =
119115
new Traverse[CommittableConsumerRecord[F, K, *]] {
120116
override def traverse[G[_], A, B](
121117
fa: CommittableConsumerRecord[F, K, A]
122-
)(f: A => G[B])(implicit G: Applicative[G]): G[CommittableConsumerRecord[F, K, B]] = {
118+
)(f: A => G[B])(implicit G: Applicative[G]): G[CommittableConsumerRecord[F, K, B]] =
123119
fa.record.traverse(f).map { (b: ConsumerRecord[K, B]) =>
124120
CommittableConsumerRecord(b, fa.offset)
125121
}
126-
}
127122

128123
override def foldLeft[A, B](fa: CommittableConsumerRecord[F, K, A], b: B)(
129124
f: (B, A) => B
130-
): B = {
125+
): B =
131126
fa.record.foldLeft(b)(f)
132-
}
133127

134128
override def foldRight[A, B](
135129
fa: CommittableConsumerRecord[F, K, A],
136130
lb: Eval[B]
137-
)(f: (A, Eval[B]) => Eval[B]): Eval[B] = {
131+
)(f: (A, Eval[B]) => Eval[B]): Eval[B] =
138132
fa.record.foldRight(lb)(f)
139-
}
140133
}
141134
}

‎modules/core/src/main/scala/fs2/kafka/CommittableProducerRecords.scala‎

Lines changed: 7 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -45,10 +45,9 @@ object CommittableProducerRecords {
4545
override val records: Chunk[ProducerRecord[K, V]],
4646
override val offset: CommittableOffset[F]
4747
) extends CommittableProducerRecords[F, K, V] {
48-
override def toString: String = {
48+
override def toString: String =
4949
if (records.isEmpty) s"CommittableProducerRecords(<empty>, $offset)"
5050
else records.mkString("CommittableProducerRecords(", ", ", s", $offset)")
51-
}
5251
}
5352

5453
/**
@@ -120,69 +119,63 @@ object CommittableProducerRecords {
120119
fab: CommittableProducerRecords[F, A, B]
121120
)(f: A => G[C], g: B => G[D])(
122121
implicit G: Applicative[G]
123-
): G[CommittableProducerRecords[F, C, D]] = {
122+
): G[CommittableProducerRecords[F, C, D]] =
124123
fab.records
125124
.traverse { record =>
126125
record.bitraverse(f, g)
127126
}
128127
.map { (cd: Chunk[ProducerRecord[C, D]]) =>
129128
CommittableProducerRecords(cd, fab.offset)
130129
}
131-
}
132130

133131
override def bifoldLeft[A, B, C](
134132
fab: CommittableProducerRecords[F, A, B],
135133
c: C
136-
)(f: (C, A) => C, g: (C, B) => C): C = {
134+
)(f: (C, A) => C, g: (C, B) => C): C =
137135
fab.records.foldLeft(c) {
138136
case (acc, record) =>
139137
record.bifoldLeft(acc)(f, g)
140138
}
141-
}
142139

143140
override def bifoldRight[A, B, C](
144141
fab: CommittableProducerRecords[F, A, B],
145142
c: Eval[C]
146-
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] = {
143+
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] =
147144
fab.records.foldRight(c) {
148145
case (record, acc) =>
149146
record.bifoldRight(acc)(f, g)
150147
}
151-
}
152148
}
153149

154150
implicit def committableProducerRecordsTraverse[F[_], K]
155151
: Traverse[CommittableProducerRecords[F, K, *]] =
156152
new Traverse[CommittableProducerRecords[F, K, *]] {
157153
override def traverse[G[_], A, B](
158154
fa: CommittableProducerRecords[F, K, A]
159-
)(f: A => G[B])(implicit G: Applicative[G]): G[CommittableProducerRecords[F, K, B]] = {
155+
)(f: A => G[B])(implicit G: Applicative[G]): G[CommittableProducerRecords[F, K, B]] =
160156
fa.records
161157
.traverse { record =>
162158
record.traverse(f)
163159
}
164160
.map { (b: Chunk[ProducerRecord[K, B]]) =>
165161
CommittableProducerRecords(b, fa.offset)
166162
}
167-
}
168163

169164
override def foldLeft[A, B](fa: CommittableProducerRecords[F, K, A], b: B)(
170165
f: (B, A) => B
171-
): B = {
166+
): B =
172167
fa.records.foldLeft(b) {
173168
case (acc, record) =>
174169
record.foldLeft(acc)(f)
175170
}
176-
}
177171

178172
override def foldRight[A, B](
179173
fa: CommittableProducerRecords[F, K, A],
180174
lb: Eval[B]
181-
)(f: (A, Eval[B]) => Eval[B]): Eval[B] = {
175+
)(f: (A, Eval[B]) => Eval[B]): Eval[B] =
182176
fa.records.foldRight(lb) {
183177
case (record, acc) =>
184178
record.foldRight(acc)(f)
185179
}
186-
}
187180
}
188181
}

‎modules/core/src/main/scala/fs2/kafka/ConsumerRecord.scala‎

Lines changed: 6 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -260,46 +260,40 @@ object ConsumerRecord {
260260
new Bitraverse[ConsumerRecord] {
261261
override def bitraverse[G[_], A, B, C, D](
262262
fab: ConsumerRecord[A, B]
263-
)(f: A => G[C], g: B => G[D])(implicit G: Applicative[G]): G[ConsumerRecord[C, D]] = {
263+
)(f: A => G[C], g: B => G[D])(implicit G: Applicative[G]): G[ConsumerRecord[C, D]] =
264264
G.product(f(fab.key), g(fab.value)).map {
265265
case (c, d) =>
266266
fab.withKeyValue(c, d)
267267
}
268-
}
269268

270269
override def bifoldLeft[A, B, C](
271270
fab: ConsumerRecord[A, B],
272271
c: C
273-
)(f: (C, A) => C, g: (C, B) => C): C = {
272+
)(f: (C, A) => C, g: (C, B) => C): C =
274273
g(f(c, fab.key), fab.value)
275-
}
276274

277275
override def bifoldRight[A, B, C](
278276
fab: ConsumerRecord[A, B],
279277
c: Eval[C]
280-
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] = {
278+
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] =
281279
g(fab.value, f(fab.key, c))
282-
}
283280
}
284281

285282
implicit def consumerRecordTraverse[K]: Traverse[ConsumerRecord[K, *]] =
286283
new Traverse[ConsumerRecord[K, *]] {
287284
override def traverse[G[_], A, B](
288285
fa: ConsumerRecord[K, A]
289-
)(f: A => G[B])(implicit G: Applicative[G]): G[ConsumerRecord[K, B]] = {
286+
)(f: A => G[B])(implicit G: Applicative[G]): G[ConsumerRecord[K, B]] =
290287
f(fa.value).map { b =>
291288
fa.withValue(b)
292289
}
293-
}
294290

295-
override def foldLeft[A, B](fa: ConsumerRecord[K, A], b: B)(f: (B, A) => B): B = {
291+
override def foldLeft[A, B](fa: ConsumerRecord[K, A], b: B)(f: (B, A) => B): B =
296292
f(b, fa.value)
297-
}
298293

299294
override def foldRight[A, B](fa: ConsumerRecord[K, A], lb: Eval[B])(
300295
f: (A, Eval[B]) => Eval[B]
301-
): Eval[B] = {
296+
): Eval[B] =
302297
f(fa.value, lb)
303-
}
304298
}
305299
}

‎modules/core/src/main/scala/fs2/kafka/Headers.scala‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -89,10 +89,9 @@ object Headers {
8989
override def exists(key: String): Boolean =
9090
headers.exists(_.key == key)
9191

92-
override def concat(that: Headers): Headers = {
92+
override def concat(that: Headers): Headers =
9393
if (that.isEmpty) this
9494
else new HeadersImpl(headers.appendChain(that.toChain))
95-
}
9695

9796
override def toChain: Chain[Header] =
9897
headers.toChain

‎modules/core/src/main/scala/fs2/kafka/KafkaConsumer.scala‎

Lines changed: 6 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -159,7 +159,7 @@ object KafkaConsumer {
159159
streamId: StreamId,
160160
partitionStreamId: PartitionStreamId,
161161
partition: TopicPartition
162-
): F[Stream[F, CommittableConsumerRecord[F, K, V]]] = {
162+
): F[Stream[F, CommittableConsumerRecord[F, K, V]]] =
163163
for {
164164
chunks <- chunkQueue
165165
dequeueDone <- Deferred[F, Unit]
@@ -217,7 +217,6 @@ object KafkaConsumer {
217217
.onFinalize(dequeueDone.complete(()))
218218
}
219219
}.flatten
220-
}
221220

222221
def enqueueAssignment(
223222
streamId: StreamId,
@@ -274,7 +273,7 @@ object KafkaConsumer {
274273
streamId: StreamId,
275274
partitionStreamIdRef: Ref[F, PartitionStreamId],
276275
partitionsMapQueue: PartitionsMapQueue
277-
): F[SortedSet[TopicPartition]] = {
276+
): F[SortedSet[TopicPartition]] =
278277
Deferred[F, Either[Throwable, SortedSet[TopicPartition]]].flatMap { deferred =>
279278
val request =
280279
Request.Assignment[F, K, V](
@@ -287,7 +286,6 @@ object KafkaConsumer {
287286
case Right(assigned) => assigned
288287
}
289288
}
290-
}
291289

292290
def initialEnqueue(
293291
streamId: StreamId,
@@ -318,35 +316,32 @@ object KafkaConsumer {
318316
}
319317
}
320318

321-
override def partitionedStream: Stream[F, Stream[F, CommittableConsumerRecord[F, K, V]]] = {
319+
override def partitionedStream: Stream[F, Stream[F, CommittableConsumerRecord[F, K, V]]] =
322320
partitionsMapStream.flatMap { partitionsMap =>
323321
Stream.emits(partitionsMap.toVector.map {
324322
case (_, partitionStream) =>
325323
partitionStream
326324
})
327325
}
328-
}
329326

330327
override def stream: Stream[F, CommittableConsumerRecord[F, K, V]] =
331328
partitionedStream.parJoinUnbounded
332329

333-
override def commitAsync(offsets: Map[TopicPartition, OffsetAndMetadata]): F[Unit] = {
330+
override def commitAsync(offsets: Map[TopicPartition, OffsetAndMetadata]): F[Unit] =
334331
request { callback =>
335332
Request.ManualCommitAsync(
336333
callback = callback,
337334
offsets = offsets
338335
)
339336
}
340-
}
341337

342-
override def commitSync(offsets: Map[TopicPartition, OffsetAndMetadata]): F[Unit] = {
338+
override def commitSync(offsets: Map[TopicPartition, OffsetAndMetadata]): F[Unit] =
343339
request { callback =>
344340
Request.ManualCommitSync(
345341
callback = callback,
346342
offsets = offsets
347343
)
348344
}
349-
}
350345

351346
private[this] def request[A](
352347
request: (Either[Throwable, A] => F[Unit]) => Request[F, K, V]
@@ -493,7 +488,7 @@ object KafkaConsumer {
493488
override def assign(topic: String, partitions: NonEmptySet[Int]): F[Unit] =
494489
assign(partitions.map(new TopicPartition(topic, _)))
495490

496-
override def assign(topic: String): F[Unit] = {
491+
override def assign(topic: String): F[Unit] =
497492
for {
498493
partitions <- partitionsFor(topic)
499494
.map { partitionInfo =>
@@ -503,7 +498,6 @@ object KafkaConsumer {
503498
}
504499
_ <- partitions.fold(F.unit)(assign(topic, _))
505500
} yield ()
506-
}
507501

508502
override def beginningOffsets(
509503
partitions: Set[TopicPartition]

‎modules/core/src/main/scala/fs2/kafka/KafkaProducer.scala‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -97,13 +97,12 @@ object KafkaProducer {
9797
new KafkaProducer.Metrics[F, K, V] {
9898
override def produce[P](
9999
records: ProducerRecords[K, V, P]
100-
): F[F[ProducerResult[K, V, P]]] = {
100+
): F[F[ProducerResult[K, V, P]]] =
101101
withProducer { (producer, _) =>
102102
records.records
103103
.traverse(produceRecord(keySerializer, valueSerializer, producer))
104104
.map(_.sequence.map(ProducerResult(_, records.passthrough)))
105105
}
106-
}
107106

108107
override def metrics: F[Map[MetricName, Metric]] =
109108
withProducer.blocking { _.metrics().asScala.toMap }

‎modules/core/src/main/scala/fs2/kafka/ProducerRecord.scala‎

Lines changed: 6 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -152,46 +152,40 @@ object ProducerRecord {
152152
new Bitraverse[ProducerRecord] {
153153
override def bitraverse[G[_], A, B, C, D](
154154
fab: ProducerRecord[A, B]
155-
)(f: A => G[C], g: B => G[D])(implicit G: Applicative[G]): G[ProducerRecord[C, D]] = {
155+
)(f: A => G[C], g: B => G[D])(implicit G: Applicative[G]): G[ProducerRecord[C, D]] =
156156
G.product(f(fab.key), g(fab.value)).map {
157157
case (c, d) =>
158158
fab.withKeyValue(c, d)
159159
}
160-
}
161160

162161
override def bifoldLeft[A, B, C](
163162
fab: ProducerRecord[A, B],
164163
c: C
165-
)(f: (C, A) => C, g: (C, B) => C): C = {
164+
)(f: (C, A) => C, g: (C, B) => C): C =
166165
g(f(c, fab.key), fab.value)
167-
}
168166

169167
override def bifoldRight[A, B, C](
170168
fab: ProducerRecord[A, B],
171169
c: Eval[C]
172-
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] = {
170+
)(f: (A, Eval[C]) => Eval[C], g: (B, Eval[C]) => Eval[C]): Eval[C] =
173171
g(fab.value, f(fab.key, c))
174-
}
175172
}
176173

177174
implicit def producerRecordTraverse[K]: Traverse[ProducerRecord[K, *]] =
178175
new Traverse[ProducerRecord[K, *]] {
179176
override def traverse[G[_], A, B](
180177
fa: ProducerRecord[K, A]
181-
)(f: A => G[B])(implicit G: Applicative[G]): G[ProducerRecord[K, B]] = {
178+
)(f: A => G[B])(implicit G: Applicative[G]): G[ProducerRecord[K, B]] =
182179
f(fa.value).map { b =>
183180
fa.withValue(b)
184181
}
185-
}
186182

187-
override def foldLeft[A, B](fa: ProducerRecord[K, A], b: B)(f: (B, A) => B): B = {
183+
override def foldLeft[A, B](fa: ProducerRecord[K, A], b: B)(f: (B, A) => B): B =
188184
f(b, fa.value)
189-
}
190185

191186
override def foldRight[A, B](fa: ProducerRecord[K, A], lb: Eval[B])(
192187
f: (A, Eval[B]) => Eval[B]
193-
): Eval[B] = {
188+
): Eval[B] =
194189
f(fa.value, lb)
195-
}
196190
}
197191
}

‎modules/core/src/main/scala/fs2/kafka/ProducerRecords.scala‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -43,10 +43,9 @@ object ProducerRecords {
4343
override val records: Chunk[ProducerRecord[K, V]],
4444
override val passthrough: P
4545
) extends ProducerRecords[K, V, P] {
46-
override def toString: String = {
46+
override def toString: String =
4747
if (records.isEmpty) s"ProducerRecords(<empty>, $passthrough)"
4848
else records.mkString("ProducerRecords(", ", ", s", $passthrough)")
49-
}
5049
}
5150

5251
/**

0 commit comments

Comments
 (0)