Didn't want to pollute the #29 feature request, so I'm opening a new question (or bug) issue. :-)

I tried to make a custom serializer as you suggested, following the official example https://github.com/Kotlin/kotlinx.serialization/blob/v0.20.0/runtime/commonTest/src/kotlinx/serialization/json/JsonTreeAndMapperTest.kt#L35 that is linked to from the docs about custom serializers.

In the GitHub action yml file you can have

outputs:
    foo:
        description: bar
        value: baz

runs:
    using: composite

or

outputs:
    foo:
        description: bar

runs:
    using: something else

Meaning the output has a mandatory value property if it is a composite action but no value property if it is a normal action.

Previously I didn't support composite, so I had

@Serializable
data class GitHubAction(
        /* ... */
        val outputs: Map<String, Output>? = null,
        /* ... */
) {
    /* ... */
    @Serializable
    data class Output(
            val description: String
    )
    /* ... */
}

I now changed it to

@Serializable
data class GitHubAction(
        /* ... */
        val outputs: Map<String, Output>? = null,
        /* ... */
) {
    /* ... */
    sealed class Output {
        abstract val description: String

        data class NormalOutput(
                override val description: String
        ) : Output()

        data class CompositeOutput(
                override val description: String,
                val value: String
        ) : Output()

        @Serializer(forClass = Output::class)
        companion object : KSerializer<Output> {
            override val descriptor: SerialDescriptor = SerialDescriptor("net.kautler.dao.GitHubAction.Output", SEALED) {
                element("normal", SerialDescriptor("net.kautler.dao.GitHubAction.Output.NormalOutput") {
                    element("description", PrimitiveDescriptor("net.kautler.dao.GitHubAction.Output.NormalOutput.description", STRING))
                })
                element("composite", SerialDescriptor("net.kautler.dao.GitHubAction.Output.CompositeOutput") {
                    element("description", PrimitiveDescriptor("net.kautler.dao.GitHubAction.Output.CompositeOutput.description", STRING))
                    element("value", PrimitiveDescriptor("net.kautler.dao.GitHubAction.Output.CompositeOutput.value", STRING))
                })
            }

            override fun deserialize(decoder: Decoder): Output {
                TODO("deserialize: Not yet implemented")
            }

            override fun serialize(encoder: Encoder, value: Output) {
                TODO("serialize: Not yet implemented")
            }
        }
    }
    /* ... */
}

The problem is, that it seems to not being used. When I had a TODO() in the descriptor it failed accordingly. But when I now try to deserialize an action file, I get complaint from kaml about missing type tag instead of the custom serializer being used. Do I do something wrong or is there a bug in kaml?

I tried to use kaml in an unrelated project and was unable to make Idea happy with it. I have the latest version of Idea for macOS 2019.3.

So I git cloned your repo to see how it fares and see the same issues

Have you found some magic to convince IJ to work with you? Care to share that magic? thx!

Describe the bug

Hey, TBH I'm not sure if this is a bug or just not implemented yet, I'm very new to Kotlin Multiplatform :) I'm trying to leverage Kaml to deserialize some YAML files in a MPP project, but it seems like trying to leverage Kaml in commonMain is not implemented yet when targeting non-JVM applications.

FAILURE: Build failed with an exception.

* What went wrong:
Could not determine the dependencies of task ':satisfaketion-generators:jsTestPackageJson'.
> Could not resolve all dependencies for configuration ':satisfaketion-generators:jsTestNpm'.
   > Could not resolve com.charleskorn.kaml:kaml:0.40.0.
     Required by:
         project :satisfaketion-generators
      > No matching variant of com.charleskorn.kaml:kaml:0.40.0 was found. The consumer was configured to find a usage of 'kotlin-runtime' of a library, preferably optimized for non-jvm, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'js', attribute 'org.jetbrains.kotlin.js.compiler' with value 'ir' but:
          - Variant 'jvmApiElements-published' capability com.charleskorn.kaml:kaml:0.40.0 declares a library:
              - Incompatible because this component declares an API of a component, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm' and the consumer needed a usage of 'kotlin-runtime' of a component, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'js'
              - Other compatible attributes:
                  - Doesn't say anything about its target Java environment (preferred optimized for non-jvm)
                  - Doesn't say anything about org.jetbrains.kotlin.js.compiler (required 'ir')
          - Variant 'jvmRuntimeElements-published' capability com.charleskorn.kaml:kaml:0.40.0 declares a runtime of a library:
              - Incompatible because this component declares a component, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'jvm' and the consumer needed a component, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'js'
              - Other compatible attributes:
                  - Doesn't say anything about its target Java environment (preferred optimized for non-jvm)
                  - Doesn't say anything about org.jetbrains.kotlin.js.compiler (required 'ir')
          - Variant 'metadataApiElements' capability com.charleskorn.kaml:kaml:0.40.0 declares a library:
              - Incompatible because this component declares a usage of 'kotlin-api' of a component, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'common' and the consumer needed a usage of 'kotlin-runtime' of a component, as well as attribute 'org.jetbrains.kotlin.platform.type' with value 'js'
              - Other compatible attributes:
                  - Doesn't say anything about its target Java environment (preferred optimized for non-jvm)
                  - Doesn't say anything about org.jetbrains.kotlin.js.compiler (required 'ir')

Reproduction repo

So, this is the repo I am currently trying to convert to multiplatform https://github.com/unredundant/satisfaketion. More specifically, the generators module. I can't actually push the code b/c I have some (clearly too lofty) git hooks that prevent me from pushing a broken gradle build and I'm too lazy to delete them 😅 If it would really help I can temporarily remove them and push the code. But effectively, I have a gradle build file like this

plugins {
  kotlin("multiplatform")
  // ...
}

// ...

kotlin {
  sourceSets {
    val commonMain by getting {
      dependencies {
        implementation(kotlin("stdlib"))
        api(projects.satisfaketionCore)  // project dependency (also multiplatform)
        implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.2")
        implementation("com.charleskorn.kaml:kaml:0.40.0")
      }
    }
    val commonTest by getting
    val jvmMain by getting 
    val jvmTest by getting
    val jsMain by getting
    val jsTest by getting
    val nativeMain by getting
    val nativeTest by getting
  }
}

which leads to the error posted above.

Steps to reproduce

1. Import kaml dependency into MPP project which targets at least JS (presumably native has same issue?)
2. Try to build
3. ~~Weep~~ Profit?

Expected behaviour

I'm not sure this is expected behavior, but it would be nice if this was supported :)

Actual behaviour

Stacktrace sadness :(

Version information

Kaml 0.40.0
Kotlin 1.6.10

Any other information

No response

This adds ignoreEmptyDocument to the Configuration (default false)

When true, it doesnt throw an EmptyYamlDocumentException when the document is empty.

Solves #284 (from Discussion #281)

Describe the bug

I've written a tiny function to convert YamlNode's into JsonElement's (the stuff I'm reading is always JSON compatible). As part of that I have to convert YamlScalar to JsonPrimitive.

I generally I don't have an issue with kaml's approach to scalars, however it is a little unfortunate that it even loses whether the scalar was a string (as-in: the value was quoted). I'm not sure how much type information snakeyaml profiles, but it would be great to retain as much as possible to make format conversions easier.

My current converter tries to convert the string value from the scalar into the various number types until one of them work. If everything fails I assume it to be a string. However that will lead to scalars like '1' to be interpreted as a number on the JSON side, even through it was originally explicitly quoted.

Reproduction repo

private inline fun <T : Any> tryConversion(conversion: () -> T): T? {
    return try {
        conversion()
    } catch (e: YamlScalarFormatException) {
        null
    }
}


private fun yamlNodeToJsonElement(yamlNode: YamlNode): JsonElement {
    return when (yamlNode) {
        is YamlList -> JsonArray(yamlNode.items.map(::yamlNodeToJsonElement))
        is YamlMap -> JsonObject(yamlNode.entries.map { (key, value) -> Pair(key.content, yamlNodeToJsonElement(value)) }.toMap())
        is YamlNull -> JsonNull
        is YamlScalar -> {
            tryConversion { JsonPrimitive(yamlNode.toBoolean()) }
                ?: tryConversion { JsonPrimitive(yamlNode.toByte()) }
                ?: tryConversion { JsonPrimitive(yamlNode.toShort()) }
                ?: tryConversion { JsonPrimitive(yamlNode.toInt()) }
                ?: tryConversion { JsonPrimitive(yamlNode.toLong()) }
                ?: tryConversion { JsonPrimitive(yamlNode.toFloat()) }
                ?: tryConversion { JsonPrimitive(yamlNode.toDouble()) }
                ?: JsonPrimitive(yamlNode.content)
        }
        is YamlTaggedNode -> yamlNodeToJsonElement(yamlNode.innerNode)
    }
}

Steps to reproduce

use a document like

some-string: '1'

parse it into a YamlNode and convert it to a JsonElement of the same type.

Expected behaviour

Some why to extract type information from the original yaml document.

Actual behaviour

All type information is lost.

Version information

0.46.0

Any other information

No response

Describe the problem you'd like to solve

Sometimes I need to be able to break the glass and serialize/deserialize YAML without having well-structured POJOs/KOJOs.

Describe the solution you'd like

I'd like a canonical "vanilla" representation of YAML. It does not have to implement all YAML features (e.g., SnakeYAML chokes on tags in its vanilla codec implementation, and I'd be fine with that behavior). It could be a codec for YamlNode or Any or a new class created for this purpose.

This would bring it in line with other languages' YAML implementations such as Python's and Ruby's.

Describe alternatives you've considered

A combination of SnakeYAML and Moshi.

Additional context

My context is also multi-document YAML streams from Kubernetes, just like #54 's case.

This adds support for the Flow Style of rendering Sequences, by adding a parameter to YamlConfiguration

The default block style is still used to avoid breaking anything.

This is referenced in #33

Describe the bug

The current code uses for example InputStreamReader(source). This uses the JVM default encoding. From Java 18 on, this will usually be UTF-8 but can also be reconfigured. Before Java 18, this is system dependent and often is not UTF-8. And even if it were always UTF-8, Yaml parsers have to support UTF-8 and UTF-16 with and without BOM for 1.1 and also UTF-32 for 1.2.

From a quick look the writing stream methods always use UTF-8, for those it might be handy to be able to supply the wanted encoding.

But more important, for the reading stream methods you need a detection algorithm with a push-back stream, so that you can detect BOM and act accordingly and if none found, fall back to UTF-8.

You could also consider adding methods that take a Reader / Writer instead as there the encoding is already given by the caller.

Reproduction repo

No response

Steps to reproduce

• have a YAML with ö in it with UTF-8 encoding
• set the jvm default encoding to ISO-8859-1
• deserialize the YAML and you get ö instead of the ö

Expected behaviour

You get ö

Actual behaviour

You get ö

Version information

0.46.0

Any other information

No response

Describe the problem you'd like to solve

The methods on the Yaml object for reading and writing are not balanced.

Describe the solution you'd like

I propose to make decodeFromReader() public, and to add encodeToWriter() and encodeToStream() as encoding methods that correspond to the decoding methods.

Describe alternatives you've considered

No response

Additional context

No response

Describe the problem you'd like to solve

I want to resolve references like this one. The reference points to another node in the same file.

I don't know how I would do this with the normal kotlinx.serialization api, but for the yaml parser itself this should be possible.

Describe the solution you'd like

Could there be an option to enable that these references get resolved automatically?

Describe alternatives you've considered

No response

Additional context

No response

I'm working on a dsl for Azure DevOps YAML Pipelines and they have a block called variables that can contain a few types.

variables:
  # a variable can be created in 2 different ways
  - myVar:  'myVarValue'
  - name: myVar
     value: 'myVarValue'
     readonly: true
  # a group can be created in 1 way, but always has the same key
  - group: myFirstGroup
  - group: mySecondGroup
  - group: myThirdGroup

I've been working on this for a while now and by now I have been able to create a list of Variable

@Serializable
abstract class VariableBase {
    abstract val name: String
}

@Serializable
class Variable(override val name: String, val value: String, val readonly: Boolean = false) : VariableBase()

@Serializable
data class Group(override val name: String) : VariableBase()

@Serializable
class Variables {
    var variables = mutableListOf<VariableBase>()

    fun variable(name: String, value: String, readonly: Boolean = false) {
        this.variables.add(Variable(name, value, readonly))
    }

    fun group(name: String) {
        this.variables.add(Group(name))
    }
}

val variables = Variables()
variables.variable("myVar", "myValue")
variables.group("myFirstGroup")
variables.group("mySecondGroup")
variables.group("myThirdGroup")

val result = Yaml(
    configuration = YamlConfiguration(
        polymorphismStyle = PolymorphismStyle.Property
    ),
    serializersModule = SerializersModule {
        polymorphic(VariableBase::class) {
            subclass(Variable::class)
            subclass(Group::class)
        }
    })
    .encodeToString(Variables.serializer(), variables)

print(result)

This will generate the following output:

variables:
- type: "Variable"
  name: "myVar"
  value: "myValue"
  readonly: false
- type: "Group"
  name: "myFirstGroup"
- type: "Group"
  name: "mySecondGroup"
- type: "Group"
  name: "myThirdGroup"

So how would I be able to create the list that is required to create an Azure DevOps YAML Pipeline variables block?

I guess it might be an idea to add a PolymorphismStyle.None to prevent a type output. I'll create a PR if you think that is a good idea.

This PR contains the following updates:

| Package | Change | Age | Adoption | Passing | Confidence | |---|---|---|---|---|---| | com.pinterest:ktlint | 0.47.1 -> 0.48.1 | | | | |

Release Notes

import java.io.File

// Define a reusable instance of the KtLint Rule Engine
val ktLintRuleEngine = KtLintRuleEngine(
  // Define configuration
)

// Process a collection of files
val files: Set<File> // Collect files in a convenient way
files.forEach(file in files) {
    ktLintRuleEngine.lint(file) {
        // Handle lint violations
    }
}

// or process a code sample for a given filepath
ktLintRuleEngine.lint(
  code = "code to be linted",
  filePath = Path("/path/to/source/file")
) {
  // Handle lint violations
}

if (node.isRoot()) {
    val fileName = (node.psi as? KtFile)?.name
    ...
}

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

• [ ] If you want to rebase/retry this PR, check this box

This PR has been generated by Mend Renovate. View repository job log here.

Hi @charleskorn

I ran into some trouble when parsing an enum with explicit serial names into a config using Hoplite. Was trying to pinpoint the issue, and it seems it's not in KAML 🙂 If you feel there's any value to adding the tests you're welcome to merge this, otherwise just close it.

I've just read https://github.com/Kotlin/kotlinx.serialization/blob/v0.20.0/docs/json_transformations.md and really like that. But I need that for YAML. If you want to deserialize a GitHub action definition file, you have for example exactly the use-case of polymorphism by shape. Would be really cool if kaml would also have such functionality built-in.

(Don't wonder that I'm reading the 0.20.0 docs, I'm using this in a Gradle build and therefore I cannot use 1.4.0 yet)