Skip to content

Commit 6ea18d7

Browse files
author
MongoCamp CI
committed
ci: update version after release
1 parent 733a2c6 commit 6ea18d7

3 files changed

Lines changed: 92 additions & 50 deletions

File tree

‎package.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
{
22
"name" : "mongodb-driver",
33
"organization" : "dev.mongocamp",
4-
"version" : "3.1.1",
4+
"version" : "3.1.2.snapshot",
55
"author" : "info@mongocamp.dev",
66
"license" : "Apache-2.0",
77
"type" : "module",

‎src/main/scala/dev/mongocamp/driver/mongodb/bson/BsonConverter.scala‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4,16 +4,16 @@ import java.math.BigInteger
44
import java.time.LocalDate
55
import java.time.LocalDateTime
66
import java.time.ZoneId
7+
import java.util.concurrent.TimeUnit
78
import java.util.Date
9+
import org.joda.time.DateTime
810
import org.mongodb.scala.bson._
911
import org.mongodb.scala.bson.BsonArray.fromIterable
1012
import org.mongodb.scala.Document
1113
import scala.collection.mutable
1214
import scala.concurrent.duration.Duration
1315
import scala.jdk.CollectionConverters._
1416
import scala.util.matching.Regex
15-
import org.joda.time.DateTime
16-
import java.util.concurrent.TimeUnit
1717

1818
object BsonConverter {
1919
val DocumentKeyDivider = "."
@@ -112,15 +112,15 @@ object BsonConverter {
112112
}
113113
case v: Any if converterPlugin.hasCustomClass(v) =>
114114
converterPlugin.toBson(v)
115-
case b: Boolean => BsonBoolean(b)
116-
case s: String => BsonString(s)
117-
case c: Char => BsonString(c.toString)
118-
case bytes: Array[Byte] => BsonBinary(bytes)
119-
case r: Regex => BsonRegularExpression(r)
120-
case d: Date => BsonDateTime(d)
121-
case d: DateTime => BsonDateTime(d.toDate)
115+
case b: Boolean => BsonBoolean(b)
116+
case s: String => BsonString(s)
117+
case c: Char => BsonString(c.toString)
118+
case bytes: Array[Byte] => BsonBinary(bytes)
119+
case r: Regex => BsonRegularExpression(r)
120+
case d: Date => BsonDateTime(d)
121+
case d: DateTime => BsonDateTime(d.toDate)
122122
case dt: org.joda.time.Duration => BsonString(scala.concurrent.duration.Duration(dt.getMillis, TimeUnit.MILLISECONDS).toString)
123-
case d: Duration => BsonString(d.toString)
123+
case d: Duration => BsonString(d.toString)
124124
case ld: LocalDate =>
125125
BsonDateTime(Date.from(ld.atStartOfDay(ZoneId.systemDefault()).toInstant))
126126
case ldt: LocalDateTime =>

‎src/main/scala/dev/mongocamp/driver/mongodb/json/CirceSchema.scala‎

Lines changed: 81 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
package dev.mongocamp.driver.mongodb.json
22

33
import dev.mongocamp.driver.mongodb.bson.BsonConverter
4-
import io.circe.Decoder.Result
54
import io.circe._
5+
import io.circe.Decoder.Result
66
import java.util.Date
77
import org.bson.types.ObjectId
88
import org.joda.time.DateTime
@@ -20,10 +20,12 @@ trait CirceSchema extends CirceProductSchema {
2020

2121
override def apply(c: HCursor): Result[org.mongodb.scala.Document] = {
2222
Decoder.decodeString
23-
.map(s => {
24-
val document = new org.mongodb.scala.Document(org.mongodb.scala.bson.BsonDocument(s))
25-
document
26-
})
23+
.map(
24+
s => {
25+
val document = new org.mongodb.scala.Document(org.mongodb.scala.bson.BsonDocument(s))
26+
document
27+
}
28+
)
2729
.apply(c)
2830
}
2931
}
@@ -34,78 +36,98 @@ trait CirceSchema extends CirceProductSchema {
3436
val map = a
3537
.keySet()
3638
.asScala
37-
.map(key => {
38-
val value = a.get(key)
39-
(key, encodeAnyToJson(value))
40-
})
39+
.map(
40+
key => {
41+
val value = a.get(key)
42+
(key, encodeAnyToJson(value))
43+
}
44+
)
4145
.toMap
4246
encodeMapStringAny(map)
4347
}
4448

4549
override def apply(c: HCursor): Result[org.bson.Document] = {
4650
Decoder
4751
.decodeMap[String, Any]
48-
.map(m => {
49-
val document = new org.bson.Document(m.asJava)
50-
document
51-
})
52+
.map(
53+
m => {
54+
val document = new org.bson.Document(m.asJava)
55+
document
56+
}
57+
)
5258
.apply(c)
5359
}
5460
}
5561

5662
implicit val DateFormat: Encoder[Date] with Decoder[Date] = new Encoder[Date] with Decoder[Date] {
5763
override def apply(d: Date): Json = {
5864
Option(d)
59-
.map(date => Encoder.encodeString.apply(date.toInstant.toString))
65+
.map(
66+
date => Encoder.encodeString.apply(date.toInstant.toString)
67+
)
6068
.getOrElse(Json.Null)
6169
}
6270

6371
override def apply(c: HCursor): Result[Date] = {
6472
Decoder.decodeString
65-
.map(s => new DateTime(s).toDate)
73+
.map(
74+
s => new DateTime(s).toDate
75+
)
6676
.apply(c)
6777
}
6878
}
6979

7080
implicit val DateTimeFormat: Encoder[DateTime] with Decoder[DateTime] = new Encoder[DateTime] with Decoder[DateTime] {
7181
override def apply(d: DateTime): Json = {
7282
Option(d)
73-
.map(date => Encoder.encodeString.apply(date.toInstant.toString))
83+
.map(
84+
date => Encoder.encodeString.apply(date.toInstant.toString)
85+
)
7486
.getOrElse(Json.Null)
7587
}
7688

7789
override def apply(c: HCursor): Result[DateTime] = {
7890
Decoder.decodeString
79-
.map(s => new DateTime(s))
91+
.map(
92+
s => new DateTime(s)
93+
)
8094
.apply(c)
8195
}
8296
}
8397

8498
implicit val ObjectIdFormat: Encoder[ObjectId] with Decoder[ObjectId] = new Encoder[ObjectId] with Decoder[ObjectId] {
8599
override def apply(o: ObjectId): Json = {
86100
Option(o)
87-
.map(o => Encoder.encodeString.apply(o.toHexString))
101+
.map(
102+
o => Encoder.encodeString.apply(o.toHexString)
103+
)
88104
.getOrElse(Json.Null)
89105
}
90106

91107
override def apply(c: HCursor): Result[ObjectId] = {
92108
Decoder.decodeString
93-
.map(s => new ObjectId(s))
109+
.map(
110+
s => new ObjectId(s)
111+
)
94112
.apply(c)
95113
}
96114
}
97115

98116
implicit val DurationFormat: Encoder[Duration] with Decoder[Duration] = new Encoder[Duration] with Decoder[Duration] {
99117
override def apply(d: Duration): Json = {
100118
Option(d)
101-
.map(duration => Json.fromString(duration.toString))
119+
.map(
120+
duration => Json.fromString(duration.toString)
121+
)
102122
.getOrElse(Json.Null)
103123
}
104124

105125
override def apply(c: HCursor): Result[Duration] = {
106-
Decoder.decodeString.emap(s =>
107-
scala.util.Try(Duration(s)).toEither.left.map(_.getMessage)
108-
).apply(c)
126+
Decoder.decodeString
127+
.emap(
128+
s => scala.util.Try(Duration(s)).toEither.left.map(_.getMessage)
129+
)
130+
.apply(c)
109131
}
110132
}
111133

@@ -127,15 +149,19 @@ trait CirceSchema extends CirceProductSchema {
127149

128150
override def apply(c: HCursor): Result[Any] = {
129151
Decoder.decodeJson
130-
.map(a => decodeFromJson(a))
152+
.map(
153+
a => decodeFromJson(a)
154+
)
131155
.apply(c)
132156
}
133157
}
134158

135159
def encodeMapStringAny(a: Map[String, Any]): Json = {
136160
Json.obj(
137161
a.keySet
138-
.map(key => (key, encodeAnyToJson(a(key))))
162+
.map(
163+
key => (key, encodeAnyToJson(a(key)))
164+
)
139165
.toList: _*
140166
)
141167
}
@@ -147,7 +173,8 @@ trait CirceSchema extends CirceProductSchema {
147173
val long = value.toLong
148174
if (long.isDefined) {
149175
long.get
150-
} else {
176+
}
177+
else {
151178
value.toDouble
152179
}
153180
case a if a.isString =>
@@ -156,17 +183,23 @@ trait CirceSchema extends CirceProductSchema {
156183
try {
157184
val date = new DateTime(string)
158185
date
159-
} catch {
186+
}
187+
catch {
160188
case _: Exception => string
161189
}
162-
} else {
190+
}
191+
else {
163192
string
164193
}
165194
case a if a.isBoolean => a.asBoolean.getOrElse(false)
166195
case a if a.isArray =>
167-
a.asArray.get.toList.map(e => decodeFromJson(e))
196+
a.asArray.get.toList.map(
197+
e => decodeFromJson(e)
198+
)
168199
case a if a.isObject =>
169-
a.asObject.get.toMap.map(e => (e._1, decodeFromJson(e._2)))
200+
a.asObject.get.toMap.map(
201+
e => (e._1, decodeFromJson(e._2))
202+
)
170203
case a if a.isNull => null
171204
case _ => null
172205
}
@@ -184,7 +217,9 @@ trait CirceSchema extends CirceProductSchema {
184217
case f: Float => Json.fromFloatOrNull(f)
185218
case option: Option[_] =>
186219
option
187-
.map(e => encodeAnyToJson(e, depth))
220+
.map(
221+
e => encodeAnyToJson(e, depth)
222+
)
188223
.getOrElse(Json.Null)
189224
case d: Date => Encoder.encodeString.apply(d.toInstant.toString)
190225
case d: DateTime => Encoder.encodeString.apply(d.toInstant.toString)
@@ -193,33 +228,40 @@ trait CirceSchema extends CirceProductSchema {
193228
case m: Map[String, _] => encodeMapStringAny(m)
194229
case seq: Seq[_] =>
195230
Json.arr(
196-
seq.map(e => encodeAnyToJson(e, depth)): _*
231+
seq.map(
232+
e => encodeAnyToJson(e, depth)
233+
): _*
197234
)
198235
case set: Set[_] =>
199236
Json.arr(
200237
set
201-
.map(e => encodeAnyToJson(e, depth))
238+
.map(
239+
e => encodeAnyToJson(e, depth)
240+
)
202241
.toList: _*
203242
)
204243
case product: Product =>
205244
val productElementKeys = productElementNames(product).toList
206245
val fieldMap = productElementKeys
207-
.map(key => {
208-
val index = productElementKeys.indexOf(key)
209-
(key, product.productElement(index))
210-
})
246+
.map(
247+
key => {
248+
val index = productElementKeys.indexOf(key)
249+
(key, product.productElement(index))
250+
}
251+
)
211252
.toMap
212253
encodeAnyToJson(fieldMap)
213254
case r: Document => encodeAnyToJson(r.toMap)
214255
case any: Any =>
215256
if (depth < 256) {
216257
encodeAnyToJson(any, depth + 1)
217-
} else {
258+
}
259+
else {
218260
Json.Null
219261
}
220262
case _ =>
221263
Json.Null
222264
}
223265
}
224266

225-
}
267+
}

0 commit comments

Comments
 (0)