9289360318

Committed 29 May 2024 04:00PM UTC coverage: 81.153% (+0.05%) from 81.105%

Build Type

push

Committed by

Commit Message

Update cats-helper to 3.10.5 (#622)

## About this PR
📦 Updates com.evolutiongaming:cats-helper from `3.10.3` to `3.10.5`

## Usage
✅ **Please merge!**

I'll automatically update this PR to resolve conflicts as long as you
don't change it yourself.

If you'd like to skip this version, you can just close this PR. If you
have any feedback, just mention me in the comments below.

Configure Scala Steward for your repository with a
[`.scala-steward.conf`](https://github.com/scala-steward-org/scala-steward/blob/8293d2e31/docs/repo-specific-configuration.md)
file.

_Have a fantastic day writing Scala!_

<details>
<summary>⚙ Adjust future updates</summary>

Add this to your `.scala-steward.conf` file to ignore future updates of
this dependency:
```
updates.ignore = [ { groupId = "com.evolutiongaming", artifactId = "cats-helper" } ]
```
Or, add this to slow down future updates of this dependency:
```
dependencyOverrides = [{
  pullRequests = { frequency = "30 days" },
  dependency = { groupId = "com.evolutiongaming", artifactId = "cats-helper" }
}]
```
</details>

<sup>
labels: library-update, early-semver-patch, semver-spec-patch,
version-scheme:semver-spec, commit-count:1
</sup>

Run Details

3350 of 4128 relevant lines covered (81.15%)

1.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.49

/replicator/src/main/scala/com/evolutiongaming/kafka/journal/replicator/Batch.scala

package com.evolutiongaming.kafka.journal.replicator

import cats.data.{NonEmptyList => Nel}
import cats.syntax.all._
import com.evolutiongaming.kafka.journal._
import com.evolutiongaming.skafka.Offset

sealed abstract class Batch extends Product {

  def offset: Offset
}

object Batch {

  def of(records: Nel[ActionRecord[Action]]): List[Batch] = {

    def cut(appends: Appends, delete: Action.Delete) = {
      val append = appends.records.head.action
      append.range.to <= delete.to.value
    }

    records
      .foldLeft(List.empty[Batch]) { (bs, record) =>
        val offset = record.partitionOffset.offset

        def appendsOf(records: Nel[ActionRecord[Action.Append]]) = {
          Appends(offset, records)
        }

        def deleteOf(to: DeleteTo, origin: Option[Origin], version: Option[Version]) = {
          Delete(offset, to, origin, version)
        }

        def purgeOf(origin: Option[Origin], version: Option[Version]) = {
          Purge(offset, origin, version)
        }

        def actionRecord[A <: Action](a: A) = record.copy(action = a)

        def origin = {
          bs.foldRight(none[Origin]) { (b, origin) =>
            origin orElse {
              b match {
                case b: Batch.Delete  => b.origin
                case _: Batch.Appends => none
                case b: Batch.Purge   => b.origin
              }
            }
          }
        }

        def version = {
          bs.foldRight(none[Version]) { (b, version) =>
            version orElse {
              b match {
                case b: Batch.Delete  => b.version
                case _: Batch.Appends => none
                case b: Batch.Purge   => b.version
              }
            }
          }
        }

        bs match {
          case b :: tail => (b, record.action) match {
            case (b: Appends, a: Action.Append) =>
              val records = actionRecord(a) :: b.records
              appendsOf(records) :: tail

            case (b: Appends, _: Action.Mark) =>
              appendsOf(b.records) :: tail

            case (b: Appends, a: Action.Delete) =>
              if (cut(b, a)) {
                val delete = deleteOf(a.to, origin orElse a.origin, version orElse a.version)
                delete :: Nil
              } else {
                val delete = deleteOf(a.to, a.origin, a.version)
                delete :: bs
              }

            case (_: Appends, a: Action.Purge) =>
              purgeOf(a.origin, a.version) :: Nil

            case (b: Delete, a: Action.Append) =>
              appendsOf(Nel.of(actionRecord(a))) :: b :: tail

            case (b: Delete, _: Action.Mark) =>
              b.copy(offset = offset) :: tail

            case (b: Delete, a: Action.Delete) =>
              if (a.to > b.to) {
                if (tail.collectFirst { case b: Appends => cut(b, a) } getOrElse false) {
                  val delete = deleteOf(a.to, origin orElse a.origin, version orElse a.version)
                  delete :: Nil
                } else {
                  val delete = deleteOf(a.to, b.origin orElse a.origin, b.version orElse a.version)
                  delete :: tail
                }
              } else {
                val delete = b.copy(
                  offset = offset,
                  origin = b.origin orElse a.origin,
                  version = b.version orElse a.version)
                delete :: tail
              }

            case (_: Delete, a: Action.Purge) =>
              purgeOf(a.origin, a.version) :: Nil

            case (b: Purge, a: Action.Append) =>
              appendsOf(Nel.of(actionRecord(a))) :: b :: Nil

            case (b: Purge, _: Action.Mark) =>
              b.copy(offset = offset) :: Nil

            case (b: Purge, a: Action.Delete) =>
              deleteOf(a.to, a.origin, a.version) :: b :: Nil

            case (_: Purge, a: Action.Purge) =>
              purgeOf(a.origin, a.version) :: Nil
          }

          case Nil =>
            record.action match {
              case a: Action.Append => appendsOf(Nel.of(actionRecord(a))) :: Nil
              case _: Action.Mark   => Nil
              case a: Action.Delete => deleteOf(a.to, a.origin, a.version) :: Nil
              case a: Action.Purge  => purgeOf(a.origin, a.version) :: Nil
            }
        }
      }
      .foldLeft(List.empty[Batch]) { (bs, b) =>
        b match {
          case b: Appends => b.copy(records = b.records.reverse) :: bs
          case b: Delete  => b :: bs
          case b: Purge   => b :: bs
        }
      }
  }


  final case class Appends(
    offset: Offset,
    records: Nel[ActionRecord[Action.Append]]
  ) extends Batch


  final case class Delete(
    offset: Offset,
    to: DeleteTo,
    origin: Option[Origin],
    version: Option[Version]
  ) extends Batch


  final case class Purge(
    offset: Offset,
    origin: Option[Origin],
    version: Option[Version]
  ) extends Batch
}

1	package com.evolutiongaming.kafka.journal.replicator
2
3	import cats.data.{NonEmptyList => Nel}
4	import cats.syntax.all._
5	import com.evolutiongaming.kafka.journal._
6	import com.evolutiongaming.skafka.Offset
7
8	sealed abstract class Batch extends Product {
9
10	def offset: Offset
11	}
12
13	object Batch {
14
15	def of(records: Nel[ActionRecord[Action]]): List[Batch] = {
16
17	def cut(appends: Appends, delete: Action.Delete) = {
18	val append = appends.records.head.action	1✔
19	append.range.to <= delete.to.value	1✔
20	}
21
22	records
23	.foldLeft(List.empty[Batch]) { (bs, record) =>	2✔
24	val offset = record.partitionOffset.offset	2✔
25
26	def appendsOf(records: Nel[ActionRecord[Action.Append]]) = {
27	Appends(offset, records)	2✔
28	}
29
30	def deleteOf(to: DeleteTo, origin: Option[Origin], version: Option[Version]) = {
31	Delete(offset, to, origin, version)	2✔
32	}
33
34	def purgeOf(origin: Option[Origin], version: Option[Version]) = {
35	Purge(offset, origin, version)	2✔
36	}
37
38	def actionRecord[A <: Action](a: A) = record.copy(action = a)	2✔
39
40	def origin = {
41	bs.foldRight(none[Origin]) { (b, origin) =>	1✔
42	origin orElse {	1✔
43	b match {
44	case b: Batch.Delete => b.origin	1✔
45	case _: Batch.Appends => none	1✔
46	case b: Batch.Purge => b.origin	×
47	}
48	}
49	}
50	}
51
52	def version = {
53	bs.foldRight(none[Version]) { (b, version) =>	1✔
54	version orElse {	1✔
55	b match {
56	case b: Batch.Delete => b.version	1✔
57	case _: Batch.Appends => none	1✔
58	case b: Batch.Purge => b.version	×
59	}
60	}
61	}
62	}
63
64	bs match {
65	case b :: tail => (b, record.action) match {	2✔
66	case (b: Appends, a: Action.Append) =>
67	val records = actionRecord(a) :: b.records	2✔
68	appendsOf(records) :: tail	2✔
69
70	case (b: Appends, _: Action.Mark) =>
71	appendsOf(b.records) :: tail	2✔
72
73	case (b: Appends, a: Action.Delete) =>
74	if (cut(b, a)) {	1✔
75	val delete = deleteOf(a.to, origin orElse a.origin, version orElse a.version)	1✔
76	delete :: Nil	1✔
77	} else {	1✔
78	val delete = deleteOf(a.to, a.origin, a.version)	1✔
79	delete :: bs	1✔
80	}
81
82	case (_: Appends, a: Action.Purge) =>
83	purgeOf(a.origin, a.version) :: Nil	1✔
84
85	case (b: Delete, a: Action.Append) =>
86	appendsOf(Nel.of(actionRecord(a))) :: b :: tail	1✔
87
88	case (b: Delete, _: Action.Mark) =>
89	b.copy(offset = offset) :: tail	2✔
90
91	case (b: Delete, a: Action.Delete) =>
92	if (a.to > b.to) {	1✔
93	if (tail.collectFirst { case b: Appends => cut(b, a) } getOrElse false) {	1✔
94	val delete = deleteOf(a.to, origin orElse a.origin, version orElse a.version)	1✔
95	delete :: Nil	1✔
96	} else {	1✔
97	val delete = deleteOf(a.to, b.origin orElse a.origin, b.version orElse a.version)	1✔
98	delete :: tail	1✔
99	}
100	} else {	1✔
101	val delete = b.copy(	1✔
102	offset = offset,
103	origin = b.origin orElse a.origin,	1✔
104	version = b.version orElse a.version)	1✔
105	delete :: tail	1✔
106	}
107
108	case (_: Delete, a: Action.Purge) =>
109	purgeOf(a.origin, a.version) :: Nil	1✔
110
111	case (b: Purge, a: Action.Append) =>
112	appendsOf(Nel.of(actionRecord(a))) :: b :: Nil	1✔
113
114	case (b: Purge, _: Action.Mark) =>
115	b.copy(offset = offset) :: Nil	1✔
116
117	case (b: Purge, a: Action.Delete) =>
118	deleteOf(a.to, a.origin, a.version) :: b :: Nil	1✔
119
120	case (_: Purge, a: Action.Purge) =>
121	purgeOf(a.origin, a.version) :: Nil	1✔
122	}
123
124	case Nil =>
125	record.action match {	2✔
126	case a: Action.Append => appendsOf(Nel.of(actionRecord(a))) :: Nil	2✔
127	case _: Action.Mark => Nil	2✔
128	case a: Action.Delete => deleteOf(a.to, a.origin, a.version) :: Nil	2✔
129	case a: Action.Purge => purgeOf(a.origin, a.version) :: Nil	2✔
130	}
131	}
132	}
133	.foldLeft(List.empty[Batch]) { (bs, b) =>	2✔
134	b match {
135	case b: Appends => b.copy(records = b.records.reverse) :: bs	2✔
136	case b: Delete => b :: bs	2✔
137	case b: Purge => b :: bs	2✔
138	}
139	}
140	}
141
142
143	final case class Appends(
144	offset: Offset,
145	records: Nel[ActionRecord[Action.Append]]
146	) extends Batch
147
148
149	final case class Delete(
150	offset: Offset,
151	to: DeleteTo,
152	origin: Option[Origin],
153	version: Option[Version]
154	) extends Batch
155
156
157	final case class Purge(
158	offset: Offset,
159	origin: Option[Origin],
160	version: Option[Version]
161	) extends Batch
162	}

evolution-gaming / kafka-journal / 9289360318

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous