content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package ksm.typed
import kotlin.reflect.KType
import kotlin.reflect.typeOf
public class TypedValue<out T>(
public val data: T,
public val type: KType
) {
public fun interface Generic<out T> {
public fun get(type: KType): T
public companion object {
public inline fun <reified T> of(data: T): Generic<T> {
return of(TypedValue.of(data))
}
public fun <T> of(value: TypedValue<T>): Generic<T> {
return Generic { type ->
require(type == value.type)
value.data
}
}
}
}
public companion object {
public inline fun <reified T> of(value: T): TypedValue<T> {
return TypedValue(value, typeOf<T>())
}
}
}
| ksm/core/src/commonMain/kotlin/ksm/typed/TypedValue.kt | 2294782467 |
package ksm.builder
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.install
import ksm.plugin.Plugin
public class StateControllerBuilder(public var context: StateContext) {
@OptIn(MutateContext::class)
public fun install(plugin: Plugin) {
context = context.install(plugin)
}
}
| ksm/core/src/commonMain/kotlin/ksm/builder/StateControllerBuilder.kt | 3212669741 |
package ksm.kotlinx.serialization.plugin.serializer
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.KSerializer
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.serializer
import ksm.typed.TypedValue
public object GenericValueDeserializer : KSerializer<TypedValue.Generic<*>> {
@OptIn(ExperimentalSerializationApi::class)
override val descriptor: SerialDescriptor = SerialDescriptor(
serialName = "TypedValueSerializer",
original = JsonElement.serializer().descriptor
)
override fun serialize(
encoder: Encoder,
value: TypedValue.Generic<*>
) {
error("TypedValue.Generic<T> cannot be serialized, only deserialized")
}
override fun deserialize(decoder: Decoder): TypedValue.Generic<*> {
return TypedValue.Generic { type ->
val deserializer = decoder.serializersModule.serializer(type)
deserializer.deserialize(decoder)
}
}
}
| ksm/navigation/navigation-kotlinx-json/src/commonMain/kotlin/ksm/kotlinx/serialization/plugin/serializer/GenericValueDeserializer.kt | 884163739 |
package ksm.kotlinx.serialization.plugin.serializer
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerializationStrategy
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.serializer
import ksm.typed.TypedValue
public object TypedValueSerializer : KSerializer<TypedValue<*>> {
@OptIn(ExperimentalSerializationApi::class)
override val descriptor: SerialDescriptor = SerialDescriptor(
serialName = "TypedValueSerializer",
original = JsonElement.serializer().descriptor
)
override fun serialize(
encoder: Encoder,
value: TypedValue<*>
) {
val baseSerializer = encoder.serializersModule.serializer(value.type)
baseSerializer.serialize(encoder, value.data)
}
override fun deserialize(decoder: Decoder): TypedValue<*> {
error("This type cannot be deserialized, use TypedValue.Generic<T> instead")
}
}
| ksm/navigation/navigation-kotlinx-json/src/commonMain/kotlin/ksm/kotlinx/serialization/plugin/serializer/TypedValueSerializer.kt | 3347447974 |
package ksm.kotlinx.serialization.plugin
import kotlinx.serialization.json.Json
import kotlinx.serialization.modules.SerializersModule
import kotlinx.serialization.serializer
import ksm.kotlinx.serialization.plugin.serializer.GenericValueDeserializer
import ksm.kotlinx.serialization.plugin.serializer.TypedValueSerializer
import ksm.navigation.serialization.BaseSerializationFormat
import ksm.navigation.serialization.BaseSerializationStore
import ksm.typed.TypedValue
import kotlin.reflect.KType
internal class KotlinxSerializationFormat(
private val store: BaseSerializationStore.String,
json: Json
) : BaseSerializationFormat {
private val json = Json(json) {
serializersModule = SerializersModule {
include(serializersModule)
contextual(TypedValue::class, TypedValueSerializer)
contextual(TypedValue.Generic::class, GenericValueDeserializer)
}
}
override fun encode(value: TypedValue<*>) {
val serializer = json.serializersModule.serializer(value.type)
store.apply(json.encodeToString(serializer, value))
}
override fun decode(type: KType): Any? {
val string = store.get() ?: return null
val deserializer = json.serializersModule.serializer(type)
return json.decodeFromString(deserializer, string)
}
}
| ksm/navigation/navigation-kotlinx-json/src/commonMain/kotlin/ksm/kotlinx/serialization/plugin/KotlinxSerializationFormat.kt | 48618833 |
package ksm.kotlinx.serialization.plugin
import kotlinx.serialization.json.Json
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.install
import ksm.navigation.serialization.BaseSerializationStore
import ksm.navigation.serialization.plugin.BaseSerializationPlugin
import ksm.plugin.Plugin
public class KotlinxSerializationPlugin(
private val json: Json = Json,
private val store: BaseSerializationStore.String? = null
) : Plugin {
override val key: Companion = KotlinxSerializationPlugin
@MutateContext
override fun install(context: StateContext): StateContext {
val store = this.store
?: context[BaseSerializationStore.String]
?: error("Please either provide BaseSerializationStore using constructor or install the plugin that will provide it")
val format = KotlinxSerializationFormat(store, json)
val basePlugin = BaseSerializationPlugin(format)
return context.install(basePlugin)
}
public companion object : StateContext.Key<KotlinxSerializationPlugin>
}
| ksm/navigation/navigation-kotlinx-json/src/commonMain/kotlin/ksm/kotlinx/serialization/plugin/KotlinxSerializationPlugin.kt | 1177498220 |
package ksm.navigation.ktgbotapi
import kotlin.jvm.JvmInline
@JvmInline
public value class TelegramPeerKey(public val string: String)
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/TelegramPeerKey.kt | 1197336446 |
package ksm.navigation.ktgbotapi
import dev.inmo.tgbotapi.bot.TelegramBot
import dev.inmo.tgbotapi.types.update.abstracts.Update
import kotlinx.coroutines.flow.Flow
import ksm.StateController
import ksm.annotation.LibraryConstructor
import ksm.asStateController
import ksm.builder.StateControllerBuilder
import ksm.navigation.state.StateScope
import ksm.navigation.state.navigate
import ksm.navigation.ktgbotapi.plugin.TelegramBotApiPlugin
import ksm.navigation.navigationStateController
import ksm.navigation.serialization.restore
import ksm.navigation.stack.hasNextContext
import ksm.navigation.stack.lastContext
public class TelegramBotStateMachine(
private val builder: StateControllerBuilder.() -> Unit
) {
public suspend fun <T : Update> start(
startStateName: String,
telegramBot: TelegramBot,
updates: Flow<T>,
key: (T) -> TelegramPeerKey
) {
updates.collect { update ->
val controller = createStateController(key(update), update, telegramBot)
if (!controller.context.hasNextContext) {
controller.navigate(startStateName)
}
// todo: это дефолтный интерцептор, надо дать возможность
// добавлять свои интерцепторы на апдейты после восстановления состояния
// -
// Новых абстракций можно не придумывать, а в случае, когда необходимо блокировать
// выполнение цепочки, можно сделать декоратор
val lastContext = controller.context.lastContext
val lastController = lastContext.asStateController()
val stateScope = StateScope(lastController)
lastContext.executeBlock.invoke(stateScope)
}
}
@OptIn(LibraryConstructor::class)
private fun createStateController(
key: TelegramPeerKey,
update: Update,
telegramBot: TelegramBot
): StateController {
return navigationStateController {
install(TelegramBotApiPlugin(key, update, telegramBot))
builder()
}.apply {
context.restore()
}
}
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/TelegramBotKSM.kt | 4008677382 |
package ksm.navigation.ktgbotapi.match
import dev.inmo.tgbotapi.extensions.utils.extensions.raw.text
import dev.inmo.tgbotapi.utils.RiskFeature
import ksm.navigation.ktgbotapi.message
@OptIn(RiskFeature::class)
public inline fun MatchScope.exact(
text: String,
block: () -> Unit
) {
if (context.message.text == text) block()
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/match/Exact.kt | 16882429 |
package ksm.navigation.ktgbotapi.match
import ksm.context.StateContext
public class MatchScope(
public val context: StateContext
) {
private var default: () -> Unit = { }
public fun default(block: () -> Unit) {
default = block
}
private var intercepted: Boolean = false
public fun intercept() {
require(!intercepted)
intercepted = true
}
public fun runDefault() {
if (!intercepted) default()
}
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/match/MatchScope.kt | 362344144 |
package ksm.navigation.ktgbotapi.match
public fun MatchScope.command(
text: String,
args: Int? = null,
prefix: String = "/",
block: (List<String>) -> Unit
) {
// todo: сделать реализацию, которая будет учитывать количество аргументов и т.п.
// возможно стоит тут задействовать интерцепторы и через них прокидывать дефолтное сообщение,
// когда команда неизвестна
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/match/Command.kt | 3306270949 |
package ksm.navigation.ktgbotapi
import dev.inmo.tgbotapi.bot.TelegramBot
import dev.inmo.tgbotapi.extensions.api.send.sendMessage
import dev.inmo.tgbotapi.extensions.utils.extensions.sourceChat
import dev.inmo.tgbotapi.extensions.utils.extensions.sourceUser
import dev.inmo.tgbotapi.types.IdChatIdentifier
import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
import dev.inmo.tgbotapi.types.chat.User
import dev.inmo.tgbotapi.types.update.abstracts.Update
import dev.inmo.tgbotapi.utils.PreviewFeature
import ksm.navigation.state.StateScope
import ksm.navigation.ktgbotapi.match.MatchScope
public val StateScope.update: Update get() {
return controller.context.update
}
@OptIn(PreviewFeature::class)
public val StateScope.user: User get() {
return update.sourceUser() ?: error("Cannot get user from $update")
}
@OptIn(PreviewFeature::class)
public val StateScope.chatId: IdChatIdentifier get() {
return update.sourceChat()?.id ?: error("Cannot get chatId from $update")
}
public val StateScope.telegramBot: TelegramBot get() {
return controller.context.telegramBot
}
public suspend fun StateScope.sendMessage(
text: String,
replyMarkup: KeyboardMarkup? = null
) {
telegramBot.sendMessage(chatId, text, replyMarkup = replyMarkup)
}
public inline fun StateScope.matchMessage(block: MatchScope.() -> Unit) {
MatchScope(controller.context).apply(block)
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/StateScope.kt | 1986627342 |
package ksm.navigation.ktgbotapi
import dev.inmo.tgbotapi.bot.TelegramBot
import dev.inmo.tgbotapi.types.message.abstracts.Message
import dev.inmo.tgbotapi.types.update.MessageUpdate
import dev.inmo.tgbotapi.types.update.abstracts.Update
import ksm.context.StateContext
import ksm.navigation.state.StateScope
import ksm.navigation.ktgbotapi.plugin.TelegramBotApiPlugin
import ksm.plugin.plugin
public val StateContext.update: Update get() {
return plugin(TelegramBotApiPlugin).update
}
// todo: правило для экстеншенов – они должны работать либо всегда, либо никогда
// нельзя сделать экстеншен, который будет падать, если пришёл один тг запрос и
// который будет работать, если пришёл другой.
// это надо решать каким-то другим образом
// Для этого мб потребуется сделать states отдельным плагином
//
public val StateContext.messageUpdate: MessageUpdate get() {
return update as? MessageUpdate ?: error("Received update is not MessageUpdate")
}
public val StateContext.message: Message get() {
return messageUpdate.data
}
public val StateContext.telegramBot: TelegramBot get() {
return plugin(TelegramBotApiPlugin).telegramBot
}
internal val StateContext.executeBlock: suspend StateScope.() -> Unit get() {
return plugin(TelegramBotApiPlugin).executeBlock(context = this)
}
public fun StateContext.setExecuteBlock(block: suspend StateScope.() -> Unit) {
plugin(TelegramBotApiPlugin).setExecuteBlock(
context = this,
block = block
)
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/StateContext.kt | 4292979754 |
package ksm.navigation.ktgbotapi.plugin
import ksm.context.StateContext
import ksm.navigation.state.StateScope
internal class TelegramBotEntry : StateContext.Element {
override val key = TelegramBotEntry
var execute: (suspend StateScope.() -> Unit)? = null
companion object : StateContext.Key<TelegramBotEntry>
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/plugin/TelegramBotEntry.kt | 1949535533 |
package ksm.navigation.ktgbotapi.plugin
import dev.inmo.tgbotapi.bot.TelegramBot
import dev.inmo.tgbotapi.types.update.abstracts.Update
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.navigation.state.StateScope
import ksm.navigation.ktgbotapi.TelegramPeerKey
import ksm.plugin.Plugin
public class TelegramBotApiPlugin(
public val peerKey: TelegramPeerKey,
public val update: Update,
public val telegramBot: TelegramBot
) : Plugin {
override val key: Companion = TelegramBotApiPlugin
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
return context + TelegramBotEntry()
}
}
public fun setExecuteBlock(
context: StateContext,
block: suspend StateScope.() -> Unit
) {
context.require(TelegramBotEntry).execute = block
}
public fun executeBlock(context: StateContext): suspend StateScope.() -> Unit {
return context.require(TelegramBotEntry).execute
?: error("Please invoke `execute` in StateBuilder")
}
public companion object : StateContext.Key<TelegramBotApiPlugin>
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/plugin/TelegramBotApiPlugin.kt | 752447295 |
package ksm.navigation.ktgbotapi
import ksm.navigation.state.StateScope
import ksm.navigation.state.builder.StateBuilderScope
public fun StateBuilderScope.execute(block: suspend StateScope.() -> Unit) {
context.setExecuteBlock(block)
}
| ksm/navigation/navigation-ktgbotapi/src/commonMain/kotlin/ksm/navigation/ktgbotapi/StateBuilderScope.kt | 3706612805 |
package ksm.navigation.compose.host
import androidx.compose.foundation.layout.Box
import androidx.compose.runtime.Composable
import androidx.compose.runtime.key
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import ksm.StateController
import ksm.asStateController
import ksm.navigation.compose.plugin.ComposePlugin
import ksm.navigation.state.StateScope
import ksm.navigation.state.navigate
import ksm.plugin.plugin
@Composable
public fun NavigationStateHost(
controller: StateController,
startStateName: String,
modifier: Modifier = Modifier
) {
Box(modifier) {
val currentContext = remember(controller) {
controller.navigate(startStateName)
controller.context.plugin(ComposePlugin).currentContext
}.value
key(currentContext) {
currentContext ?: return
val childController = currentContext.asStateController()
val contentScope = StateScope(childController)
val content = currentContext.plugin(ComposePlugin).content(currentContext)
content?.invoke(contentScope)
}
}
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/host/NavigationStateHost.kt | 3188706182 |
package ksm.navigation.compose
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import ksm.StateController
import ksm.annotation.LibraryConstructor
import ksm.builder.StateControllerBuilder
import ksm.navigation.compose.plugin.ComposePlugin
import ksm.navigation.compose.plugin.ComposeSerializationStore
import ksm.navigation.navigationStateController
import ksm.navigation.serialization.restore
@OptIn(LibraryConstructor::class)
@Composable
public fun rememberStateController(
builder: StateControllerBuilder.() -> Unit
): StateController {
val store = rememberSaveable(
builder,
saver = ComposeSerializationStore.Saver,
init = { ComposeSerializationStore() }
)
return remember(store) {
navigationStateController {
install(ComposePlugin(store))
builder()
}.apply {
context.restore()
}
}
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/RememberStateController.kt | 4012350995 |
package ksm.navigation.compose.example
import androidx.compose.runtime.Composable
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.emptyFlow
import ksm.StateController
import ksm.navigation.compose.Content
import ksm.navigation.compose.host.NavigationStateHost
import ksm.navigation.compose.rememberStateController
import ksm.navigation.state.builder.StateRouteScope
import ksm.navigation.state.builder.states
import ksm.navigation.state.data.receive
import ksm.navigation.state.name.named
import ksm.navigation.result.*
import ksm.viewmodel.viewModelStateController
private class MainViewModel {
val actions: Flow<Action> = emptyFlow()
val controller = viewModelStateController()
sealed interface Action {
data object RouteDetails : Action
}
}
private data class DetailsParameters(val itemId: String)
private const val MAIN_SCREEN = "MainState"
private const val DETAILS_SCREEN = "DetailsState"
@Composable
private fun AppContent() {
val controller = rememberStateController {
states {
main()
details()
}
}
NavigationStateHost(
controller = controller,
startStateName = MAIN_SCREEN
)
}
private fun StateController.registerDetailsNavigator(
handler: NavigationResultHandler<String>
): NavigatorForResult<DetailsParameters> {
return registerNavigator(DETAILS_SCREEN, handler)
}
private fun StateRouteScope.main() = named(MAIN_SCREEN) {
Content {
val launcher = controller.registerDetailsNavigator { itemName ->
println("Item Picked! $itemName")
}
// somewhere in actions handler
val parameters = DetailsParameters(itemId = "10")
launcher.navigate(parameters)
}
}
private fun StateRouteScope.details() = named(DETAILS_SCREEN) {
Content {
val parameters: DetailsParameters = controller.receive()
// somewhere in actions handler
controller.finishWithResult("ItemName[${parameters.itemId}]")
}
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/example/Example.kt | 4007902728 |
package ksm.navigation.compose.plugin
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import ksm.navigation.state.StateScope
import ksm.navigation.serialization.BaseSerializationStore
import ksm.plugin.Plugin
public class ComposePlugin(
private val store: BaseSerializationStore.String
) : Plugin {
override val key: Companion = ComposePlugin
internal val currentContext = mutableStateOf<StateContext?>(value = null)
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration())
return context + store
}
private inner class Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
context.addLifecycleInterceptor(Lifecycle())
return context + ComposeEntry()
}
}
private inner class Lifecycle : LifecycleInterceptor {
override fun onResume(context: StateContext) {
currentContext.value = context
}
}
internal fun setContent(
context: StateContext,
content: @Composable StateScope.() -> Unit
) {
context.require(ComposeEntry).content = content
}
internal fun content(context: StateContext): (@Composable StateScope.() -> Unit)? {
return context.require(ComposeEntry).content
}
public companion object : StateContext.Key<ComposePlugin>
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/plugin/ComposePlugin.kt | 2029674451 |
package ksm.navigation.compose.plugin
import androidx.compose.runtime.saveable.SaverScope
import ksm.navigation.serialization.BaseSerializationStore
import androidx.compose.runtime.saveable.Saver as ComposeSaver
public class ComposeSerializationStore(
internal var string: String? = null
) : BaseSerializationStore.String {
override fun apply(string: String) {
this.string = string
}
override fun get(): String? = string
public object Saver : ComposeSaver<ComposeSerializationStore, String> {
override fun restore(value: String): ComposeSerializationStore {
return ComposeSerializationStore(value)
}
override fun SaverScope.save(value: ComposeSerializationStore): String? {
return value.string
}
}
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/plugin/ComposeSerializationStore.kt | 928171985 |
package ksm.navigation.compose.plugin
import androidx.compose.runtime.Composable
import ksm.context.StateContext
import ksm.navigation.state.StateScope
internal class ComposeEntry : StateContext.Element {
override val key = ComposeEntry
var content: (@Composable StateScope.() -> Unit)? = null
companion object : StateContext.Key<ComposeEntry>
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/plugin/ComposeEntry.kt | 1767542749 |
package ksm.navigation.compose
import androidx.compose.runtime.Composable
import ksm.navigation.compose.plugin.ComposePlugin
import ksm.navigation.state.StateScope
import ksm.navigation.state.builder.StateBuilderScope
import ksm.plugin.plugin
public fun StateBuilderScope.Content(
block: @Composable StateScope.() -> Unit
) {
context.plugin(ComposePlugin).setContent(context, block)
}
| ksm/navigation/navigation-compose/src/main/kotlin/ksm/navigation/compose/StateBuilderScope.kt | 3661103396 |
package ksm.navigation.mdi
import app.meetacy.di.DI
import ksm.navigation.mdi.plugin.DIPlugin
import ksm.context.StateContext
import ksm.plugin.plugin
public var StateContext.di: DI
get() = plugin(DIPlugin).di(context = this)
set(value) = plugin(DIPlugin).setDI(context = this, di = value)
| ksm/navigation/navigation-mdi/src/commonMain/kotlin/ksm/navigation/mdi/StateContext.kt | 2362366403 |
package ksm.navigation.mdi.plugin
import app.meetacy.di.DI
import app.meetacy.di.builder.di
import ksm.pluginStateController
import ksm.annotation.MutateContext
import ksm.asStateController
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.plugin.Plugin
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
public class DIPlugin(private val root: DI) : Plugin {
override val key: Companion = DIPlugin
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration())
return context + DIEntry(root)
}
private inner class Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
val entry = DIEntry(root)
context.addLifecycleInterceptor(Lifecycle(entry))
return context + entry
}
}
private inner class Lifecycle(val entry: DIEntry) : LifecycleInterceptor {
override fun onFinish(context: StateContext) {
entry.setDI(null)
}
}
public fun di(context: StateContext): DI {
val base = context.require(DIEntry).getDI() ?: error("DI is not initialized")
return base + di {
val stateController by constant(context.asStateController())
}
}
public fun setDI(context: StateContext, di: DI) {
context.require(DIEntry).setDI(di)
}
public companion object : StateContext.Key<DIPlugin>
}
| ksm/navigation/navigation-mdi/src/commonMain/kotlin/ksm/navigation/mdi/plugin/DIPlugin.kt | 223426339 |
package ksm.navigation.mdi.plugin
import app.meetacy.di.DI
import ksm.context.StateContext
internal class DIEntry(private val root: DI) : StateContext.Element {
override val key = DIEntry
private var di: DI? = root
fun setDI(di: DI?) {
if (di == null) {
this.di = null
return
}
this.di = root + di
}
fun getDI() = di
companion object : StateContext.Key<DIEntry>
}
| ksm/navigation/navigation-mdi/src/commonMain/kotlin/ksm/navigation/mdi/plugin/DIEntry.kt | 830246503 |
package ksm.navigation.mdi
import app.meetacy.di.DI
import ksm.StateController
public val StateController.di: DI get() {
return context.di
}
| ksm/navigation/navigation-mdi/src/commonMain/kotlin/ksm/navigation/mdi/StateController.kt | 599898026 |
package ksm.navigation.mdi
import app.meetacy.di.DI
import ksm.navigation.state.builder.StateBuilderScope
public var StateBuilderScope.di: DI
get() = context.di
set(value) { context.di = value }
| ksm/navigation/navigation-mdi/src/commonMain/kotlin/ksm/navigation/mdi/StateBuilderScope.kt | 2968318674 |
package ksm.navigation.result
import ksm.typed.TypedValue
public interface NavigatorForResult<in T> {
public fun navigate(value: TypedValue<T>)
}
public inline fun <reified T> NavigatorForResult<T>.navigate(data: T) {
navigate(TypedValue.of(data))
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/NavigatorForResult.kt | 2760205325 |
package ksm.navigation.result
import ksm.StateController
public fun <TData, TResult> StateController.registerNavigator(
name: String,
handler: NavigationResultHandler<TResult>
): NavigatorForResult<TData> {
return context.registerNavigator(name, handler)
}
public fun StateController.finishWithResult(result: Any?) {
context.finishWithResult(result)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/NavigationController.kt | 3339221120 |
package ksm.navigation.result
import ksm.context.StateContext
import ksm.plugin.plugin
import ksm.navigation.result.plugin.NavigationResultPlugin
public fun <TData, TResult> StateContext.registerNavigator(
name: String,
handler: NavigationResultHandler<TResult>
): NavigatorForResult<TData> {
return plugin(NavigationResultPlugin).registerNavigator(
context = this,
name = name,
handler = handler
)
}
public fun StateContext.finishWithResult(result: Any?) {
plugin(NavigationResultPlugin).finishWithResult(
context = this,
result = result
)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/StateContext.kt | 3706861384 |
package ksm.navigation.result.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.context.finish
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import ksm.navigation.state.navigate
import ksm.navigation.state.parameters.receiveParameter
import ksm.navigation.state.parameters.setParameter
import ksm.plugin.Plugin
import ksm.navigation.result.NavigatorForResult
import ksm.navigation.result.NavigationResultHandler
import ksm.navigation.stack.previousContext
import ksm.typed.TypedValue
public object NavigationResultPlugin : Plugin.Singleton<NavigationResultPlugin> {
private const val RESULT_ID_KEY = "ksm.result.plugin.RESULT_ID"
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
val entry = NavigationResultEntry()
context.addLifecycleInterceptor(Lifecycle(entry))
return context + entry
}
}
private class Lifecycle(val entry: NavigationResultEntry) : LifecycleInterceptor {
override fun onResume(context: StateContext) {
entry.onResume()
}
}
public fun finishWithResult(
context: StateContext,
result: Any?
) {
val resultId: Int = context.receiveParameter(RESULT_ID_KEY)
?: error("Cannot finish with result state that was not launched with LauncherForResult")
context.previousContext
.require(NavigationResultEntry)
.setResult(NavigationResultId(resultId), result)
context.finish()
}
public fun <T> registerNavigator(
context: StateContext,
name: String,
handler: NavigationResultHandler<*>
): NavigatorForResult<T> {
val resultId = context
.require(NavigationResultEntry)
.registerNavigator(handler)
return object : NavigatorForResult<T> {
override fun navigate(value: TypedValue<T>) {
context.navigate(name, value) { child ->
child.setParameter(RESULT_ID_KEY, resultId.int)
}
}
}
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/plugin/NavigationResultPlugin.kt | 2663157125 |
package ksm.navigation.result.plugin
import kotlin.jvm.JvmInline
@JvmInline
internal value class NavigationResultId(val int: Int)
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/plugin/NavigationResultId.kt | 3853106856 |
package ksm.navigation.result.plugin
import ksm.context.StateContext
import ksm.navigation.result.NavigationResultHandler
internal class NavigationResultEntry : StateContext.Element {
override val key = NavigationResultEntry
private val unhandledResults = mutableMapOf<NavigationResultId, Any?>()
private val resultHandlers = mutableMapOf<NavigationResultId, NavigationResultHandler<*>>()
fun setResult(id: NavigationResultId, data: Any?) {
unhandledResults[id] = data
}
fun registerNavigator(handler: NavigationResultHandler<*>): NavigationResultId {
val id = NavigationResultId(resultHandlers.size)
resultHandlers[id] = handler
handleResult(id)
return id
}
fun onResume() {
for (resultId in unhandledResults.keys.toList()) {
handleResult(resultId)
}
}
private fun handleResult(resultId: NavigationResultId) {
if (resultId !in unhandledResults) return
val result = unhandledResults.getValue(resultId)
resultHandlers[resultId]?.handleUnchecked(result)
unhandledResults -= resultId
}
@Suppress("UNCHECKED_CAST")
private fun <T> NavigationResultHandler<T>.handleUnchecked(result: Any?) {
handle(result as T)
}
companion object : StateContext.Key<NavigationResultEntry>
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/plugin/NavigationResultEntry.kt | 1650759024 |
package ksm.navigation.result
public fun interface NavigationResultHandler<in T> {
public fun handle(result: T)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/result/NavigationResultHandler.kt | 2163567061 |
package ksm.navigation
import ksm.StateController
import ksm.pluginStateController
import ksm.annotation.LibraryConstructor
import ksm.builder.StateControllerBuilder
import ksm.context.StateContext
import ksm.navigation.state.name.plugin.StateNamePlugin
import ksm.navigation.state.parameters.plugin.StateParametersPlugin
import ksm.navigation.stack.installStackPlugin
@LibraryConstructor
public inline fun navigationStateController(
context: StateContext = StateContext.Empty,
enableConfiguration: Boolean = true,
enableLifecycle: Boolean = true,
enableStateName: Boolean = true,
enableStateParameters: Boolean = true,
enableStack: Boolean = true,
enableFinishOnce: Boolean = true,
block: StateControllerBuilder.() -> Unit = {}
): StateController {
return pluginStateController(
context = context,
enableConfiguration = enableConfiguration,
enableLifecycle = enableLifecycle,
enableFinishOnce = enableFinishOnce
) {
// Installing built-in features
installStackPlugin(enableStack) {
if (enableStateName) install(StateNamePlugin)
if (enableStateParameters) install(StateParametersPlugin)
block()
}
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/NavigationController.kt | 2155195417 |
package ksm.navigation.serialization
import ksm.typed.TypedValue
import kotlin.reflect.KType
public interface BaseSerializationFormat {
public fun encode(value: TypedValue<*>)
public fun decode(type: KType): Any?
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/serialization/BaseSerializationFormat.kt | 2372663436 |
package ksm.navigation.serialization
import ksm.context.StateContext
public interface BaseSerializationStore {
public suspend fun await() {}
public interface String : BaseSerializationStore, StateContext.Element {
override val key: Companion get() = String
public fun get(): kotlin.String?
public fun apply(string: kotlin.String)
public companion object : StateContext.Key<String>
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/serialization/BaseSerializationStore.kt | 2651228504 |
package ksm.navigation.serialization
import ksm.context.StateContext
import ksm.plugin.plugin
import ksm.navigation.serialization.plugin.BaseSerializationPlugin
public fun StateContext.restore() {
plugin(BaseSerializationPlugin).restore(context = this)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/serialization/StateContext.kt | 82431896 |
package ksm.navigation.serialization.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import ksm.navigation.state.parameters.interceptor.addParametersInterceptor
import ksm.plugin.Plugin
import ksm.navigation.serialization.BaseSerializationFormat
public class BaseSerializationPlugin(format: BaseSerializationFormat) : Plugin {
override val key: Companion = BaseSerializationPlugin
private val controller = BaseSerializationStateController(format)
@MutateContext
override fun install(
context: StateContext
): StateContext {
context.addConfigurationInterceptor(Configuration())
return context
}
private inner class Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
val parametersInterceptor = BaseSerializationParametersInterceptor()
context.addParametersInterceptor(parametersInterceptor)
context.addLifecycleInterceptor(Lifecycle(parametersInterceptor))
return context
}
}
private inner class Lifecycle(
val interceptor: BaseSerializationParametersInterceptor
) : LifecycleInterceptor {
override fun onResume(context: StateContext) {
controller.commit(context, interceptor)
}
}
public fun restore(context: StateContext) {
controller.restore(context)
}
public companion object : StateContext.Key<BaseSerializationPlugin>
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/serialization/plugin/BaseSerializationPlugin.kt | 1632009917 |
package ksm.navigation.serialization.plugin
import ksm.navigation.state.parameters.interceptor.ParametersInterceptor
import ksm.typed.TypedValue
internal class BaseSerializationParametersInterceptor : ParametersInterceptor {
private val map = mutableMapOf<String, TypedValue.Generic<*>>()
override fun onPut(
key: String,
value: TypedValue<*>
) {
map[key] = TypedValue.Generic.of(value)
}
@Suppress("UNCHECKED_CAST")
override fun <T> onReceive(key: String): TypedValue.Generic<T>? {
return map[key] as TypedValue.Generic<T>?
}
fun toMap(): Map<String, TypedValue.Generic<*>> {
return map
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/serialization/plugin/BaseSerializationParametersInterceptor.kt | 1994458461 |
package ksm.navigation.serialization.plugin
import ksm.context.StateContext
import ksm.context.createChildContext
import ksm.navigation.state.name.name
import ksm.navigation.state.name.setName
import ksm.navigation.state.parameters.setParameter
import ksm.navigation.serialization.BaseSerializationFormat
import ksm.navigation.stack.previousContextOrNull
import ksm.typed.TypedValue
import kotlin.reflect.typeOf
private typealias SerializedStackType = List<TypedValue<Map<String, TypedValue<*>>>>
internal class BaseSerializationStateController(
private val format: BaseSerializationFormat
) : StateContext.Element {
override val key = BaseSerializationStateController
private val serializedStackType = typeOf<SerializedStackType>()
@Suppress("UNCHECKED_CAST")
fun restore(root: StateContext) {
val serializedStack = format.decode(serializedStackType) ?: return
serializedStack as SerializedStackType
var current = root
for (serializedEntry in serializedStack) {
current = decodeEntry(current, serializedEntry.data)
}
}
private fun decodeEntry(
context: StateContext,
parameters: Map<String, TypedValue<*>>
): StateContext = context.createChildContext { child ->
val name = parameters[STATE_NAME_KEY]?.data as String?
if (name != null) {
child.setName(name)
}
for ((key, value) in parameters) {
if (key == STATE_NAME_KEY) continue
child.setParameter(key, value)
}
}
fun commit(context: StateContext, entry: BaseSerializationParametersInterceptor) {
var current: StateContext? = context
val serializedStack = mutableListOf<TypedValue<*>>()
while (current != null) {
val encodedEntry = encodeEntry(current, entry)
serializedStack.add(
// Make sure root context is always on top
index = 0,
element = encodedEntry
)
current = context.previousContextOrNull
}
val value = TypedValue.of(serializedStack.toList())
format.encode(value)
}
private fun encodeEntry(
context: StateContext,
entry: BaseSerializationParametersInterceptor
): TypedValue<*> {
val name = STATE_NAME_KEY to TypedValue.Generic.of(context.name)
val map = entry.toMap() + name
return TypedValue.of(map)
}
companion object : StateContext.Key<BaseSerializationStateController> {
const val STATE_NAME_KEY = "ksm.serialization.plugin.STATE_NAME"
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/serialization/plugin/BaseSerializationStateController.kt | 2219189349 |
package ksm.navigation.annotation
@DslMarker
public annotation class StateBuilderDSL
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/annotation/StateBuilderDSL.kt | 1141299872 |
package ksm.navigation.annotation
@RequiresOptIn(
message = "You install StackPlugin without usage of installStackPlugin function. " +
"In order to make Lifecycle work properly with StackPlugin, consider to use this function instead",
level = RequiresOptIn.Level.ERROR
)
public annotation class InstallStackPlugin
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/annotation/InstallStackPlugin.kt | 1504371153 |
package ksm.navigation.state
import ksm.StateController
import ksm.navigation.annotation.StateBuilderDSL
@StateBuilderDSL
public class StateScope(public val controller: StateController)
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/StateScope.kt | 1640843408 |
package ksm.navigation.state.parameters
import ksm.context.StateContext
import ksm.navigation.state.parameters.plugin.StateParametersPlugin
import ksm.plugin.plugin
import ksm.typed.TypedValue
import kotlin.reflect.KType
import kotlin.reflect.typeOf
public inline fun <reified T> StateContext.setParameter(key: String, data: T) {
return setParameter(key, TypedValue.of(data))
}
public fun <T> StateContext.setParameter(
key: String,
value: TypedValue<T>
) {
plugin(StateParametersPlugin).put(
context = this,
key = key,
value = value
)
}
public inline fun <reified T> StateContext.receiveParameter(key: String): T? {
return receiveParameter(key, typeOf<T>())
}
public fun <T> StateContext.receiveParameter(
key: String,
type: KType
): T? {
return plugin(StateParametersPlugin).receive<T>(
context = this,
key = key
)?.get(type)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/parameters/StateContext.kt | 3891539219 |
package ksm.navigation.state.parameters.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.navigation.state.parameters.interceptor.ParametersInterceptor
import ksm.navigation.state.parameters.interceptor.memory.MemoryParametersInterceptor
import ksm.plugin.Plugin
import ksm.typed.TypedValue
public object StateParametersPlugin : Plugin.Singleton<StateParametersPlugin> {
@MutateContext
override fun install(
context: StateContext
): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
val entry = StateParametersEntry()
entry.addInterceptor(MemoryParametersInterceptor())
return context + entry
}
}
public fun <T> put(
context: StateContext,
key: String,
value: TypedValue<T>
) {
context.require(StateParametersEntry).onPut(key, value)
}
public fun <T> receive(
context: StateContext,
key: String
): TypedValue.Generic<T>? {
return context.require(StateParametersEntry).onReceive(key)
}
public fun addParametersInterceptor(
context: StateContext,
interceptor: ParametersInterceptor
) {
context.require(StateParametersEntry).addInterceptor(interceptor)
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/parameters/plugin/StateParametersPlugin.kt | 1944167074 |
package ksm.navigation.state.parameters.plugin
import ksm.context.StateContext
import ksm.navigation.state.parameters.interceptor.ParametersInterceptor
import ksm.typed.TypedValue
internal class StateParametersEntry : StateContext.Element {
override val key = StateParametersEntry
private val interceptors = mutableListOf<ParametersInterceptor>()
fun addInterceptor(interceptor: ParametersInterceptor) {
interceptors += interceptor
}
fun onPut(
key: String,
value: TypedValue<*>
) {
for (interceptor in interceptors) {
interceptor.onPut(key, value)
}
}
fun <T> onReceive(key: String): TypedValue.Generic<T>? {
for (interceptor in interceptors.asReversed()) {
val value = interceptor.onReceive<T>(key)
if (value != null) return value
}
return null
}
companion object : StateContext.Key<StateParametersEntry>
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/parameters/plugin/StateParametersEntry.kt | 1596692330 |
package ksm.navigation.state.parameters.interceptor.memory
import ksm.navigation.state.parameters.interceptor.ParametersInterceptor
import ksm.typed.TypedValue
internal class MemoryParametersInterceptor : ParametersInterceptor {
private val map = mutableMapOf<String, TypedValue.Generic<*>>()
override fun onPut(key: String, value: TypedValue<*>) {
map[key] = TypedValue.Generic.of(value)
}
@Suppress("UNCHECKED_CAST")
override fun <T> onReceive(key: String): TypedValue.Generic<T>? {
return map[key] as TypedValue.Generic<T>?
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/parameters/interceptor/memory/MemoryParametersInterceptor.kt | 2406950754 |
package ksm.navigation.state.parameters.interceptor
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.navigation.state.parameters.plugin.StateParametersPlugin
import ksm.plugin.plugin
import ksm.typed.TypedValue
@MutateContext
public fun StateContext.addParametersInterceptor(
onPut: (key: String, value: TypedValue<*>) -> Unit = { _, _ -> },
onReceive: (String) -> TypedValue.Generic<*>? = { null }
) {
val interceptor = object : ParametersInterceptor {
override fun onPut(key: String, value: TypedValue<*>) {
onPut(key, value)
}
override fun <T> onReceive(key: String): TypedValue.Generic<T>? {
@Suppress("UNCHECKED_CAST")
return onReceive(key) as TypedValue.Generic<T>?
}
}
addParametersInterceptor(interceptor)
}
@MutateContext
public fun StateContext.addParametersInterceptor(
interceptor: ParametersInterceptor
) {
plugin(StateParametersPlugin).addParametersInterceptor(
context = this,
interceptor = interceptor
)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/parameters/interceptor/StateContext.kt | 2411110107 |
package ksm.navigation.state.parameters.interceptor
import ksm.typed.TypedValue
public interface ParametersInterceptor {
public fun onPut(key: String, value: TypedValue<*>) {}
public fun <T> onReceive(key: String): TypedValue.Generic<T>? = null
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/parameters/interceptor/ParametersInterceptor.kt | 2667994892 |
package ksm.navigation.state
import ksm.StateController
import ksm.context.StateContext
import ksm.context.createChildContext
import ksm.navigation.state.data.setStateData
import ksm.navigation.state.name.setName
import ksm.typed.TypedValue
public inline fun <reified T> StateController.navigate(
name: String,
data: T
) {
navigate(name, TypedValue.of(data))
}
public fun StateController.navigate(
name: String,
data: TypedValue<*> = TypedValue.of(Unit)
) {
context.navigate(name, data)
}
public inline fun <reified T> StateContext.navigate(
name: String,
data: T
) {
navigate(name, TypedValue.of(data))
}
public inline fun StateContext.navigate(
name: String,
data: TypedValue<*> = TypedValue.of(Unit),
setup: (StateContext) -> Unit = {}
) {
createChildContext { child ->
child.setName(name)
child.setStateData(data)
setup(child)
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/Navigate.kt | 1586540053 |
package ksm.navigation.state.name
import ksm.context.StateContext
import ksm.navigation.state.name.plugin.StateNamePlugin
import ksm.plugin.plugin
public fun StateContext.setName(name: String) {
plugin(StateNamePlugin).setName(
context = this,
name = name
)
}
public val StateContext.name: String get() {
return stateNameOrNull ?: error("Current state has no name")
}
public val StateContext.stateNameOrNull: String? get() {
return plugin(StateNamePlugin).stateName(context = this)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/name/StateContext.kt | 1063396473 |
package ksm.navigation.state.name.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.plugin.Plugin
public object StateNamePlugin : Plugin.Singleton<StateNamePlugin> {
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
return context + StateNameEntry()
}
}
public fun setName(
context: StateContext,
name: String
) {
context.require(StateNameEntry).name = name
}
public fun stateName(context: StateContext): String? {
return context.require(StateNameEntry).name
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/name/plugin/StateNamePlugin.kt | 2080184802 |
package ksm.navigation.state.name.plugin
import ksm.context.StateContext
internal class StateNameEntry : StateContext.Element {
override val key = StateNameEntry
var name: String? = null
companion object : StateContext.Key<StateNameEntry>
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/name/plugin/StateNameEntry.kt | 2377907711 |
package ksm.navigation.state.name
import ksm.navigation.state.builder.StateBuilderScope
import ksm.navigation.state.builder.StateRouteScope
public inline fun StateRouteScope.named(
string: String,
block: StateBuilderScope.() -> Unit
) {
intercept(
predicate = { stateRouteContextForFilter.stateNameOrNull == string },
block = block
)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/name/StateRouteScope.kt | 66224210 |
package ksm.navigation.state.data
import ksm.StateController
public inline fun <reified T> StateController.receive(): T {
return context.receive()
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/data/NavigationController.kt | 3100964558 |
package ksm.navigation.state.data
import ksm.context.StateContext
import ksm.navigation.state.parameters.receiveParameter
import ksm.navigation.state.parameters.setParameter
import ksm.typed.TypedValue
import kotlin.reflect.KType
public const val STATE_DATA_KEY: String = "ksm.state.data.STATE_DATA"
public inline fun <reified T> StateContext.setStateData(value: T) {
setStateData(TypedValue.of(value))
}
public fun StateContext.setStateData(value: TypedValue<*>) {
setParameter(STATE_DATA_KEY, value)
}
public inline fun <reified T> StateContext.receive(): T {
return receiveParameter<T>(STATE_DATA_KEY) ?: error("Data is not provided")
}
public fun StateContext.receive(type: KType): Any? {
return receiveParameter(STATE_DATA_KEY, type)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/data/StateContext.kt | 3047671758 |
package ksm.navigation.state.builder
import ksm.navigation.annotation.StateBuilderDSL
import ksm.context.StateContext
@StateBuilderDSL
public class StateRouteScope(
public val stateRouteContextForFilter: StateContext
) {
internal var intercepted = false
public fun intercept() {
require(!intercepted) { "State was already intercepted" }
intercepted = true
}
public inline fun intercept(
predicate: () -> Boolean,
block: StateBuilderScope.() -> Unit
) {
if (predicate()) {
intercept()
block(StateBuilderScope(stateRouteContextForFilter))
}
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/builder/StateRouteScope.kt | 1727626989 |
package ksm.navigation.state.builder
import ksm.builder.StateControllerBuilder
import ksm.context.StateContext
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
public fun StateControllerBuilder.states(block: StateRouteScope.() -> Unit) {
val interceptor = object : LifecycleInterceptor {
override fun onCreate(context: StateContext) {
val scope = StateRouteScope(context)
block(scope)
if (!scope.intercepted) {
error("Cannot launch state because there is no handlers for this")
}
}
}
context.addLifecycleInterceptor(interceptor)
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/builder/StateControllerBuilder.kt | 1341532065 |
package ksm.navigation.state.builder
import ksm.navigation.annotation.StateBuilderDSL
import ksm.context.StateContext
@StateBuilderDSL
public class StateBuilderScope(public val context: StateContext)
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/state/builder/StateBuilderScope.kt | 1000580707 |
package ksm.navigation.stack
import ksm.StateController
import ksm.asStateController
public val StateController.previous: StateController get() {
return context.previousContext.asStateController()
}
public val StateController.root: StateController get() {
return context.rootContext.asStateController()
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/NavigationController.kt | 3214128127 |
@file:OptIn(InstallStackPlugin::class)
package ksm.navigation.stack
import ksm.context.StateContext
import ksm.navigation.annotation.InstallStackPlugin
import ksm.navigation.stack.plugin.StackPlugin
public val StateContext.previousContext: StateContext
get() = previousContextOrNull ?: error("Cannot get previous context")
public val StateContext.previousContextOrNull: StateContext?
get() = this[StackPlugin]?.previousContextOrNull(context = this)
public val StateContext.hasPreviousContext: Boolean get() {
return previousContextOrNull != null
}
public val StateContext.nextContext: StateContext
get() = nextContextOrNull ?: error("Cannot get next context")
public val StateContext.nextContextOrNull: StateContext?
get() = this[StackPlugin]?.nextContextOrNull(context = this)
public val StateContext.lastContext: StateContext get() {
var context: StateContext = this
while (context.hasNextContext) {
context = nextContext
}
return context
}
public val StateContext.hasNextContext: Boolean
get() = nextContextOrNull != null
public val StateContext.rootContext: StateContext get() {
var context: StateContext = this
while (context.hasPreviousContext) {
context = previousContext
}
return context
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/StateContext.kt | 886128158 |
package ksm.navigation.stack.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.plugin.Plugin
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import ksm.lifecycle.plugin.LifecyclePlugin
import ksm.navigation.annotation.InstallStackPlugin
@InstallStackPlugin
public object StackPlugin : Plugin.Singleton<StackPlugin> {
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
val previousEntry = context[NavigationStackEntry]
context[LifecyclePlugin]?.onPause(context)
val entry = NavigationStackEntry(previousEntry)
context.addLifecycleInterceptor(Lifecycle(entry))
return context + entry
}
}
private class Lifecycle(val entry: NavigationStackEntry) : LifecycleInterceptor {
override fun onCreate(context: StateContext) {
entry.attachContext(context)
}
override fun onFinish(context: StateContext) {
entry.onFinish()
}
}
public fun previousContextOrNull(context: StateContext): StateContext? {
return context.require(NavigationStackEntry).previousContext
}
public fun nextContextOrNull(
context: StateContext
): StateContext? {
return context.require(NavigationStackEntry).nextContext
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/plugin/StackPlugin.kt | 4284615880 |
package ksm.navigation.stack.plugin
import ksm.context.StateContext
import ksm.context.finish
internal class NavigationStackEntry(
private val previousEntry: NavigationStackEntry?
) : StateContext.Element {
override val key = NavigationStackEntry
val previousContext: StateContext? get() = previousEntry?.context
private lateinit var context: StateContext
var nextContext: StateContext? = null
private set
fun attachContext(context: StateContext) {
this.context = context
previousEntry?.nextContext = context
}
fun onFinish() {
previousEntry?.nextContext = null
nextContext?.finish()
}
companion object : StateContext.Key<NavigationStackEntry>
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/plugin/NavigationStackEntry.kt | 1123301469 |
package ksm.navigation.stack.lifecycle.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.plugin.LifecyclePlugin
import ksm.plugin.Plugin
// This plugin is installed before any of navigation plugins
public object FirstStackLifecyclePlugin : Plugin.Singleton<FirstStackLifecyclePlugin> {
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
// Called before any plugin that should know about stack, because
// FirstStackLifecyclePlugin is installed first after core plugins
// which don't need to know about stack
context[LifecyclePlugin]?.onPause(context)
return context
}
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/lifecycle/plugin/FirstStackLifecyclePlugin.kt | 147784882 |
package ksm.navigation.stack.lifecycle.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import ksm.lifecycle.plugin.LifecyclePlugin
import ksm.navigation.stack.previousContextOrNull
import ksm.plugin.Plugin
// This plugin is installed after any of navigation plugins
public object LastStackLifecyclePlugin : Plugin.Singleton<FirstStackLifecyclePlugin> {
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
context.addLifecycleInterceptor(Lifecycle)
return context
}
}
private object Lifecycle : LifecycleInterceptor {
override fun onFinish(context: StateContext) {
// Called after any plugin that should know about stack, because
// LastStackLifecyclePlugin is installed last before core plugins
// which don't need to know about stack
context.previousContextOrNull
?.get(LifecyclePlugin)
?.onResume(context)
}
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/lifecycle/plugin/LastStackLifecyclePlugin.kt | 3316671974 |
package ksm.navigation.stack
import ksm.builder.StateControllerBuilder
import ksm.navigation.annotation.InstallStackPlugin
import ksm.navigation.stack.lifecycle.plugin.FirstStackLifecyclePlugin
import ksm.navigation.stack.lifecycle.plugin.LastStackLifecyclePlugin
import ksm.navigation.stack.plugin.StackPlugin
@OptIn(InstallStackPlugin::class)
public inline fun StateControllerBuilder.installStackPlugin(
enabled: Boolean,
block: () -> Unit
) {
if (enabled) {
install(FirstStackLifecyclePlugin)
install(StackPlugin)
block()
install(LastStackLifecyclePlugin)
} else {
block()
}
}
| ksm/navigation/src/commonMain/kotlin/ksm/navigation/stack/StateControllerBuilder.kt | 1586983004 |
import ksm.annotation.LibraryConstructor
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import ksm.navigation.state.name.name
import ksm.navigation.state.navigate
import ksm.navigation.navigationStateController
import ksm.plugin.Plugin
import kotlin.test.Test
class KsmTest {
@OptIn(LibraryConstructor::class)
@Test
fun ksmTest() {
val controller = navigationStateController {
install(PrintPlugin)
}
controller.navigate("Start")
}
}
object PrintPlugin : Plugin.Singleton<PrintPlugin> {
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
context.addLifecycleInterceptor(Lifecycle)
return context
}
}
private object Lifecycle : LifecycleInterceptor {
override fun onCreate(context: StateContext) {
println("Hello, current state = ${context.name}")
}
}
}
| ksm/navigation/src/commonTest/kotlin/Test.kt | 915573668 |
import org.gradle.api.Project
fun Project.versionFromProperties(acceptor: (String) -> Unit) {
afterEvaluate {
acceptor(versionFromProperties())
}
}
fun Project.versionFromProperties(): String {
val snapshot = project.findProperty("snapshot")?.toString()?.toBooleanStrict()
if (snapshot == null || !snapshot) return project.version.toString()
val commit = project.property("commit").toString()
val attempt = project.property("attempt").toString().toInt()
val version = buildString {
append(project.version)
append("-build")
append(commit.take(n = 7))
if (attempt > 1) {
append(attempt)
}
}
return version
}
| ksm/build-logic/src/main/kotlin/Version.kt | 2022557851 |
package ksm.coroutines
import kotlinx.coroutines.CoroutineScope
import ksm.context.StateContext
import ksm.coroutines.interceptor.AwaitInterceptor
import ksm.coroutines.plugin.AwaitPlugin
import ksm.coroutines.plugin.CoroutinesPlugin
import ksm.plugin.plugin
import kotlin.coroutines.CoroutineContext
public val StateContext.scope: CoroutineScope get() {
return plugin(CoroutinesPlugin).coroutineScope(context = this)
}
public fun StateContext.addAwaitInterceptor(interceptor: AwaitInterceptor) {
plugin(AwaitPlugin).addAwaitInterceptor(
context = this,
interceptor = interceptor
)
}
public suspend fun StateContext.await() {
plugin(AwaitPlugin).await(context = this)
}
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/StateContext.kt | 1587333195 |
package ksm.coroutines.plugin
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.awaitCancellation
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.plugin.Plugin
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.context.finish
import ksm.lifecycle.LifecycleInterceptor
import ksm.lifecycle.addLifecycleInterceptor
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
public class CoroutinesPlugin(
private val scope: CoroutineScope
) : Plugin {
override val key: Companion = CoroutinesPlugin
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration())
return context
}
private inner class Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
val entry = CoroutinesEntry(context, scope)
context.addLifecycleInterceptor(Lifecycle(entry))
return context + entry
}
}
private inner class Lifecycle(val entry: CoroutinesEntry) : LifecycleInterceptor {
override fun onCreate(context: StateContext) {
if (!entry.coroutineScope.isActive)
error("Cannot start a new state because coroutineScope was already finished")
entry.coroutineScope.launch {
try {
awaitCancellation()
} finally {
context.finish()
}
}
}
override fun onFinish(context: StateContext) { entry.cancel() }
}
public fun coroutineScope(context: StateContext): CoroutineScope {
return context.require(CoroutinesEntry).coroutineScope
}
public companion object : StateContext.Key<CoroutinesPlugin>
}
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/plugin/CoroutinesPlugin.kt | 2936457660 |
package ksm.coroutines.plugin
import ksm.context.StateContext
import ksm.coroutines.interceptor.AwaitInterceptor
internal class AwaitEntry : StateContext.Element {
override val key = AwaitEntry
private val awaitInterceptors = mutableListOf<AwaitInterceptor>()
suspend fun await() {
for (interceptor in awaitInterceptors) {
interceptor.await()
}
}
fun addAwaitInterceptor(interceptor: AwaitInterceptor) {
awaitInterceptors += interceptor
}
companion object : StateContext.Key<AwaitEntry>
}
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/plugin/AwaitEntry.kt | 3048263534 |
package ksm.coroutines.plugin
import kotlinx.coroutines.*
import ksm.context.StateContext
import kotlin.coroutines.CoroutineContext
internal class CoroutinesEntry(
context: StateContext,
initialCoroutineScope: CoroutineScope
) : StateContext.Element {
override val key = CoroutinesEntry
val coroutineScope: CoroutineScope
init {
val parentCoroutineScope = context[CoroutinesEntry]
?.coroutineScope
?: initialCoroutineScope
val parentJob = parentCoroutineScope.coroutineContext[Job]
val job = Job(parentJob)
coroutineScope = parentCoroutineScope + job
}
fun cancel() = coroutineScope.cancel()
companion object : StateContext.Key<CoroutinesEntry>
}
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/plugin/CoroutinesEntry.kt | 2037372760 |
package ksm.coroutines.plugin
import ksm.annotation.MutateContext
import ksm.context.StateContext
import ksm.context.configuration.interceptor.ConfigurationInterceptor
import ksm.context.configuration.interceptor.addConfigurationInterceptor
import ksm.coroutines.interceptor.AwaitInterceptor
import ksm.plugin.Plugin
public object AwaitPlugin : Plugin.Singleton<AwaitPlugin> {
@MutateContext
override fun install(context: StateContext): StateContext {
context.addConfigurationInterceptor(Configuration)
return context
}
private object Configuration : ConfigurationInterceptor {
@MutateContext
override fun onConfigure(context: StateContext): StateContext {
return context + AwaitEntry()
}
}
public suspend fun await(context: StateContext) {
context.require(AwaitEntry).await()
}
public fun addAwaitInterceptor(
context: StateContext,
interceptor: AwaitInterceptor
) {
context.require(AwaitEntry).addAwaitInterceptor(interceptor)
}
}
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/plugin/AwaitPlugin.kt | 3955507422 |
package ksm.coroutines
import kotlinx.coroutines.CoroutineScope
import ksm.StateController
public val StateController.scope: CoroutineScope
get() = context.scope
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/StateController.kt | 553474037 |
package ksm.coroutines.interceptor
public fun interface AwaitInterceptor {
public suspend fun await()
}
| ksm/kotlinx-coroutines/src/commonMain/kotlin/ksm/coroutines/interceptor/AwaitInterceptor.kt | 1895061554 |
package com.example.routes
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import io.ktor.server.testing.*
import kotlin.test.Test
import kotlin.test.assertEquals
class OrderRouteTest {
@Test
fun testGetOrder() = testApplication {
val response: HttpResponse = client.get("/order/2020-04-06-01")
assertEquals(
"""{"number":"2020-04-06-01","contents":[{"item":"Ham Sandwich","amount":2,"price":5.5},{"item":"Water","amount":1,"price":1.5},{"item":"Beer","amount":3,"price":2.3},{"item":"Cheesecake","amount":1,"price":3.75}]}""",
response.bodyAsText()
)
assertEquals(HttpStatusCode.OK, response.status)
}
} | ktor-api/src/test/kotlin/com/example/routes/OrderRouteTest.kt | 3176622910 |
package com.example
import com.example.dao.DatabaseSingleton
import com.example.plugins.*
import io.ktor.server.application.*
import io.ktor.server.routing.*
fun main(args: Array<String>) {
io.ktor.server.netty.EngineMain.main(args)
}
fun Application.module() {
DatabaseSingleton.init()
configureSerialization()
configureRouting()
routing {
}
}
| ktor-api/src/main/kotlin/com/example/Application.kt | 3307940520 |
package com.example.plugins
import com.example.routes.customerRouting
import com.example.routes.getOrderRoute
import com.example.routes.listOrderRoute
import com.example.routes.totalizeOrderRoute
import io.ktor.server.application.*
import io.ktor.server.routing.*
fun Application.configureRouting() {
routing {
customerRouting()
getOrderRoute()
listOrderRoute()
totalizeOrderRoute()
}
}
| ktor-api/src/main/kotlin/com/example/plugins/Routing.kt | 1655792440 |
package com.example.plugins
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.plugins.contentnegotiation.*
fun Application.configureSerialization() {
install(ContentNegotiation) {
json()
}
}
| ktor-api/src/main/kotlin/com/example/plugins/Serialization.kt | 2448232293 |
package com.example.dao
import com.example.models.Customers
import kotlinx.coroutines.Dispatchers
import org.jetbrains.exposed.sql.Database
import org.jetbrains.exposed.sql.SchemaUtils
import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
import org.jetbrains.exposed.sql.transactions.transaction
object DatabaseSingleton {
fun init() {
val driverClassName = "org.h2.Driver"
val jdbcURL = "jdbc:h2:file:/Users/blue/db"
val database = Database.connect(jdbcURL, driverClassName)
transaction(database) {
// 테이블 생성
SchemaUtils.create(Customers)
}
}
suspend fun <T> dbQuery(block: suspend () -> T): T = newSuspendedTransaction(Dispatchers.IO) { block() }
} | ktor-api/src/main/kotlin/com/example/dao/DatabaseSingleton.kt | 2909703202 |
package com.example.dao
import com.example.models.Customer
interface DAOFacade {
suspend fun allCustomer() : List<Customer>
suspend fun getCustomer(id: String) : Customer?
suspend fun addCustomer(customer: Customer) : Customer?
suspend fun editCustomer(customer: Customer) : Boolean
suspend fun removeCustomer(id: String) : Boolean
} | ktor-api/src/main/kotlin/com/example/dao/DAOFacade.kt | 1748489937 |
package com.example.dao
import com.example.dao.DatabaseSingleton.dbQuery
import com.example.models.Customer
import com.example.models.Customers
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
class DAOFacadeImpl : DAOFacade {
private fun resultRowToCustomer(row:ResultRow) = Customer(
id = row[Customers.id],
firstName = row[Customers.firstName],
lastName = row[Customers.lastName],
email = row[Customers.email]
)
override suspend fun allCustomer(): List<Customer> = dbQuery {
Customers.selectAll().map(::resultRowToCustomer)
}
override suspend fun getCustomer(id: String): Customer? = dbQuery {
Customers
.select { Customers.id eq id }
.map(::resultRowToCustomer)
.singleOrNull()
}
override suspend fun addCustomer(customer: Customer): Customer? = dbQuery {
val insertStatement = Customers.insert {
it[Customers.id] = customer.id
it[Customers.firstName] = customer.firstName
it[Customers.lastName] = customer.lastName
it[Customers.email] = customer.email
}
insertStatement.resultedValues?.singleOrNull()?.let(::resultRowToCustomer)
}
override suspend fun editCustomer(customer: Customer):Boolean = dbQuery {
Customers
.update({ Customers.id eq customer.id }) {
it[Customers.firstName] = customer.firstName
it[Customers.lastName] = customer.lastName
it[Customers.email] = customer.email
} > 0
}
override suspend fun removeCustomer(id: String): Boolean = dbQuery {
Customers.deleteWhere { Customers.id eq id } > 0
}
} | ktor-api/src/main/kotlin/com/example/dao/DAOFacadeImpl.kt | 3279685998 |
package com.example.models
import kotlinx.serialization.Serializable
import org.jetbrains.exposed.sql.Table
@Serializable
data class Customer (
val id : String,
val firstName: String,
val lastName: String,
val email: String,
)
object Customers : Table() {
val id = varchar("id", 10)
val firstName = varchar("firstName", 50)
val lastName = varchar("lastName", 50)
val email = varchar("email", 50)
override val primaryKey = PrimaryKey(id)
}
val customerStorage = mutableListOf<Customer>() | ktor-api/src/main/kotlin/com/example/models/Customer.kt | 4157376528 |
package com.example.models
import kotlinx.serialization.Serializable
@Serializable
data class Order(val number: String, val contents: List<OrderItem>)
@Serializable
data class OrderItem(val item: String, val amount: Int, val price: Double)
val orderStorage = listOf(Order(
"2020-04-06-01", listOf(
OrderItem("Ham Sandwich", 2, 5.50),
OrderItem("Water", 1, 1.50),
OrderItem("Beer", 3, 2.30),
OrderItem("Cheesecake", 1, 3.75)
)),
Order("2020-04-03-01", listOf(
OrderItem("Cheeseburger", 1, 8.50),
OrderItem("Water", 2, 1.50),
OrderItem("Coke", 2, 1.76),
OrderItem("Ice Cream", 1, 2.35)
))
) | ktor-api/src/main/kotlin/com/example/models/Order.kt | 2402085032 |
package com.example.routes
import com.example.dao.DAOFacade
import com.example.dao.DAOFacadeImpl
import com.example.models.Customer
import com.example.models.customerStorage
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import kotlinx.coroutines.runBlocking
fun Route.customerRouting() {
val dao: DAOFacade = DAOFacadeImpl()
route("/customer") {
get {
if (customerStorage.isNotEmpty()) {
call.respond(dao.allCustomer())
} else {
call.respondText("No customer found", status = HttpStatusCode.NotFound)
}
}
get("{id?}") {
val id = call.parameters["id"] ?: return@get call.respondText(
"Missing id",
status = HttpStatusCode.BadRequest
)
val customer = dao.getCustomer(call.parameters["id"]!!) ?: return@get call.respondText(
"No customer with id $id",
status = HttpStatusCode.NotFound
)
call.respond(customer)
}
post {
val customer = call.receive<Customer>()
dao.addCustomer(customer)
call.respondText("Customer stored correctly", status = HttpStatusCode.Created)
}
delete("{id?}") {
val id = call.parameters["id"] ?: return@delete call.respond(HttpStatusCode.BadRequest)
if (dao.removeCustomer(id)) {
call.respondText("Customer removed correctly", status = HttpStatusCode.Accepted)
} else {
call.respondText("Not found", status = HttpStatusCode.NotFound)
}
}
}
} | ktor-api/src/main/kotlin/com/example/routes/CustomerRoutes.kt | 953305900 |
package com.example.routes
import com.example.models.orderStorage
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
fun Route.listOrderRoute() {
get("/order") {
if (orderStorage.isNotEmpty()) {
call.respond(orderStorage)
}
}
}
fun Route.getOrderRoute() {
get("/order/{id}") {
val id = call.parameters["id"] ?: return@get call.respondText(
"Bad Request",
status = HttpStatusCode.BadRequest
)
val order = orderStorage.find { it.number == id } ?: return@get call.respondText(
"No found",
status = HttpStatusCode.NotFound
)
call.respond(order)
}
}
fun Route.totalizeOrderRoute() {
get("/order/{id}/total") {
val id = call.parameters["id"] ?: return@get call.respondText(
"Bad Request",
status = HttpStatusCode.BadRequest
)
val order = orderStorage.find { it.number == id } ?: return@get call.respondText(
"No found",
status = HttpStatusCode.NotFound
)
val total = order.contents.sumOf { it.price * it.amount}
call.respond(total)
}
} | ktor-api/src/main/kotlin/com/example/routes/OrderRoutes.kt | 1179985184 |
package ayds.songinfo.home.controller
import ayds.songinfo.home.model.HomeModelInjector
import ayds.songinfo.home.view.HomeView
object HomeControllerInjector {
fun onViewStarted(homeView: HomeView) {
ayds.songinfo.home.controller.HomeControllerImpl(HomeModelInjector.getHomeModel()).apply {
setHomeView(homeView)
}
}
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/controller/HomeControllerInjector.kt | 3076531351 |
package ayds.songinfo.home.controller
import ayds.observer.Observer
import ayds.songinfo.home.model.HomeModel
import ayds.songinfo.home.model.entities.Song
import ayds.songinfo.home.view.HomeUiEvent
import ayds.songinfo.home.view.HomeView
interface HomeController {
fun setHomeView(homeView: HomeView)
}
internal class HomeControllerImpl(
private val homeModel: HomeModel
) : ayds.songinfo.home.controller.HomeController {
private lateinit var homeView: HomeView
override fun setHomeView(homeView: HomeView) {
this.homeView = homeView
homeView.uiEventObservable.subscribe(observer)
}
private val observer: Observer<HomeUiEvent> =
Observer { value ->
when (value) {
HomeUiEvent.Search -> searchSong()
HomeUiEvent.MoreDetails -> moreDetails()
is HomeUiEvent.OpenSongUrl -> openSongUrl()
}
}
private fun searchSong() {
// Warning: Never use Thread in android! Use coroutines
Thread {
homeModel.searchSong(homeView.uiState.searchTerm)
}.start()
}
private fun moreDetails() {
Thread {
val song = homeModel.getSongById(homeView.uiState.songId)
(song as? Song.SpotifySong)?.let {
homeView.navigateToOtherDetails(song.artistName)
}
}.start()
}
private fun openSongUrl() {
homeView.openExternalLink(homeView.uiState.songUrl)
}
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/controller/HomeController.kt | 3598395162 |
package ayds.songinfo.home.model.repository
import ayds.songinfo.home.model.entities.Song.EmptySong
import ayds.songinfo.home.model.entities.Song
import ayds.songinfo.home.model.entities.Song.SpotifySong
import ayds.songinfo.home.model.repository.external.spotify.SpotifyTrackService
import ayds.songinfo.home.model.repository.local.spotify.SpotifyLocalStorage
interface SongRepository {
fun getSongByTerm(term: String): Song
fun getSongById(id: String): Song
}
internal class SongRepositoryImpl(
private val spotifyLocalStorage: SpotifyLocalStorage,
private val spotifyTrackService: SpotifyTrackService
) : SongRepository {
override fun getSongByTerm(term: String): Song {
var spotifySong = spotifyLocalStorage.getSongByTerm(term)
when {
spotifySong != null -> markSongAsLocal(spotifySong)
else -> {
try {
spotifySong = spotifyTrackService.getSong(term)
(spotifySong as? SpotifySong)?.let {
when {
it.isSavedSong() -> spotifyLocalStorage.updateSongTerm(term, it.id)
else -> spotifyLocalStorage.insertSong(term, it)
}
}
} catch (e: Exception) {
spotifySong = null
}
}
}
return spotifySong ?: EmptySong
}
override fun getSongById(id: String): Song {
return spotifyLocalStorage.getSongById(id) ?: EmptySong
}
private fun SpotifySong.isSavedSong() = spotifyLocalStorage.getSongById(id) != null
private fun markSongAsLocal(song: SpotifySong) {
song.isLocallyStored = true
}
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/SongRepository.kt | 2474562085 |
package ayds.songinfo.home.model.repository.local.spotify.room
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
import androidx.room.Update
@Dao
interface SongDao {
@Update
fun updateSong(song: SongEntity)
@Insert
fun insertSong(song: SongEntity)
@Query("SELECT * FROM songentity WHERE term LIKE :term LIMIT 1")
fun getSongByTerm(term: String): SongEntity?
@Query("SELECT * FROM songentity WHERE id LIKE :id LIMIT 1")
fun getSongById(id: String): SongEntity?
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/local/spotify/room/SongDao.kt | 1858331720 |
package ayds.songinfo.home.model.repository.local.spotify.room
import androidx.room.Database
import androidx.room.RoomDatabase
@Database(entities = [SongEntity::class], version = 1)
abstract class SongDatabase : RoomDatabase() {
abstract fun songDao(): SongDao
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/local/spotify/room/SongDatabase.kt | 2494698098 |
package ayds.songinfo.home.model.repository.local.spotify.room
import ayds.songinfo.home.model.entities.Song.SpotifySong
import ayds.songinfo.home.model.repository.local.spotify.SpotifyLocalStorage
internal class SpotifyLocalStorageRoomImpl(
dataBase: SongDatabase,
) : SpotifyLocalStorage {
private val songDao: SongDao = dataBase.songDao()
override fun updateSongTerm(query: String, songId: String) {
}
override fun updateSongTerm(query: String, song: SpotifySong) {
songDao.updateSong(song.toSongEntity(query))
}
override fun insertSong(query: String, song: SpotifySong) {
songDao.insertSong(song.toSongEntity(query))
}
override fun getSongByTerm(term: String): SpotifySong? {
return songDao.getSongByTerm(term)?.toSpotifySong()
}
override fun getSongById(id: String): SpotifySong? {
return songDao.getSongById(id)?.toSpotifySong()
}
private fun SpotifySong.toSongEntity(term: String) = SongEntity(
this.id,
term,
this.songName,
this.artistName,
this.albumName,
this.releaseDate,
this.spotifyUrl,
this.imageUrl,
this.releaseDatePrecision
)
private fun SongEntity.toSpotifySong() = SpotifySong(
this.id,
this.songName,
this.artistName,
this.albumName,
this.releaseDate,
this.spotifyUrl,
this.imageUrl,
this.releaseDatePrecision
)
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/local/spotify/room/SpotifyLocalStorageRoomImpl.kt | 3582534276 |
package ayds.songinfo.home.model.repository.local.spotify.room
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity
data class SongEntity(
@PrimaryKey val id: String,
val term: String,
val songName: String,
val artistName: String,
val albumName: String,
val releaseDate: String,
val spotifyUrl: String,
val imageUrl: String,
val releaseDatePrecision: String
) | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/local/spotify/room/SongEntity.kt | 3783963555 |
package ayds.songinfo.home.model.repository.local.spotify
import ayds.songinfo.home.model.entities.Song.SpotifySong
interface SpotifyLocalStorage {
fun updateSongTerm(query: String, songId: String)
fun updateSongTerm(query: String, song: SpotifySong)
fun insertSong(query: String, song: SpotifySong)
fun getSongByTerm(term: String): SpotifySong?
fun getSongById(id: String): SpotifySong?
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/local/spotify/SpotifyLocalStorage.kt | 2008533702 |
package ayds.songinfo.home.model.repository.external.spotify
import ayds.songinfo.home.model.entities.Song.SpotifySong
interface SpotifyTrackService {
fun getSong(title: String): SpotifySong?
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/external/spotify/SpotifyTrackService.kt | 3135009795 |
package ayds.songinfo.home.model.repository.external.spotify
import ayds.songinfo.home.model.repository.external.spotify.tracks.*
object SpotifyInjector {
val spotifyTrackService: SpotifyTrackService = SpotifyTrackInjector.spotifyTrackService
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/external/spotify/SpotifyInjector.kt | 587856873 |
package ayds.songinfo.home.model.repository.external.spotify.auth
import retrofit2.Retrofit
import retrofit2.converter.scalars.ScalarsConverterFactory
object SpotifyAuthInjector {
private const val SPOTIFY_ACCOUNTS_URL = "https://accounts.spotify.com/api/"
private val spotifyAccountRetrofit = Retrofit.Builder()
.baseUrl(SPOTIFY_ACCOUNTS_URL)
.addConverterFactory(ScalarsConverterFactory.create())
.build()
private val spotifyTokenAPI = spotifyAccountRetrofit.create(SpotifyAuthAPI::class.java)
private val spotifyToTokenResolver: SpotifyToTokenResolver = JsonToTokenResolver()
val spotifyAccountService: SpotifyAccountService =
SpotifyAccountServiceImpl(spotifyTokenAPI, spotifyToTokenResolver)
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/external/spotify/auth/SpotifyAuthInjector.kt | 2292960787 |
package ayds.songinfo.home.model.repository.external.spotify.auth
import okhttp3.RequestBody
import retrofit2.Call
import retrofit2.http.*
internal interface SpotifyAuthAPI {
@POST("token")
fun getToken(
@Header("Authorization") credential: String,
@Body tokenRequest: RequestBody
): Call<String>
} | AyDS-SongInfo/app/src/main/java/ayds/songinfo/home/model/repository/external/spotify/auth/SpotifyAuthAPI.kt | 3245791214 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.