Skip to content

Commit f3dd28c

Browse files
author
Sven Behrens
committed
Fix compiler warnings
1 parent d424ec9 commit f3dd28c

File tree

2 files changed

+106
-110
lines changed

2 files changed

+106
-110
lines changed

‎render/shared/src/main/scala/plotly/Enumerate.scala

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ sealed abstract class Enumerate[T] {
77
}
88

99
object Enumerate {
10-
def apply[T](implicit enum: Enumerate[T]): Enumerate[T] = enum
10+
def apply[T](implicit enumerate: Enumerate[T]): Enumerate[T] = enumerate
1111

1212
private def instance[T](values: => Seq[T]): Enumerate[T] =
1313
new Enumerate[T] {

‎render/shared/src/main/scala/plotly/internals/ArgonautCodecsInternals.scala

Lines changed: 105 additions & 109 deletions
Original file line numberDiff line numberDiff line change
@@ -17,49 +17,47 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
1717

1818
sealed abstract class IsWrapper[W]
1919

20-
implicit def isWrapperEncode[W, L <: HList, T]
21-
(implicit
22-
ev: IsWrapper[W],
23-
gen: Generic.Aux[W, L],
24-
isHCons: ops.hlist.IsHCons.Aux[L, T, HNil],
25-
underlying: EncodeJson[T]
26-
): EncodeJson[W] =
20+
implicit def isWrapperEncode[W, L <: HList, T](implicit
21+
ev: IsWrapper[W],
22+
gen: Generic.Aux[W, L],
23+
isHCons: ops.hlist.IsHCons.Aux[L, T, HNil],
24+
underlying: EncodeJson[T]
25+
): EncodeJson[W] =
2726
EncodeJson { w =>
2827
val t = isHCons.head(gen.to(w))
2928
t.asJson
3029
}
3130

32-
implicit def isWrapperDecode[W, L <: HList, T]
33-
(implicit
34-
ev: IsWrapper[W],
35-
gen: Generic.Aux[W, L],
36-
isHCons: ops.hlist.IsHCons.Aux[L, T, HNil],
37-
underlying: DecodeJson[T]
38-
): DecodeJson[W] =
31+
implicit def isWrapperDecode[W, L <: HList, T](implicit
32+
ev: IsWrapper[W],
33+
gen: Generic.Aux[W, L],
34+
isHCons: ops.hlist.IsHCons.Aux[L, T, HNil],
35+
underlying: DecodeJson[T]
36+
): DecodeJson[W] =
3937
DecodeJson { c =>
40-
c.as[T].map(t =>
41-
gen.from((t :: HNil).asInstanceOf[L]) // FIXME
42-
)
38+
c.as[T]
39+
.map(t => gen.from((t :: HNil).asInstanceOf[L]) // FIXME
40+
)
4341
}
4442

45-
implicit val boxMeanBoolIsWrapper: IsWrapper[BoxMean.Bool] = null
46-
implicit val boxPointsBoolIsWrapper: IsWrapper[BoxPoints.Bool] = null
47-
implicit val sequenceDoublesIsWrapper: IsWrapper[Sequence.Doubles] = null
43+
implicit val boxMeanBoolIsWrapper: IsWrapper[BoxMean.Bool] = null
44+
implicit val boxPointsBoolIsWrapper: IsWrapper[BoxPoints.Bool] = null
45+
implicit val sequenceDoublesIsWrapper: IsWrapper[Sequence.Doubles] = null
4846
implicit val sequenceNestedDoublesIsWrapper: IsWrapper[Sequence.NestedDoubles] = null
49-
implicit val sequenceNestedIntsIsWrapper: IsWrapper[Sequence.NestedInts] = null
50-
implicit val sequenceStringsIsWrapper: IsWrapper[Sequence.Strings] = null
51-
implicit val sequenceDatetimesIsWrapper: IsWrapper[Sequence.DateTimes] = null
52-
implicit val rangeDoublesIsWrapper: IsWrapper[Range.Doubles] = null
53-
implicit val rangeDatetimesIsWrapper: IsWrapper[Range.DateTimes] = null
54-
implicit val doubleElementIsWrapper: IsWrapper[Element.DoubleElement] = null
55-
implicit val stringElementIsWrapper: IsWrapper[Element.StringElement] = null
56-
implicit def oneOrSeqOneIsWrapper[T]: IsWrapper[OneOrSeq.One[T]] = null
57-
implicit def oneOrSeqSequenceIsWrapper[T]: IsWrapper[OneOrSeq.Sequence[T]] = null
47+
implicit val sequenceNestedIntsIsWrapper: IsWrapper[Sequence.NestedInts] = null
48+
implicit val sequenceStringsIsWrapper: IsWrapper[Sequence.Strings] = null
49+
implicit val sequenceDatetimesIsWrapper: IsWrapper[Sequence.DateTimes] = null
50+
implicit val rangeDoublesIsWrapper: IsWrapper[Range.Doubles] = null
51+
implicit val rangeDatetimesIsWrapper: IsWrapper[Range.DateTimes] = null
52+
implicit val doubleElementIsWrapper: IsWrapper[Element.DoubleElement] = null
53+
implicit val stringElementIsWrapper: IsWrapper[Element.StringElement] = null
54+
implicit def oneOrSeqOneIsWrapper[T]: IsWrapper[OneOrSeq.One[T]] = null
55+
implicit def oneOrSeqSequenceIsWrapper[T]: IsWrapper[OneOrSeq.Sequence[T]] = null
5856

5957
def flagEncoder[T, F](flags: T => Set[F], label: F => String): EncodeJson[T] =
6058
EncodeJson { t =>
6159
val s = flags(t).toSeq match {
62-
case Seq() => "none"
60+
case Seq() => "none"
6361
case nonEmpty => nonEmpty.map(label).mkString("+")
6462
}
6563

@@ -73,12 +71,14 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
7371
if (s == "none")
7472
DecodeResult.ok(Set.empty[F])
7573
else
76-
s.split('+').foldLeft[DecodeResult[Set[F]]](DecodeResult.ok(Set.empty[F])) {
77-
case (acc, f) =>
78-
for {
79-
acc0 <- acc
80-
f0 <- map.get(f).fold[DecodeResult[F]](DecodeResult.fail(s"Unrecognized $type0: $f", c.history))(DecodeResult.ok)
81-
} yield acc0 + f0
74+
s.split('+').foldLeft[DecodeResult[Set[F]]](DecodeResult.ok(Set.empty[F])) { case (acc, f) =>
75+
for {
76+
acc0 <- acc
77+
f0 <-
78+
map
79+
.get(f)
80+
.fold[DecodeResult[F]](DecodeResult.fail(s"Unrecognized $type0: $f", c.history))(DecodeResult.ok)
81+
} yield acc0 + f0
8282
}
8383

8484
flags.map(build)
@@ -94,76 +94,75 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
9494

9595
def instance[T](f: T => String): IsEnum[T] =
9696
new IsEnum[T] {
97-
def label(t: T) = f(t)
97+
def label(t: T): String = f(t)
9898
}
9999
}
100100

101101
implicit def isEnumEncoder[T: IsEnum]: EncodeJson[T] =
102102
EncodeJson.of[String].contramap(IsEnum[T].label)
103103

104-
implicit def isEnumDecoder[T]
105-
(implicit
106-
isEnum: IsEnum[T],
107-
enum: Enumerate[T],
108-
typeable: Typeable[T]
109-
): DecodeJson[T] =
104+
implicit def isEnumDecoder[T](implicit
105+
isEnum: IsEnum[T],
106+
enumerate: Enumerate[T],
107+
typeable: Typeable[T]
108+
): DecodeJson[T] =
110109
DecodeJson {
111110
val underlying = DecodeJson.of[String]
112-
val map = enum().map(e => isEnum.label(e) -> e).toMap
113-
val name = typeable.describe // TODO split in words
111+
val map = enumerate().map(e => isEnum.label(e) -> e).toMap
112+
val name = typeable.describe // TODO split in words
114113

115114
c =>
116115
underlying(c).flatMap { s =>
117116
map.get(s) match {
118-
case None => DecodeResult.fail(s"Unrecognized $name: '$s'", c.history)
117+
case None => DecodeResult.fail(s"Unrecognized $name: '$s'", c.history)
119118
case Some(m) => DecodeResult.ok(m)
120119
}
121120
}
122121
}
123122

124-
implicit val anchorIsEnum = IsEnum.instance[Anchor](_.label)
125-
implicit val refIsEnum = IsEnum.instance[Ref](_.label)
126-
implicit val axisAnchorIsEnum = IsEnum.instance[AxisAnchor](_.label)
127-
implicit val axisReferenceIsEnum = IsEnum.instance[AxisReference](_.label)
128-
implicit val axisTypeIsEnum = IsEnum.instance[AxisType](_.label)
129-
implicit val barModeIsEnum = IsEnum.instance[BarMode](_.label)
130-
implicit val boxModeIsEnum = IsEnum.instance[BoxMode](_.label)
131-
implicit val dashIsEnum = IsEnum.instance[Dash](_.label)
132-
implicit val fillIsEnum = IsEnum.instance[Fill](_.label)
133-
implicit val hoverModeIsEnum = IsEnum.instance[HoverMode](_.label)
134-
implicit val lineShapeIsEnum = IsEnum.instance[LineShape](_.label)
135-
implicit val orientationIsEnum = IsEnum.instance[Orientation](_.label)
136-
implicit val traceOrderIsEnum = IsEnum.instance[TraceOrder](_.label)
137-
implicit val boxMeanOtherIsEnum = IsEnum.instance[BoxMean.Labeled](_.label)
138-
implicit val boxPointsOtherIsEnum = IsEnum.instance[BoxPoints.Labeled](_.label)
139-
implicit val textPositionIsEnum = IsEnum.instance[TextPosition](_.label)
123+
implicit val anchorIsEnum = IsEnum.instance[Anchor](_.label)
124+
implicit val refIsEnum = IsEnum.instance[Ref](_.label)
125+
implicit val axisAnchorIsEnum = IsEnum.instance[AxisAnchor](_.label)
126+
implicit val axisReferenceIsEnum = IsEnum.instance[AxisReference](_.label)
127+
implicit val axisTypeIsEnum = IsEnum.instance[AxisType](_.label)
128+
implicit val barModeIsEnum = IsEnum.instance[BarMode](_.label)
129+
implicit val boxModeIsEnum = IsEnum.instance[BoxMode](_.label)
130+
implicit val dashIsEnum = IsEnum.instance[Dash](_.label)
131+
implicit val fillIsEnum = IsEnum.instance[Fill](_.label)
132+
implicit val hoverModeIsEnum = IsEnum.instance[HoverMode](_.label)
133+
implicit val lineShapeIsEnum = IsEnum.instance[LineShape](_.label)
134+
implicit val orientationIsEnum = IsEnum.instance[Orientation](_.label)
135+
implicit val traceOrderIsEnum = IsEnum.instance[TraceOrder](_.label)
136+
implicit val boxMeanOtherIsEnum = IsEnum.instance[BoxMean.Labeled](_.label)
137+
implicit val boxPointsOtherIsEnum = IsEnum.instance[BoxPoints.Labeled](_.label)
138+
implicit val textPositionIsEnum = IsEnum.instance[TextPosition](_.label)
140139
implicit val barTextPositionIsEnum = IsEnum.instance[BarTextPosition](_.label)
141-
implicit val sideIsEnum = IsEnum.instance[Side](_.label)
142-
implicit val symbolIsEnum = IsEnum.instance[Symbol](_.label)
143-
implicit val ticksIsEnum = IsEnum.instance[Ticks](_.label)
144-
implicit val histNormIsEnum = IsEnum.instance[HistNorm](_.label)
145-
implicit val sizeModeIsEnum = IsEnum.instance[SizeMode](_.label)
146-
implicit val hoverOnIsEnum = IsEnum.instance[HoverOn](_.label)
147-
implicit val groupNormIsEnum = IsEnum.instance[GroupNorm](_.label)
148-
implicit val histFuncIsEnum = IsEnum.instance[HistFunc](_.label)
149-
implicit val tickModeIsEnum = IsEnum.instance[TickMode](_.mode)
150-
implicit val patternIsEnum = IsEnum.instance[Pattern](_.label)
151-
implicit val rowOrderIsEnum = IsEnum.instance[RowOrder](_.label)
152-
implicit val alignmentIsEnum = IsEnum.instance[Alignment](_.label)
153-
implicit val colorModelIsEnum = IsEnum.instance[ColorModel](_.label)
140+
implicit val sideIsEnum = IsEnum.instance[Side](_.label)
141+
implicit val symbolIsEnum = IsEnum.instance[Symbol](_.label)
142+
implicit val ticksIsEnum = IsEnum.instance[Ticks](_.label)
143+
implicit val histNormIsEnum = IsEnum.instance[HistNorm](_.label)
144+
implicit val sizeModeIsEnum = IsEnum.instance[SizeMode](_.label)
145+
implicit val hoverOnIsEnum = IsEnum.instance[HoverOn](_.label)
146+
implicit val groupNormIsEnum = IsEnum.instance[GroupNorm](_.label)
147+
implicit val histFuncIsEnum = IsEnum.instance[HistFunc](_.label)
148+
implicit val tickModeIsEnum = IsEnum.instance[TickMode](_.mode)
149+
implicit val patternIsEnum = IsEnum.instance[Pattern](_.label)
150+
implicit val rowOrderIsEnum = IsEnum.instance[RowOrder](_.label)
151+
implicit val alignmentIsEnum = IsEnum.instance[Alignment](_.label)
152+
implicit val colorModelIsEnum = IsEnum.instance[ColorModel](_.label)
154153

155154
def jsonSumDirectCodecFor(name: String): JsonSumCodec = new JsonSumCodec {
156155
def encodeEmpty: Nothing =
157156
throw new IllegalArgumentException(s"empty $name")
158157

159158
def encodeField(fieldOrObj: Either[Json, (String, Json)]): Json =
160159
fieldOrObj match {
161-
case Left(other) => other
160+
case Left(other) => other
162161
case Right((_, content)) => content
163162
}
164163

165164
def decodeEmpty(cursor: HCursor): DecodeResult[Nothing] =
166-
// FIXME Sometimes reports the wrong error (in case of two nested sum types)
165+
// FIXME Sometimes reports the wrong error (in case of two nested sum types)
167166
DecodeResult.fail(s"unrecognized $name", cursor.history)
168167

169168
def decodeField[A](name: String, cursor: HCursor, decode: DecodeJson[A]): DecodeResult[Either[ACursor, A]] =
@@ -175,7 +174,7 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
175174
}
176175

177176
case class JsonProductObjCodecNoEmpty(
178-
toJsonName: String => String = identity
177+
toJsonName: String => String = identity
179178
) extends JsonProductCodec {
180179

181180
private val underlying = JsonProductCodec.adapt(toJsonName)
@@ -194,7 +193,12 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
194193
cursor.history
195194
)
196195

197-
def decodeField[A](name: String, cursor: HCursor, decode: DecodeJson[A], default: Option[A]): DecodeResult[(A, ACursor)] = {
196+
def decodeField[A](
197+
name: String,
198+
cursor: HCursor,
199+
decode: DecodeJson[A],
200+
default: Option[A]
201+
): DecodeResult[(A, ACursor)] = {
198202
val c = cursor.downField(toJsonName(name))
199203

200204
def result = c.as(decode).map((_, if (c.succeeded) c.delete else ACursor.ok(cursor)))
@@ -219,18 +223,18 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
219223
implicit val decodeHoverInfo: DecodeJson[HoverInfo] =
220224
DecodeJson { c =>
221225
DecodeJson.of[String].apply(c).flatMap {
222-
case "all" => DecodeResult.ok(HoverInfo.All)
226+
case "all" => DecodeResult.ok(HoverInfo.All)
223227
case "skip" => DecodeResult.ok(HoverInfo.Skip)
224228
case "none" => DecodeResult.ok(HoverInfo.None)
225229
case combination =>
226230
val results = combination.split('+').map {
227-
case "x" => Right(HoverInfo.X)
228-
case "y" => Right(HoverInfo.Y)
229-
case "z" => Right(HoverInfo.Z)
231+
case "x" => Right(HoverInfo.X)
232+
case "y" => Right(HoverInfo.Y)
233+
case "z" => Right(HoverInfo.Z)
230234
case "color" => Right(HoverInfo.Color)
231-
case "text" => Right(HoverInfo.Text)
232-
case "name" => Right(HoverInfo.Name)
233-
case other => Left(s"Unrecognized hover info element: $other")
235+
case "text" => Right(HoverInfo.Text)
236+
case "name" => Right(HoverInfo.Name)
237+
case other => Left(s"Unrecognized hover info element: $other")
234238
}
235239
if (results.exists(_.isLeft))
236240
DecodeResult.fail(
@@ -242,7 +246,6 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
242246
}
243247
}
244248

245-
246249
implicit def defaultJsonProductCodecFor[T]: JsonProductCodecFor[T] =
247250
JsonProductCodecFor(JsonProductObjCodecNoEmpty.default)
248251

@@ -256,9 +259,9 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
256259
s.stripPrefix("rgba(").stripSuffix(")").split(',').map(_.trim) match {
257260
case Array(rStr, gStr, bStr, alphaStr) =>
258261
val res = for {
259-
r <- Try(rStr.toInt).toOption
260-
g <- Try(gStr.toInt).toOption
261-
b <- Try(bStr.toInt).toOption
262+
r <- Try(rStr.toInt).toOption
263+
g <- Try(gStr.toInt).toOption
264+
b <- Try(bStr.toInt).toOption
262265
alpha <- Try(alphaStr.toDouble).toOption
263266
} yield DecodeResult.ok(Color.RGBA(r, g, b, alpha))
264267

@@ -279,15 +282,14 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
279282
implicit val decodeStringColor: DecodeJson[Color.StringColor] =
280283
DecodeJson {
281284
val underlying = DecodeJson.of[String]
282-
val map = Color.StringColor.colors
283-
.toVector
285+
val map = Color.StringColor.colors.toVector
284286
.map(c => c -> Color.StringColor(c))
285287
.toMap
286288

287289
c =>
288290
underlying(c).flatMap { s =>
289291
map.get(s) match {
290-
case None => DecodeResult.fail(s"Unrecognized color: '$s'", c.history)
292+
case None => DecodeResult.fail(s"Unrecognized color: '$s'", c.history)
291293
case Some(m) => DecodeResult.ok(m)
292294
}
293295
}
@@ -340,25 +342,21 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
340342
DecodeResult.fail(s"Unrecognized RGB color: $other", c.history)
341343
}
342344

343-
asString
344-
.toOption
345+
asString.toOption
345346
.orElse(asInt.toOption)
346347
.fold(asHexa)(DecodeResult.ok)
347348
}
348349

349350
private def decodeNum(s: String) = {
350351

351-
val intOpt = Try(s.toInt)
352-
.toOption
352+
val intOpt = Try(s.toInt).toOption
353353

354-
val fromDouble = Try(s.toDouble)
355-
.toOption
354+
val fromDouble = Try(s.toDouble).toOption
356355
.map(_.toInt)
357356

358357
def fromPct =
359358
if (s.endsWith("%"))
360-
Try(s.stripSuffix("%").trim.toDouble)
361-
.toOption
359+
Try(s.stripSuffix("%").trim.toDouble).toOption
362360
.map(v => (256 * v).toInt)
363361
else
364362
None
@@ -457,12 +455,12 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
457455
implicit val encodeError: EncodeJson[Error] =
458456
EncodeJson { error =>
459457
val json = error match {
460-
case data: Error.Data => data.asJson
461-
case pct: Error.Percent => pct.asJson
458+
case data: Error.Data => data.asJson
459+
case pct: Error.Percent => pct.asJson
462460
case cst: Error.Constant => cst.asJson
463461
}
464462

465-
json.obj.fold(json)(o => Json.jObject(("type" -> error.`type`.asJson) +: o))
463+
json.obj.fold(json)(o => Json.jObject(("type" -> error.`type`.asJson) +: o))
466464
}
467465

468466
implicit val decodeError: DecodeJson[Error] =
@@ -488,15 +486,13 @@ object ArgonautCodecsInternals extends ArgonautCodecsExtra {
488486
implicit val jsonSumCodecForColor: JsonSumCodecFor[Color] =
489487
JsonSumCodecFor(jsonSumDirectCodecFor("color"))
490488

491-
492489
case class WrappedFont(font: Font)
493-
val derivedFontDecoder = MkDecodeJson[Font].decodeJson
490+
val derivedFontDecoder = MkDecodeJson[Font].decodeJson
494491
lazy val wrappedFontDecoder = DecodeJson.of[WrappedFont].map(_.font)
495492

496493
implicit lazy val decodeFont: DecodeJson[Font] =
497-
DecodeJson {
498-
c =>
499-
wrappedFontDecoder(c).toOption.fold(derivedFontDecoder(c))(DecodeResult.ok)
494+
DecodeJson { c =>
495+
wrappedFontDecoder(c).toOption.fold(derivedFontDecoder(c))(DecodeResult.ok)
500496
}
501497

502498
implicit val jsonCodecForTrace = JsonSumCodecFor[Trace](

0 commit comments

Comments
 (0)