Released 1.9.6-b6. #89

.gitattributes

@@ -0,0 +1 @@
+*.bat eol=crlf

.travis.yml

@@ -3,7 +3,7 @@ jdk:
   - oraclejdk8
 
 install: ./gradlew assemble install -x dokka -x dokkaJavadoc
-script: ./gradlew check -x dokka -x dokkaJavadoc
+script: ./gradlew check
 
 before_cache:
   - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock

CHANGELOG.md

@@ -1,3 +1,13 @@
+#### 1.9.6-b6
+
+- **[UPDATE]** Updated to Gradle 4.0.
+- **[UPDATE]** Updated to Ashley 1.7.3.
+- **[CHANGE]** (`ktx-ashley`) Extensions updated to support `Engine` base class additionally to the `PooledEngine`.
+  - `Engine.add` and `Engine.entity` extension methods to replace `PooledEngine` equivalents.
+  - Changed `PooledEntity` to `EngineEntity`, wrapping `Entity` and providing access to `Engine` API.
+- **[CHANGE]** (`ktx-async`) `TextAssetLoader` now extends `AsynchronousAssetLoader` instead of `SynchronousAssetLoader`.
+- **[FIX]** (`ktx-async`) `AssetStorage` now correctly handles `SynchronousAssetLoader` instances on the main rendering thread.
+
 #### 1.9.6-b5
 
 - **[UPDATE]** Updated to Kotlin 1.1.2-5.

actors/build.gradle

@@ -1,4 +1,4 @@
 dependencies {
-    testCompile "com.badlogicgames.gdx:gdx-backend-lwjgl:$gdxVersion"
-    testCompile "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-desktop"
+  testCompile "com.badlogicgames.gdx:gdx-backend-lwjgl:$gdxVersion"
+  testCompile "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-desktop"
 }

app/src/main/kotlin/ktx/app/application.kt

@@ -19,7 +19,7 @@ abstract class KotlinApplication(protected val fixedTimeStep: Float = 1f / 60f,
    * since the last [render] call in case of subsequent [render] calls on devices unable to run the application at the
    * chosen time step rate.*/
   protected var timeSinceLastRender = 0f
-                private set
+    private set
 
   override fun resize(width: Int, height: Int) {
   }

ashley/README.md

@@ -13,8 +13,8 @@ builder DSL.
 
 `ktx-ashley` provides the following extensions and utilities:
 
-- `PooledEngine.add` and `PooledEngine.entity` extension methods provide type-safe building DSL for creating pooled `Entities`.
-- `PooledEntity` is an `Entity` wrapper that allows to create `Component` instances using using the `PooledEngine` via
+- `Engine.add` and `Engine.entity` extension methods provide type-safe building DSL for creating `Entities`.
+- `EngineEntity` is an `Entity` wrapper that allows to create `Component` instances using using the `Engine` via
 `with` methods.
 - `mapperFor` factory method allows to create `ComponentMapper` instances.
 - Accessors for `Entity` objects using `ComponentMappers`: `get`, `has`, `hasNot`, `remove`.

ashley/src/main/kotlin/ktx/ashley/engines.kt

@@ -0,0 +1,81 @@
+package ktx.ashley
+
+import com.badlogic.ashley.core.Component
+import com.badlogic.ashley.core.Engine
+import com.badlogic.ashley.core.Entity
+
+/**
+ * Get or create a [Component] by calling [Engine.createComponent].
+ *
+ * @param T the type of [Component] to get or create.
+ * @param configure inlined function with [T] as the receiver to allow further configuration.
+ * @return an [Component] instance of the selected type.
+ */
+inline fun <reified T : Component> Engine.create(configure: T.() -> Unit): T = create<T>().also(configure)
+
+/**
+ * Get or create a [Component] by calling [Engine.createComponent].
+ *
+ * @param T the type of [Component] to get or create.
+ * @return an [Component] instance of the selected type.
+ */
+inline fun <reified T : Component> Engine.create(): T = createComponent(T::class.java)
+
+/**
+ * An [Entity] created by the provided [Engine].
+ *
+ * Provides methods for adding [Component]s to the [Engine] and the [Entity].
+ *
+ * @property engine the [Engine] providing [Components][Component].
+ * @property entity the [Entity] to add [Components][Component] to.
+ */
+@AshleyDsl
+class EngineEntity(
+    val engine: Engine,
+    val entity: Entity) {
+  /**
+   * Get or creates an instance of the component [T] and adds it to this [entity][EngineEntity].
+   *
+   * @param T the [Component] type to get or create.
+   * @param configure inlined function with [T] as the receiver to allow additional configuration of the [Component].
+   * @return the created ƒ[Component].
+   * @see [create]
+   */
+  inline fun <reified T : Component> with(configure: (@AshleyDsl T).() -> Unit): T = with<T>().also(configure)
+
+  /**
+   * Get or creates an instance of the component [T] and adds it to this [entity][EngineEntity].
+   *
+   * @param T the [Component] type to get or create.
+   * @return the created [Component].
+   * @see [create]
+   */
+  inline fun <reified T : Component> with(): T {
+    val component = engine.create<T>()
+    entity.add(component)
+    return component
+  }
+}
+
+/**
+ * Builder function for [Engine].
+ *
+ * @param configure inlined function with *this* [Engine] as the receiver to allow further configuration.
+ */
+inline fun Engine.add(configure: (@AshleyDsl Engine).() -> Unit) {
+  configure(this)
+}
+
+/**
+ * Create and add an [Entity] to the [Engine].
+ *
+ * @param configure inlined function with the created [Entity] as the receiver to allow further configuration of
+ *  the [Entity]. The [Entity] holds the [Entity] created and the [Engine] that created it.
+ * @return the created [Entity].
+ */
+inline fun Engine.entity(configure: EngineEntity.() -> Unit): Entity {
+  val entity = createEntity()
+  configure(EngineEntity(this, entity))
+  addEntity(entity)
+  return entity
+}

ashley/src/test/kotlin/ktx/ashley/ComponentMappersSpec.kt

@@ -6,7 +6,7 @@ import org.jetbrains.spek.api.Spek
 import org.jetbrains.spek.api.dsl.describe
 import org.jetbrains.spek.api.dsl.it
 
-object ComponentMappersSpec: Spek({
+object ComponentMappersSpec : Spek({
   describe("utilities for component mappers") {
     val entity = Entity().apply {
       add(Texture())

ashley/src/test/kotlin/ktx/ashley/PooledEnginesSpec.kt → ashley/src/test/kotlin/ktx/ashley/EnginesSpec.kt

@@ -6,8 +6,8 @@ import org.jetbrains.spek.api.Spek
 import org.jetbrains.spek.api.dsl.describe
 import org.jetbrains.spek.api.dsl.it
 
-object PooledEnginesSpec : Spek({
-  describe("utilities for pooled engines") {
+object EnginesSpec : Spek({
+  describe("utilities for engines") {
     val engine by memoized {
       PooledEngine()
     }

ashley/src/test/kotlin/ktx/ashley/FamiliesSpec.kt

@@ -6,7 +6,7 @@ import org.jetbrains.spek.api.Spek
 import org.jetbrains.spek.api.dsl.describe
 import org.jetbrains.spek.api.dsl.it
 
-object FamiliesSpec: Spek({
+object FamiliesSpec : Spek({
   describe("utilities for component families") {
     val textureEntity = Entity().apply {
       add(Texture())

ashley/src/test/kotlin/ktx/ashley/RigidBody.kt

@@ -2,4 +2,4 @@ package ktx.ashley
 
 import com.badlogic.ashley.core.Component
 
-class RigidBody: Component
+class RigidBody : Component

ashley/src/test/kotlin/ktx/ashley/Texture.kt

@@ -3,7 +3,7 @@ package ktx.ashley
 import com.badlogic.ashley.core.Component
 import com.badlogic.ashley.core.ComponentMapper
 
-class Texture: Component {
+class Texture : Component {
   companion object {
     val mapper = ComponentMapper.getFor(Texture::class.java)!!
   }

ashley/src/test/kotlin/ktx/ashley/Transform.kt

@@ -3,7 +3,7 @@ package ktx.ashley
 import com.badlogic.ashley.core.Component
 import com.badlogic.ashley.core.ComponentMapper
 
-class Transform(var x:Float = 0f, var y: Float = 0f) : Component {
+class Transform(var x: Float = 0f, var y: Float = 0f) : Component {
   companion object {
     val mapper = ComponentMapper.getFor(Transform::class.java)!!
   }

async/src/main/kotlin/ktx/async/assets/assets.kt

@@ -169,13 +169,9 @@ class AssetStorage(
     return file
   }
 
-  private suspend fun <Asset : Any> loadWithSynchronousLoader(
+  private fun <Asset : Any> loadWithSynchronousLoader(
       synchronousLoader: SynchronousLoader<Asset>,
-      descriptor: AssetDescriptor<Asset>): Asset =
-      KtxAsync.asynchronous(executor) {
-        // Yes, LibGDX AssetManager handles SynchronousAssetLoader loading on a separate thread. Go figure.
-        synchronousLoader.load(asAssetManager, descriptor)
-      }
+      descriptor: AssetDescriptor<Asset>): Asset = synchronousLoader.load(asAssetManager, descriptor)
 
   private suspend fun <Asset : Any> loadWithAsynchronousLoader(
       asynchronousLoader: AsynchronousLoader<Asset>,

async/src/main/kotlin/ktx/async/assets/loaders.kt

@@ -89,20 +89,36 @@ internal class AssetLoaderStorage {
 }
 
 /**
- * Allows to read text files with an [AssetManager] or an [AssetStorage].
+ * Allows to read text files with an [AssetManager] or an [AssetStorage]. Note that [loadAsync] _must_ be called before
+ * [loadSync], as usual in case of [AsynchronousAssetLoader] implementations. The loader is not considered thread-safe
+ * and assumes that a single file is loaded at a time.
  * @param fileResolver not used, required by the superclass.
  * @param charset name of the charset used to read text. Can be overridden with [TextAssetLoaderParameters]. Should
  *    match text files encoding. Defaults to UTF-8.
  */
 class TextAssetLoader(
     fileResolver: FileHandleResolver,
     private val charset: String = "UTF-8"
-) : SynchronousAssetLoader<String, TextAssetLoaderParameters>(fileResolver) {
-  override fun load(
+) : AsynchronousAssetLoader<String, TextAssetLoaderParameters>(fileResolver) {
+  @Volatile var fileContent: String? = null
+
+  override fun loadAsync(
       assetManager: AssetManager?,
       fileName: String?,
       file: FileHandle,
-      parameter: TextAssetLoaderParameters?): String = file.readString(parameter?.charset ?: charset)
+      parameter: TextAssetLoaderParameters?) {
+    fileContent = file.readString(parameter?.charset ?: charset)
+  }
+
+  override fun loadSync(
+      assetManager: AssetManager?,
+      fileName: String?,
+      file: FileHandle,
+      parameter: TextAssetLoaderParameters?): String = try {
+    fileContent ?: throw AssetStorageException("File $fileName was not loaded asynchronously. Call #loadAsync first.")
+  } finally {
+    fileContent = null
+  }
 
   override fun getDependencies(fileName: String?, file: FileHandle?, parameter: TextAssetLoaderParameters?):
       GdxArray<AssetDescriptor<Any>>? = null

async/src/test/kotlin/ktx/async/assets/loadersTest.kt

@@ -10,6 +10,7 @@ import com.badlogic.gdx.files.FileHandle
 import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.mock
 import com.nhaarman.mockito_kotlin.verify
+import io.kotlintest.matchers.shouldThrow
 import ktx.async.assets.TextAssetLoader.TextAssetLoaderParameters
 import org.junit.Assert.*
 import org.junit.Test
@@ -143,7 +144,8 @@ class TextAssetLoaderTest {
       on(it.readString("UTF-8")) doReturn "Content."
     }
 
-    val result = loader.load(mock(), "test.txt", file, null)
+    loader.loadAsync(mock(), "test.txt", file, null)
+    val result = loader.loadSync(mock(), "test.txt", file, null)
 
     assertEquals("Content.", result)
     verify(file).readString("UTF-8")
@@ -156,11 +158,21 @@ class TextAssetLoaderTest {
       on(it.readString("UTF-16")) doReturn "Content."
     }
 
-    val result = loader.load(mock(), "test.txt", file, TextAssetLoaderParameters(charset = "UTF-16"))
+    loader.loadAsync(mock(), "test.txt", file, TextAssetLoaderParameters(charset = "UTF-16"))
+    val result = loader.loadSync(mock(), "test.txt", file, TextAssetLoaderParameters(charset = "UTF-16"))
 
     assertEquals("Content.", result)
     verify(file).readString("UTF-16")
   }
+
+  @Test
+  fun `should throw exception when trying to read file without loading it asynchronously`() {
+    val loader = TextAssetLoader(ClasspathFileHandleResolver(), charset = "UTF-8")
+
+    shouldThrow<AssetStorageException> {
+      loader.loadSync(mock(), "test.txt", mock(), null)
+    }
+  }
 }
 
 /**

async/src/test/resources/ktx/async/assets/collection.json

@@ -1 +1,10 @@
-[{"testInt":10,"testString":"Content."},{"testInt":20,"testString":"Test."}]
+[
+  {
+    "testInt": 10,
+    "testString": "Content."
+  },
+  {
+    "testInt": 20,
+    "testString": "Test."
+  }
+]

async/src/test/resources/ktx/async/assets/object.json

@@ -1 +1,4 @@
-{"testInt":10,"testString":"Content."}
+{
+  "testInt": 10,
+  "testString": "Content."
+}