style: apply spotless

Author: levinzonr

demo/src/main/java/io/monstarlab/mosaic/features/SliderDemo.kt

@@ -39,8 +39,8 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import io.monstarlab.mosaic.slider.Slider
 import io.monstarlab.mosaic.slider.SliderColors
-import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
 import io.monstarlab.mosaic.slider.distribution.CheckPointsValueDistribution
+import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
 import kotlin.math.roundToInt
 import androidx.compose.material3.Slider as MaterialSlider
 

slider/src/main/java/io/monstarlab/mosaic/slider/MathUtils.kt

@@ -18,4 +18,4 @@ internal fun Float.fractionToValue(rangeStart: Float, rangeEnd: Float): Float =
     scale(0f, 1f, this.coerceIn(0f, 1f), rangeStart, rangeEnd)
 
 internal fun Float.fractionToValue(range: ClosedFloatingPointRange<Float>): Float =
-    scale(0f, 1f, this, range.start, range.endInclusive)
+    scale(0f, 1f, this, range.start, range.endInclusive)

slider/src/main/java/io/monstarlab/mosaic/slider/SliderState.kt

@@ -65,12 +65,13 @@ public class SliderState(
      * the "real" position of the thumb
      */
     internal val offsetAsFraction: Float
-        get() = if (totalWidth == 0f) 0f else {
+        get() = if (totalWidth == 0f) {
+            0f
+        } else {
             val valueFraction = value.valueToFraction(range)
-            valueDistribution.inverse(valueFraction).coerceIn(0f,1f)
+            valueDistribution.inverse(valueFraction).coerceIn(0f, 1f)
         }
 
-
     internal val disabledRangeAsFractions: ClosedFloatingPointRange<Float>
         get() = coerceRangeIntoFractions(disabledRange)
 
@@ -127,7 +128,9 @@ public class SliderState(
      */
     private fun scaleToOffset(value: Float): Float {
         val valueAsFraction = coerceUserValue(value).valueToFraction(range)
-        return valueDistribution.inverse(valueAsFraction).fractionToValue(0f, totalWidth)
+        return valueDistribution
+            .inverse(valueAsFraction)
+            .fractionToValue(0f, totalWidth)
     }
 
     internal fun coerceUserValue(value: Float): Float {
@@ -137,10 +140,11 @@ public class SliderState(
     }
 
     private fun Float.coerceIntoDisabledRange(): Float {
-        if (disabledRange.isEmpty() || !disabledRange.contains(this)) return this
-        if (this - disabledRange.start < disabledRange.endInclusive - this) disabledRange.start else disabledRange.endInclusive
-        // check if disabled range is on the left or right
+        if (disabledRange.isEmpty() || !disabledRange.contains(this)) {
+            return this
+        }
 
+        // check if disabled range is on the left or right
         return if (disabledRange.start == range.start) {
             coerceAtLeast(disabledRange.endInclusive)
         } else {

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/CheckPointsValueDistribution.kt

@@ -3,7 +3,7 @@ package io.monstarlab.mosaic.slider.distribution
 import io.monstarlab.mosaic.slider.valueToFraction
 
 public class CheckPointsValueDistribution(
-    valuesMap: List<Pair<Float, Float>>
+    valuesMap: List<Pair<Float, Float>>,
 ) :
     SliderValueDistribution {
 
@@ -42,25 +42,22 @@ public class CheckPointsValueDistribution(
         }
     }
 
-
     override fun interpolate(value: Float): Float {
         val equation = equations.firstOrNull { it.offsetRange.contains(value) }?.equation
         checkNotNull(equation) { "No equation found for value $value during interpolate" }
         return equation.valueFromOffset(value)
     }
 
-
     override fun inverse(value: Float): Float {
         val equation = equations.firstOrNull { it.valueRange.contains(value) }?.equation
         checkNotNull(equation) { "No equation found for value $value during inverse" }
         return equation.offsetFromValue(value)
     }
 
-
     public class DecreasingValueException(progressValuePair: Pair<Float, Float>) :
         IllegalStateException(
             "Values must be always increasing with increasing progress," +
-                    " item at progress ${progressValuePair.first}  with value " +
-                    "${progressValuePair.second} is breaking this rule "
+                " item at progress ${progressValuePair.first}  with value " +
+                "${progressValuePair.second} is breaking this rule ",
         )
-}
+}

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/LinearEquation.kt

@@ -9,10 +9,7 @@ public data class LinearEquation(
     public fun offsetFromValue(value: Float): Float = (value - c) / m
 
     public companion object {
-        public fun fromTwoPoints(
-            x1: Float, y1: Float,
-            x2: Float, y2: Float
-        ): LinearEquation {
+        public fun fromTwoPoints(x1: Float, y1: Float, x2: Float, y2: Float): LinearEquation {
             require(x2 != x1) { "can't calc equation from points with similar x value" }
             val slope = (y2 - y1) / (x2 - x1)
             val c = y2 - slope * x2

slider/src/main/java/io/monstarlab/mosaic/slider/distribution/SliderValueDistribution.kt

@@ -1,7 +1,6 @@
 package io.monstarlab.mosaic.slider.distribution
 
 import androidx.annotation.FloatRange
-import kotlin.math.sqrt
 
 /**
  * Determines how the values will be distributed across the slider
@@ -36,11 +35,7 @@ public interface SliderValueDistribution {
          * @param c constant term in the parabolic equation
          * @return a [SliderValueDistribution] instance with a parabolic distribution strategy
          */
-        public fun parabolic(
-            a: Float,
-            b: Float = 0f,
-            c: Float = 0f,
-        ): SliderValueDistribution {
+        public fun parabolic(a: Float, b: Float = 0f, c: Float = 0f): SliderValueDistribution {
             return ParabolicValueDistribution(a, b, c)
         }
 

slider/src/test/java/io/monstarlab/mosaic/slider/CheckPointsValueDistributionTest.kt

@@ -1,27 +1,26 @@
 package io.monstarlab.mosaic.slider
 
 import io.monstarlab.mosaic.slider.distribution.CheckPointsValueDistribution
-import org.junit.Assert.*
-
 import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
 import org.junit.Before
 import org.junit.Test
 
 class CheckPointsValueDistributionTest {
 
-    private  lateinit var checkPointsValueDistribution : CheckPointsValueDistribution
+    private lateinit var checkPointsValueDistribution: CheckPointsValueDistribution
     private val accuracy = 0.0001f
 
     @Before
     fun setUp() {
-
-        checkPointsValueDistribution =  CheckPointsValueDistribution(
+        checkPointsValueDistribution = CheckPointsValueDistribution(
             listOf(
                 0f to 0f,
                 25f to 25f,
                 50f to 75f,
                 100f to 100f,
-            )
+            ),
         )
     }
 
@@ -38,15 +37,13 @@ class CheckPointsValueDistributionTest {
                     5f to 10f,
                     8f to 16f,
                     7f to 20f,
-                )
+                ),
             )
         }
-
     }
 
     @Test
     fun `create from pairs and interpolate`() {
-
         val points = listOf(
             0.1f to 0.1f,
             0.2f to 0.2f,
@@ -58,12 +55,10 @@ class CheckPointsValueDistributionTest {
         points.forEach {
             assertEquals(it.second, checkPointsValueDistribution.interpolate(it.first), accuracy)
         }
-
     }
 
     @Test
     fun `create from pairs and inverse`() {
-
         val points = listOf(
             0.1f to 0.1f,
             0.2f to 0.2f,
@@ -75,6 +70,5 @@ class CheckPointsValueDistributionTest {
         points.forEach {
             assertEquals(it.first, checkPointsValueDistribution.inverse(it.second), accuracy)
         }
-
     }
-}
+}