Release/v1.1.0

.github/workflows/test-ci.yml

@@ -0,0 +1,28 @@
+name: test ci
+
+on:
+  pull_request:
+    branches: [ master, develop ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up JDK
+        uses: actions/setup-java@v2
+        with:
+          java-version: '11'
+          distribution: 'temurin'
+
+      - name: Assemble
+        run: ./gradlew assemble
+
+      - name: Tests
+        run: ./gradlew test
+
+      - name: Publish
+        run: ./gradlew publishToMavenLocal

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Irineu A. Silva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,80 @@
+# Resource [![](https://jitpack.io/v/Irineu333/Resource.svg) ](https://jitpack.io/#Irineu333/Highlight)
+
+Complete solution for handling success, failure, and loading states in Kotlin.
+
+## Loading
+
+Use the sealed class [`Resource`](src/main/kotlin/Resource.kt) with loading states.
+
+``` kotlin
+ordersRepository.flow.collect { resource ->
+    when (resource) {
+        is Resource.Result.Failure -> //...
+        is Resource.Result.Success -> //...
+        Resource.Loading -> //...
+    }
+}
+```
+
+## Result
+
+If the possible states are success and error, the ideal class is `Resource.Result`.
+
+``` kotlin
+when (ordersRepository.getOrders()) {
+    is Resource.Result.Failure -> //...
+    is Resource.Result.Success -> //...
+}
+```
+
+## Extensions
+
+The library comes with some basi basic [extensions](src/main/kotlin/extension/Resource.kt) to handle and
+manipulate the states.
+
+## kotlin.Result
+
+Integration with kotlin Result.
+
+``` kotlin
+suspend fun getOrders(): Resource.Result<List<Order>, String> {
+    val result = runCatching {
+        service.getOrders()
+    }.toResource()
+
+    return result.mapError {
+        it.message ?: ""
+    }.ifFailure {
+        logger.send("error: $it")
+    }.ifSuccess {
+        logger.send("success: $it")
+    }
+}
+```
+
+## Releases
+
+Add the jitpack to project in `build.gradle.kts` or `settings.gradle.kts`:
+
+``` kotlin
+repositories { 
+
+    maven { url = uri("https://jitpack.io") }
+}
+```
+
+Add the dependence to module:
+
+``` kotlin
+implementation("com.github.NeoUtils:Resource:{version}")
+```
+
+## License
+```
+Copyright (c) 2023 Irineu A. Silva
+
+This project is licensed under the terms of the MIT License, 
+a permissive open-source license that allows for the use, modification, 
+and distribution of the code, provided that copyright notices and 
+the license statement are included in all copies or modifications. 
+```

build.gradle.kts

@@ -5,30 +5,34 @@ plugins {
 }
 
 group = "com.neo.resource"
-version = "1.0"
+version = "1.1.0"
 
 repositories {
     mavenCentral()
 }
 
 dependencies {
     testImplementation(kotlin("test"))
+    testImplementation("io.mockk:mockk:1.13.8")
 }
 
 tasks.test {
     useJUnitPlatform()
 }
 
 kotlin {
-    jvmToolchain(8)
+    jvmToolchain {
+        languageVersion.set(JavaLanguageVersion.of(11))
+        vendor.set(JvmVendorSpec.ORACLE)
+    }
 }
 
 publishing {
     publications {
         create<MavenPublication>("maven") {
             groupId = "com.neo.resource"
             artifactId = "resource"
-            version = "1.0"
+            version = "1.1.0"
 
             from(components["java"])
         }

src/main/kotlin/extension/Resource.kt

@@ -12,30 +12,30 @@ fun <T, E> Resource.Result<T, E>.asResource() = this as Resource<T, E>
 
 // map
 
-inline fun <T, E, T2> Resource<T, E>.mapSuccess(
+fun <T, E, T2> Resource<T, E>.mapSuccess(
     transform: (T) -> T2
 ) = when (this) {
     is Resource.Result.Failure -> Resource.Result.Failure(error)
     is Resource.Result.Success -> Resource.Result.Success(transform(data))
     Resource.Loading -> Resource.Loading
 }
 
-inline fun <T, E, T2> Resource.Result<T, E>.mapSuccess(
+fun <T, E, T2> Resource.Result<T, E>.mapSuccess(
     transform: (T) -> T2
 ) = when (this) {
     is Resource.Result.Failure -> Resource.Result.Failure(error)
     is Resource.Result.Success -> Resource.Result.Success(transform(data))
 }
 
-inline fun <T, E, E2> Resource<T, E>.mapError(
+fun <T, E, E2> Resource<T, E>.mapError(
     transform: (E) -> E2
 ) = when (this) {
     is Resource.Result.Failure -> Resource.Result.Failure(transform(error))
     is Resource.Result.Success -> Resource.Result.Success(data)
     Resource.Loading -> Resource.Loading
 }
 
-inline fun <T, E, E2> Resource.Result<T, E>.mapError(
+fun <T, E, E2> Resource.Result<T, E>.mapError(
     transform: (E) -> E2
 ) = when (this) {
     is Resource.Result.Failure -> Resource.Result.Failure(transform(error))
@@ -52,6 +52,12 @@ inline fun <T, E> Resource<T, E>.ifSuccess(
     }
 }
 
+inline fun <T, E> Resource.Result<T, E>.ifSuccess(
+    onSuccess: (T) -> Unit,
+) = apply {
+    asResource().ifSuccess(onSuccess)
+}
+
 inline fun <T, E> Resource<T, E>.ifFailure(
     onError: (E) -> Unit,
 ) = apply {
@@ -60,6 +66,12 @@ inline fun <T, E> Resource<T, E>.ifFailure(
     }
 }
 
+inline fun <T, E> Resource.Result<T, E>.ifFailure(
+    onError: (E) -> Unit,
+) = apply {
+    asResource().ifFailure(onError)
+}
+
 inline fun <T, E> Resource<T, E>.ifLoading(
     onLoading: () -> Unit,
 ) = apply {