[
{
"path": ".gitattributes",
"content": "# text stuff\n* text=lf\n*.bat text eol=crlf\n*.cmd text eol=crlf\n*.java text eol=lf\n*.kt text eol=lf\n*.md text eol=lf\n*.properties text eol=lf\n*.scala text eol=lf\n*.sh text eol=lf\n.gitattributes text eol=lf\n.gitignore text eol=lf\nbuild.gradle text eol=lf\ngradlew text eol=lf\ngradlew.bat text eol=crlf\ngradle/wrapper/gradle-wrapper.properties text eol=lf\n\n#binary\n*.jar binary\n"
},
{
"path": ".github/stale.yml",
"content": "# Configuration for probot-stale - https://github.com/probot/stale\n\n# Number of days of inactivity before an Issue or Pull Request becomes stale\ndaysUntilStale: 90\n# Number of days of inactivity before a stale Issue or Pull Request is closed\ndaysUntilClose: false\n# Issues or Pull Requests with these labels will never be considered stale\nexemptLabels:\n- bug\n- Announcement\n- help wanted\n- To investigate\n# Label to use when marking as stale\nstaleLabel: stale\n# Comment to post when marking as stale. Set to `false` to disable\nmarkComment: >\n This issue has been automatically marked as stale because it has not had\n recent activity. It will be closed after 30 days if no further activity\n occurs, but feel free to re-open a closed issue if needed."
},
{
"path": ".github/workflows/gradle.yml",
"content": "name: Konf CI\n\non: [push]\n\njobs:\n build:\n name: Build on JDK ${{ matrix.java_version }} and ${{ matrix.os }}\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n java_version: [8, 11, 16]\n os: [ubuntu-latest, windows-latest, macOS-latest]\n\n steps:\n - uses: actions/checkout@v2\n - name: Set up JDK ${{ matrix.java_version }}\n uses: actions/setup-java@v1\n with:\n java-version: ${{ matrix.java_version }}\n - name: Build with Gradle\n run: ./gradlew build\n"
},
{
"path": ".gitignore",
"content": "# Created by .ignore support plugin (hsz.mobi)\n### Java template\n*.class\n\n# Mobile Tools for Java (J2ME)\n.mtj.tmp/\n\n# Package Files #\n*.jar\n*.war\n*.ear\n\n# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml\nhs_err_pid*\n### Eclipse template\n*.pydevproject\n.metadata\n.gradle\nbin/\ntmp/\n*.tmp\n*.bak\n*.swp\n*~.nib\nlocal.properties\n.settings/\n.loadpath\n\n# Eclipse Core\n.project\n\n# External tool builders\n.externalToolBuilders/\n\n# Locally stored \"Eclipse launch configurations\"\n*.launch\n\n# CDT-specific\n.cproject\n\n# JDT-specific (Eclipse Java Development Tools)\n.classpath\n\n# Java annotation processor (APT)\n.factorypath\n\n# PDT-specific\n.buildpath\n\n# sbteclipse plugin\n.target\n\n# TeXlipse plugin\n.texlipse\n### JetBrains template\n# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio\n\n*.iml\n\n## Directory-based project format:\n.idea/\n# if you remove the above rule, at least ignore the following:\n\n# User-specific stuff:\n# .idea/workspace.xml\n# .idea/tasks.xml\n# .idea/dictionaries\n\n# Sensitive or high-churn files:\n# .idea/dataSources.ids\n# .idea/dataSources.xml\n# .idea/sqlDataSources.xml\n# .idea/dynamic.xml\n# .idea/uiDesigner.xml\n\n# Gradle:\n# .idea/gradle.xml\n# .idea/libraries\n\n# Mongo Explorer plugin:\n# .idea/mongoSettings.xml\n\n## File-based project format:\n*.ipr\n*.iws\n\n## Plugin-specific files:\n\n# IntelliJ\nout/\n\n# mpeltonen/sbt-idea plugin\n.idea_modules/\n\n# JIRA plugin\natlassian-ide-plugin.xml\n\n# Crashlytics plugin (for Android Studio and IntelliJ)\ncom_crashlytics_export_strings.xml\ncrashlytics.properties\ncrashlytics-build.properties\n### Windows template\n# Windows image file caches\nThumbs.db\nehthumbs.db\n\n# Folder config file\nDesktop.ini\n\n# Recycle Bin used on file shares\n$RECYCLE.BIN/\n\n# Windows Installer files\n*.cab\n*.msi\n*.msm\n*.msp\n\n# Windows shortcuts\n*.lnk\n### Vim template\n[._]*.s[a-w][a-z]\n[._]s[a-w][a-z]\n*.un~\nSession.vim\n.netrwhist\n*~\n### SublimeText template\n# cache files for sublime text\n*.tmlanguage.cache\n*.tmPreferences.cache\n*.stTheme.cache\n\n# workspace files are user-specific\n*.sublime-workspace\n\n# project files should be checked into the repository, unless a significant\n# proportion of contributors will probably not be using SublimeText\n# *.sublime-project\n\n# sftp configuration file\nsftp-config.json\n### OSX template\n.DS_Store\n.AppleDouble\n.LSOverride\n\n# Icon must end with two \\r\nIcon\n\n# Thumbnails\n._*\n\n# Files that might appear in the root of a volume\n.DocumentRevisions-V100\n.fseventsd\n.Spotlight-V100\n.TemporaryItems\n.Trashes\n.VolumeIcon.icns\n\n# Directories potentially created on remote AFP share\n.AppleDB\n.AppleDesktop\nNetwork Trash Folder\nTemporary Items\n.apdisk\n\n\n\n### Gradle template\n.gradle\nbuild/\nbuild-eclipse/\n*/gradle*\n\n# Ignore Gradle GUI config\ngradle-app.setting\n\n# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)\n!gradle/wrapper/gradle-wrapper.jar\n\nprivate.properties\n.vscode\n.java-version\nact\n*.log"
},
{
"path": ".travis.yml",
"content": "language: java\n\njdk:\n - oraclejdk11\n - openjdk8\n - openjdk11\n - openjdk15\n\nafter_success:\n - bash <(curl -s https://codecov.io/bash)\n\nbefore_cache:\n - rm -f $HOME/.gradle/caches/modules-2/modules-2.lock\n - rm -fr $HOME/.gradle/caches/*/plugin-resolution/\ncache:\n directories:\n - $HOME/.gradle/caches/\n - $HOME/.gradle/wrapper/\n"
},
{
"path": "LICENSE",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "README.md",
"content": "# Konf\n\n[](http://java.oracle.com)\n[](https://search.maven.org/artifact/com.uchuhimo/konf)\n[](https://jitpack.io/#uchuhimo/konf)\n[](https://travis-ci.org/uchuhimo/konf)\n[](https://codecov.io/gh/uchuhimo/konf)\n[](https://codebeat.co/projects/github-com-uchuhimo-konf-master)\n[](https://github.com/KotlinBy/awesome-kotlin)\n\nA type-safe cascading configuration library for Kotlin/Java/Android, supporting most configuration formats.\n\n## Features\n\n- **Type-safe**. Get/set value in config with type-safe APIs.\n- **Thread-safe**. All APIs for config is thread-safe.\n- **Batteries included**. Support sources from JSON, XML, YAML, [HOCON](https://github.com/typesafehub/config/blob/master/HOCON.md), [TOML](https://github.com/toml-lang/toml), properties, map, command line and system environment out of box.\n- **Cascading**. Config can fork from another config by adding a new layer on it. Each layer of config can be updated independently. This feature is powerful enough to support complicated situation such as configs with different values share common fallback config, which is automatically updated when configuration file changes.\n- **Self-documenting**. Document config item with type, default value and description when declaring.\n- **Extensible**. Easy to customize new sources for config or expose items in config.\n\n## Contents\n\n- [Konf](#konf)\n - [Features](#features)\n - [Contents](#contents)\n - [Prerequisites](#prerequisites)\n - [Use in your projects](#use-in-your-projects)\n - [Maven](#maven)\n - [Gradle](#gradle)\n - [Gradle Kotlin DSL](#gradle-kotlin-dsl)\n - [Maven (master snapshot)](#maven-master-snapshot)\n - [Gradle (master snapshot)](#gradle-master-snapshot)\n - [Gradle Kotlin DSL (master snapshot)](#gradle-kotlin-dsl-master-snapshot)\n - [Quick start](#quick-start)\n - [Define items](#define-items)\n - [Use config](#use-config)\n - [Create config](#create-config)\n - [Add config spec](#add-config-spec)\n - [Retrieve value from config](#retrieve-value-from-config)\n - [Cast config to value](#cast-config-to-value)\n - [Check whether an item exists in config or not](#check-whether-an-item-exists-in-config-or-not)\n - [Modify value in config](#modify-value-in-config)\n - [Subscribe the update event](#subscribe-the-update-event)\n - [Export value in config as property](#export-value-in-config-as-property)\n - [Fork from another config](#fork-from-another-config)\n - [Load values from source](#load-values-from-source)\n - [Subscribe the update event for load operation](#subscribe-the-update-event-for-load-operation)\n - [Strict parsing when loading](#strict-parsing-when-loading)\n - [Path substitution](#path-substitution)\n - [Prefix/Merge operations for source/config/config spec](#prefixmerge-operations-for-sourceconfigconfig-spec)\n - [Export/Reload values in config](#exportreload-values-in-config)\n - [Supported item types](#supported-item-types)\n - [Optional features](#optional-features)\n - [Build from source](#build-from-source)\n - [Breaking Changes](#breaking-changes)\n - [v0.19.0](#v0190)\n - [v0.17.0](#v0170)\n - [v0.15](#v015)\n - [v0.10](#v010)\n- [License](#license)\n\n## Prerequisites\n\n- JDK 8 or higher\n- tested on Android SDK 23 or higher\n\n## Use in your projects\n\nThis library has been published to [Maven Central](https://search.maven.org/artifact/com.uchuhimo/konf) and [JitPack](https://jitpack.io/#uchuhimo/konf).\n\nKonf is modular, you can use different modules for different sources:\n\n- `konf-core`: for built-in sources (JSON, properties, map, command line and system environment)\n- `konf-hocon`: for built-in + [HOCON](https://github.com/typesafehub/config/blob/master/HOCON.md) sources\n- `konf-toml`: for built-in + [TOML](https://github.com/toml-lang/toml) sources\n- `konf-xml`: for built-in + XML sources\n- `konf-yaml`: for built-in + YAML sources\n- `konf-git`: for built-in + Git sources\n- `konf`: for all sources mentioned above\n- `konf-js`: for built-in + JavaScript (use GraalVM JavaScript) sources\n\n### Maven\n\n```xml\n\n com.uchuhimo\n konf\n 1.1.2\n\n```\n\n### Gradle\n\n```groovy\ncompile 'com.uchuhimo:konf:1.1.2'\n```\n\n### Gradle Kotlin DSL\n\n```kotlin\ncompile(group = \"com.uchuhimo\", name = \"konf\", version = \"1.1.2\")\n```\n\n### Maven (master snapshot)\n\nAdd JitPack repository to `` section:\n\n```xml\n\n jitpack.io\n https://jitpack.io\n\n```\n\nAdd dependencies:\n\n```xml\n\n com.github.uchuhimo\n konf\n master-SNAPSHOT\n\n```\n\n### Gradle (master snapshot)\n\nAdd JitPack repository:\n\n```groovy\nrepositories {\n maven { url 'https://jitpack.io' }\n}\n```\n\nAdd dependencies:\n\n```groovy\ncompile 'com.github.uchuhimo.konf:konf:master-SNAPSHOT'\n```\n\n### Gradle Kotlin DSL (master snapshot)\n\nAdd JitPack repository:\n\n```kotlin\nrepositories {\n maven(url = \"https://jitpack.io\")\n}\n```\n\nAdd dependencies:\n\n```kotlin\ncompile(group = \"com.github.uchuhimo.konf\", name = \"konf\", version = \"master-SNAPSHOT\")\n```\n\n## Quick start\n\n1. Define items in config spec:\n\n ```kotlin\n object ServerSpec : ConfigSpec() {\n val host by optional(\"0.0.0.0\")\n val tcpPort by required()\n }\n ```\n\n2. Construct config with items in config spec and values from multiple sources:\n\n ```kotlin\n val config = Config { addSpec(ServerSpec) }\n .from.yaml.file(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n ```\n \n or:\n\n ```kotlin\n val config = Config { addSpec(ServerSpec) }.withSource(\n Source.from.yaml.file(\"server.yml\") +\n Source.from.json.resource(\"server.json\") +\n Source.from.env() +\n Source.from.systemProperties()\n )\n ```\n\n This config contains all items defined in `ServerSpec`, and load values from 4 different sources. Values in resource file `server.json` will override those in file `server.yml`, values from system environment will override those in `server.json`, and values from system properties will override those from system environment.\n\n If you want to watch file `server.yml` and reload values when file content is changed, you can use `watchFile` instead of `file`:\n\n ```kotlin\n val config = Config { addSpec(ServerSpec) }\n .from.yaml.watchFile(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n ```\n\n3. Define values in source. You can define in any of these sources:\n - in `server.yml`:\n ```yaml\n server:\n host: 0.0.0.0\n tcp_port: 8080\n ```\n - in `server.json`:\n ```json\n {\n \"server\": {\n \"host\": \"0.0.0.0\",\n \"tcp_port\": 8080\n }\n }\n ```\n - in system environment:\n ```bash\n SERVER_HOST=0.0.0.0\n SERVER_TCPPORT=8080\n ```\n - in command line for system properties:\n ```bash\n -Dserver.host=0.0.0.0 -Dserver.tcp_port=8080\n ```\n\n4. Retrieve values from config with type-safe APIs:\n ```kotlin\n data class Server(val host: String, val tcpPort: Int) {\n fun start() {}\n }\n \n val server = Server(config[ServerSpec.host], config[ServerSpec.tcpPort])\n server.start()\n ```\n\n5. Retrieve values from multiple sources without using config spec:\n\n ```kotlin\n val server = Config()\n .from.yaml.file(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n .at(\"server\")\n .toValue()\n server.start()\n ```\n\n## Define items\n\nConfig items is declared in config spec, added to config by `Config#addSpec`. All items in same config spec have same prefix. Define a config spec with prefix `local.server`:\n\n```kotlin\nobject ServerSpec : ConfigSpec(\"server\") {\n}\n```\n\nIf the config spec is binding with single class, you can declare config spec as companion object of the class:\n\n```kotlin\nclass Server {\n companion object : ConfigSpec(\"server\") {\n val host by optional(\"0.0.0.0\")\n val tcpPort by required()\n }\n}\n```\n\nThe config spec prefix can be automatically inferred from the class name, leading to further simplification like:\n\n```kotlin\nobject ServerSpec : ConfigSpec() {\n}\n```\n\nor\n\n```kotlin\nclass Server {\n companion object : ConfigSpec() {\n }\n}\n```\n\nHere are some examples showing the inference convention: `Uppercase` to `uppercase`, `lowercase` to `lowercase`, `SuffixSpec` to `suffix`, `TCPService` to `tcpService`.\n\nThe config spec can also be nested. For example, the path of `Service.Backend.Login.user` in the following example will be inferred as \"service.backend.login.user\":\n\n```kotlin\nobject Service : ConfigSpec() {\n object Backend : ConfigSpec() {\n object Login : ConfigSpec() {\n val user by optional(\"admin\")\n }\n }\n}\n```\n\nThere are three kinds of item:\n\n- Required item. Required item doesn't have default value, thus must be set with value before retrieved in config. Define a required item with description:\n ```kotlin\n val tcpPort by required(description = \"port of server\")\n ```\n Or omit the description:\n ```kotlin\n val tcpPort by required()\n ```\n- Optional item. Optional item has default value, thus can be safely retrieved before setting. Define an optional item:\n ```kotlin\n val host by optional(\"0.0.0.0\", description = \"host IP of server\")\n ```\n Description can be omitted.\n- Lazy item. Lazy item also has default value, however, the default value is not a constant, it is evaluated from thunk every time when retrieved. Define a lazy item:\n ```kotlin\n val nextPort by lazy { config -> config[tcpPort] + 1 }\n ```\n\nYou can also define config spec in Java, with a more verbose API (compared to Kotlin version in \"quick start\"):\n\n```java\npublic class ServerSpec {\n public static final ConfigSpec spec = new ConfigSpec(\"server\");\n\n public static final OptionalItem host =\n new OptionalItem(spec, \"host\", \"0.0.0.0\") {};\n\n public static final RequiredItem tcpPort = new RequiredItem(spec, \"tcpPort\") {};\n}\n```\n\nNotice that the `{}` part in item declaration is necessary to avoid type erasure of item's type information.\n\n## Use config\n\n### Create config\n\nCreate an empty new config:\n\n```kotlin\nval config = Config()\n```\n\nOr an new config with some initial actions:\n\n```kotlin\nval config = Config { addSpec(Server) }\n```\n\n### Add config spec\n\nAdd multiple config specs into config:\n\n```kotlin\nconfig.addSpec(Server)\nconfig.addSpec(Client)\n```\n\n### Retrieve value from config\n\nRetrieve associated value with item (type-safe API):\n\n```kotlin\nval host = config[Server.host]\n```\n\nRetrieve associated value with item name (unsafe API):\n\n```kotlin\nval host = config.get(\"server.host\")\n```\n\nor:\n\n```kotlin\nval host = config(\"server.host\")\n```\n\n### Cast config to value\n\nCast config to a value with the target type:\n\n```kotlin\nval server = config.toValue()\n```\n\n### Check whether an item exists in config or not\n\nCheck whether an item exists in config or not:\n\n```kotlin\nconfig.contains(Server.host)\n// or\nServer.host in config\n```\n\nCheck whether an item name exists in config or not:\n\n```kotlin\nconfig.contains(\"server.host\")\n// or\n\"server.host\" in config\n```\n\nCheck whether all values of required items exist in config or not:\n\n```kotlin\nconfig.containsRequired()\n```\n\nThrow exception if some required items in config don't have values:\n\n```kotlin\nconfig.validateRequired()\n```\n\n### Modify value in config\n\nAssociate item with value (type-safe API):\n\n```kotlin\nconfig[Server.tcpPort] = 80\n```\n\nFind item with specified name, and associate it with value (unsafe API):\n\n```kotlin\nconfig[\"server.tcpPort\"] = 80\n```\n\nDiscard associated value of item:\n\n```kotlin\nconfig.unset(Server.tcpPort)\n```\n\nDiscard associated value of item with specified name:\n\n```kotlin\nconfig.unset(\"server.tcpPort\")\n```\n\nAssociate item with lazy thunk (type-safe API):\n\n```kotlin\nconfig.lazySet(Server.tcpPort) { it[basePort] + 1 }\n```\n\nFind item with specified name, and associate it with lazy thunk (unsafe API):\n\n```kotlin\nconfig.lazySet(\"server.tcpPort\") { it[basePort] + 1 }\n```\n\n### Subscribe the update event\n\nSubscribe the update event of an item:\n\n```kotlin\nval handler = Server.host.onSet { value -> println(\"the host has changed to $value\") }\n```\n\nSubscribe the update event before every set operation:\n\n```kotlin\nval handler = Server.host.beforeSet { config, value -> println(\"the host will change to $value\") }\n```\n\nor\n\n```kotlin\nval handler = config.beforeSet { item, value -> println(\"${item.name} will change to $value\") }\n```\n\nSubscribe the update event after every set operation:\n\n```kotlin\nval handler = Server.host.afterSet { config, value -> println(\"the host has changed to $value\") }\n```\n\nor\n\n```kotlin\nval handler = config.afterSet { item, value -> println(\"${item.name} has changed to $value\") }\n```\n\nCancel the subscription:\n\n```kotlin\nhandler.cancel()\n```\n\n### Export value in config as property\n\nExport a read-write property from value in config:\n\n```kotlin\nvar port by config.property(Server.tcpPort)\nport = 9090\ncheck(port == 9090)\n```\n\nExport a read-only property from value in config:\n\n```kotlin\nval port by config.property(Server.tcpPort)\ncheck(port == 9090)\n```\n\n### Fork from another config\n\n```kotlin\nval config = Config { addSpec(Server) }\nconfig[Server.tcpPort] = 1000\n// fork from parent config\nval childConfig = config.withLayer(\"child\")\n// child config inherit values from parent config\ncheck(childConfig[Server.tcpPort] == 1000)\n// modifications in parent config affect values in child config\nconfig[Server.tcpPort] = 2000\ncheck(config[Server.tcpPort] == 2000)\ncheck(childConfig[Server.tcpPort] == 2000)\n// modifications in child config don't affect values in parent config\nchildConfig[Server.tcpPort] = 3000\ncheck(config[Server.tcpPort] == 2000)\ncheck(childConfig[Server.tcpPort] == 3000)\n```\n\n## Load values from source\n\nUse `from` to load values from source doesn't affect values in config, it will return a new child config by loading all values into new layer in child config:\n\n```kotlin\nval config = Config { addSpec(Server) }\n// values in source is loaded into new layer in child config\nval childConfig = config.from.env()\ncheck(childConfig.parent === config)\n```\n\nAll out-of-box supported sources are declared in [`DefaultLoaders`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/DefaultLoaders.kt), shown below (the corresponding config spec for these samples is [`ConfigForLoad`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/test/kotlin/com/uchuhimo/konf/source/ConfigForLoad.kt)):\n\n| Type | Usage | Provider | Sample |\n| ------------------------------------------------------------ | -------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |\n| [HOCON](https://github.com/typesafehub/config/blob/master/HOCON.md) | `config.from.hocon` | [`HoconProvider`](https://github.com/uchuhimo/konf/blob/master/konf-hocon/src/main/kotlin/com/uchuhimo/konf/source/hocon/HoconProvider.kt) | [`source.conf`](https://github.com/uchuhimo/konf/blob/master/konf-hocon/src/test/resources/source/source.conf) |\n| JSON | `config.from.json` | [`JsonProvider`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/json/JsonProvider.kt) | [`source.json`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/test/resources/source/source.json) |\n| properties | `config.from.properties` | [`PropertiesProvider`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/properties/PropertiesProvider.kt) | [`source.properties`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/test/resources/source/source.properties) |\n| [TOML](https://github.com/toml-lang/toml) | `config.from.toml` | [`TomlProvider`](https://github.com/uchuhimo/konf/blob/master/konf-toml/src/main/kotlin/com/uchuhimo/konf/source/toml/TomlProvider.kt) | [`source.toml`](https://github.com/uchuhimo/konf/blob/master/konf-toml/src/test/resources/source/source.toml) |\n| XML | `config.from.xml` | [`XmlProvider`](https://github.com/uchuhimo/konf/blob/master/konf-xml/src/main/kotlin/com/uchuhimo/konf/source/xml/XmlProvider.kt) | [`source.xml`](https://github.com/uchuhimo/konf/blob/master/konf-xml/src/test/resources/source/source.xml) |\n| YAML | `config.from.yaml` | [`YamlProvider`](https://github.com/uchuhimo/konf/blob/master/konf-yaml/src/main/kotlin/com/uchuhimo/konf/source/yaml/YamlProvider.kt) | [`source.yaml`](https://github.com/uchuhimo/konf/blob/master/konf-yaml/src/test/resources/source/source.yaml) |\n| JavaScript | `config.from.js` | [`JsProvider`](https://github.com/uchuhimo/konf/blob/master/konf-js/src/main/kotlin/com/uchuhimo/konf/source/js/JsProvider.kt) | [`source.js`](https://github.com/uchuhimo/konf/blob/master/konf-js/src/test/resources/source/source.js) |\n| hierarchical map | `config.from.map.hierarchical` | - | [`MapSourceLoadSpec`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/test/kotlin/com/uchuhimo/konf/source/base/MapSourceLoadSpec.kt) |\n| map in key-value format | `config.from.map.kv` | - | [`KVSourceSpec`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/test/kotlin/com/uchuhimo/konf/source/base/KVSourceSpec.kt) |\n| map in flat format | `config.from.map.flat` | - | [`FlatSourceLoadSpec`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/test/kotlin/com/uchuhimo/konf/source/base/FlatSourceLoadSpec.kt) |\n| system environment | `config.from.env()` | [`EnvProvider`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/env/EnvProvider.kt) | - |\n| system properties | `config.from.systemProperties()` | [`PropertiesProvider`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/properties/PropertiesProvider.kt) | - |\n\nThese sources can also be manually created using their provider, and then loaded into config by `config.withSource(source)`.\n\nAll `from` APIs also have their standalone version that return sources without loading them into the config, shown below:\n\n| Type | Usage |\n| ------------------------------------------------------------ | -------------------------------- |\n| [HOCON](https://github.com/typesafehub/config/blob/master/HOCON.md) | `Source.from.hocon` |\n| JSON | `Source.from.json` |\n| properties | `Source.from.properties` |\n| [TOML](https://github.com/toml-lang/toml) | `Source.from.toml` |\n| XML | `Source.from.xml` |\n| YAML | `Source.from.yaml` |\n| JavaScript | `Source.from.js` |\n| hierarchical map | `Source.from.map.hierarchical` |\n| map in key-value format | `Source.from.map.kv` |\n| map in flat format | `Source.from.map.flat` |\n| system environment | `Source.from.env()` |\n| system properties | `Source.from.systemProperties()` |\n\nFormat of system properties source is same with that of properties source. System environment source follows the same mapping convention with properties source, but with the following name convention:\n\n- All letters in name are in uppercase\n- `.` in name is replaced with `_`\n\nHOCON/JSON/properties/TOML/XML/YAML/JavaScript source can be loaded from a variety of input format. Use properties source as example:\n\n- From file: `config.from.properties.file(\"/path/to/file\")`\n- From watched file: `config.from.properties.watchFile(\"/path/to/file\", 100, TimeUnit.MILLISECONDS)`\n - You can re-trigger the setup process every time the updated file is loaded by `watchFile(\"/path/to/file\") { config, source -> setup(config) }`\n- From string: `config.from.properties.string(\"server.port = 8080\")`\n- From URL: `config.from.properties.url(\"http://localhost:8080/source.properties\")`\n- From watched URL: `config.from.properties.watchUrl(\"http://localhost:8080/source.properties\", 1, TimeUnit.MINUTES)`\n - You can re-trigger the setup process every time the URL is loaded by `watchUrl(\"http://localhost:8080/source.properties\") { config, source -> setup(config) }`\n- From Git repository: `config.from.properties.git(\"https://github.com/uchuhimo/konf.git\", \"/path/to/source.properties\", branch = \"dev\")`\n- From watched Git repository: `config.from.properties.watchGit(\"https://github.com/uchuhimo/konf.git\", \"/path/to/source.properties\", period = 1, unit = TimeUnit.MINUTES)`\n - You can re-trigger the setup process every time the Git file is loaded by `watchGit(\"https://github.com/uchuhimo/konf.git\", \"/path/to/source.properties\") { config, source -> setup(config) }`\n- From resource: `config.from.properties.resource(\"source.properties\")`\n- From reader: `config.from.properties.reader(reader)`\n- From input stream: `config.from.properties.inputStream(inputStream)`\n- From byte array: `config.from.properties.bytes(bytes)`\n- From portion of byte array: `config.from.properties.bytes(bytes, 1, 12)`\n\nIf source is from file, file extension can be auto detected. Thus, you can use `config.from.file(\"/path/to/source.json\")` instead of `config.from.json.file(\"/path/to/source.json\")`, or use `config.from.watchFile(\"/path/to/source.json\")` instead of `config.from.json.watchFile(\"/path/to/source.json\")`. Source from URL also support auto-detected extension (use `config.from.url` or `config.from.watchUrl`). The following file extensions can be supported:\n\n| Type | Extension |\n| ---------- | ---------- |\n| HOCON | conf |\n| JSON | json |\n| Properties | properties |\n| TOML | toml |\n| XML | xml |\n| YAML | yml, yaml |\n| JavaScript | js |\n\nYou can also implement [`Source`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/Source.kt) to customize your new source, which can be loaded into config by `config.withSource(source)`.\n\n### Subscribe the update event for load operation\n\nSubscribe the update event before every load operation:\n\n```kotlin\nval handler = config.beforeLoad { source -> println(\"$source will be loaded\") }\n```\n\nYou can re-trigger the setup process by subscribing the update event after every load operation:\n\n```kotlin\nval handler = config.afterLoad { source -> setup(config) }\n```\n\nCancel the subscription:\n\n```kotlin\nhandler.cancel()\n```\n\n### Strict parsing when loading\n\nBy default, Konf extracts desired paths from sources and ignores other unknown paths in sources. If you want Konf to throws exception when unknown paths are found, you can enable `FAIL_ON_UNKNOWN_PATH` feature:\n\n```kotlin\nconfig.enable(Feature.FAIL_ON_UNKNOWN_PATH)\n .from.properties.file(\"server.properties\")\n .from.json.resource(\"server.json\")\n```\n\nThen `config` will validate paths from both the properties file and the JSON resource. Furthermore, If you want to validate the properties file only, you can use:\n\n```kotlin\nconfig.from.enable(Feature.FAIL_ON_UNKNOWN_PATH).properties.file(\"/path/to/file\")\n .from.json.resource(\"server.json\")\n```\n\n### Path substitution\n\nPath substitution is a feature that path references in source will be substituted by their values.\n\nPath substitution rules are shown below:\n\n- Only quoted string value will be substituted. It means that Konf's path substitutions will not conflict with HOCON's substitutions.\n- The definition of a path variable is `${path}`, e.g., `${java.version}`.\n- The path variable is resolved in the context of the current source.\n- If the string value only contains the path variable, it will be replaced by the whole sub-tree in the path; otherwise, it will be replaced by the string value in the path.\n- Use `${path:-default}` to provide a default value when the path is unresolved, e.g., `${java.version:-8}`.\n- Use `$${path}` to escape the path variable, e.g., `$${java.version}` will be resolved to `${java.version}` instead of the value in `java.version`.\n- Path substitution works in a recursive way, so nested path variables like `${jre-${java.specification.version}}` are allowed.\n- Konf also supports all key prefix of [StringSubstitutor](https://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/StringSubstitutor.html)'s default interpolator. \n\nBy default, Konf will perform path substitution for every source (except system environment source) when loading them into the config.\nYou can disable this behaviour by using `config.disable(Feature.SUBSTITUTE_SOURCE_BEFORE_LOADED)` for the config \nor `source.disabled(Feature.SUBSTITUTE_SOURCE_BEFORE_LOADED)` for a single source.\n\nBy default, Konf will throw exception when some path variables are unresolved. You can use `source.substituted(false)` manually to ignore these unresolved variables.\n\nTo resolve path variables refer to other sources, you can merge these sources before loading them into the config.\nFor example, if we have two sources `source1.json` and `source2.properties`,\n`source1.json` is:\n\n```json\n{ \n \"base\" : { \"user\" : \"konf\" , \"password\" : \"passwd\" }\n}\n```\n\n`source2.properties` is:\n\n```properties\nconnection.jdbc=mysql://${base.user}:${base.password}@server:port\n```\n\nuse:\n\n```kotlin\nconfig.withSource(\n Source.from.file(\"source1.json\") +\n Source.from.file(\"source2.properties\")\n)\n```\n\nWe can resolve `mysql://${base.user}:${base.password}@server:port` as `mysql://konf:passwd@server:port`.\n\n## Prefix/Merge operations for source/config/config spec\n\nAll of source/config/config spec support add prefix operation, remove prefix operation and merge operation as shown below:\n\n| Type | Add Prefix | Remove Prefix | Merge |\n| -------- | ------------------------------------------------------------ | ----------------------------------------------------------- | ------------------------------------------------------ |\n| `Source` | `source.withPrefix(prefix)` or `Prefix(prefix) + source` or `config.from.prefixed(prefix).file(file)` | `source[prefix]` or `config.from.scoped(prefix).file(file)` | `fallback + facade` or `facade.withFallback(fallback)` |\n| `Config` | `config.withPrefix(prefix)` or `Prefix(prefix) + config` | `config.at(prefix)` | `fallback + facade` or `facade.withFallback(fallback)` |\n| `Spec` | `spec.withPrefix(prefix)` or `Prefix(prefix) + spec` | `spec[prefix]` | `fallback + facade` or `facade.withFallback(fallback)` |\n\n## Export/Reload values in config\n\nExport all values in config as a tree:\n\n```kotlin\nval tree = config.toTree()\n```\n\nExport all values in config to map in key-value format:\n\n```kotlin\nval map = config.toMap()\n```\n\nExport all values in config to hierarchical map:\n\n```kotlin\nval map = config.toHierarchicalMap()\n```\n\nExport all values in config to map in flat format:\n\n```kotlin\nval map = config.toFlatMap()\n```\n\nExport all values in config to JSON:\n\n```kotlin\nval file = createTempFile(suffix = \".json\")\nconfig.toJson.toFile(file)\n```\n\nReload values from JSON:\n\n```kotlin\nval newConfig = Config {\n addSpec(Server)\n}.from.json.file(file)\ncheck(config == newConfig)\n```\n\nConfig can be saved to a variety of output format in HOCON/JSON/properties/TOML/XML/YAML/JavaScript. Use JSON as example:\n\n- To file: `config.toJson.toFile(\"/path/to/file\")`\n- To string: `config.toJson.toText()`\n- To writer: `config.toJson.toWriter(writer)`\n- To output stream: `config.toJson.toOutputStream(outputStream)`\n- To byte array: `config.toJson.toBytes()`\n\nYou can also implement [`Writer`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/Writer.kt) to customize your new writer (see [`JsonWriter`](https://github.com/uchuhimo/konf/blob/master/konf-core/src/main/kotlin/com/uchuhimo/konf/source/json/JsonWriter.kt) for how to integrate your writer with config).\n\n## Supported item types\n\nSupported item types include:\n\n- All primitive types\n- All primitive array types\n- `BigInteger`\n- `BigDecimal`\n- `String`\n- Date and Time\n - `java.util.Date`\n - `OffsetTime`\n - `OffsetDateTime`\n - `ZonedDateTime`\n - `LocalDate`\n - `LocalTime`\n - `LocalDateTime`\n - `Year`\n - `YearMonth`\n - `Instant`\n - `Duration`\n- `SizeInBytes`\n- Enum\n- Array\n- Collection\n - `List`\n - `Set`\n - `SortedSet`\n - `Map`\n - `SortedMap`\n- Kotlin Built-in classes\n - `Pair`\n - `Triple`\n - `IntRange`\n - `CharRange`\n - `LongRange`\n- Data classes\n- POJOs supported by Jackson core modules\n\nKonf supports size in bytes format described in [HOCON document](https://github.com/typesafehub/config/blob/master/HOCON.md#size-in-bytes-format) with class `SizeInBytes`.\n\nKonf supports both [ISO-8601 duration format](https://en.wikipedia.org/wiki/ISO_8601#Durations) and [HOCON duration format](https://github.com/typesafehub/config/blob/master/HOCON.md#duration-format) for `Duration`.\n\nKonf uses [Jackson](https://github.com/FasterXML/jackson) to support Kotlin Built-in classes, Data classes and POJOs. You can use `config.mapper` to access `ObjectMapper` instance used by config, and configure it to support more types from third-party Jackson modules. Default modules registered by Konf include:\n\n- Jackson core modules\n- `JavaTimeModule` in [jackson-modules-java8](https://github.com/FasterXML/jackson-modules-java8)\n- [jackson-module-kotlin](https://github.com/FasterXML/jackson-module-kotlin)\n\n## Optional features\n\nThere are some optional features that you can enable/disable in the config scope or the source scope by `Config#enable(Feature)`/`Config#disable(Feature)` or `Source#enabled(Feature)`/`Source#disable(Feature)`. You can use `Config#isEnabled()` or `Source#isEnabled()` to check whether a feature is enabled.\n\nThese features include:\n\n- `FAIL_ON_UNKNOWN_PATH`: feature that determines what happens when unknown paths appear in the source. If enabled, an exception is thrown when loading from the source to indicate it contains unknown paths. This feature is disabled by default.\n- `LOAD_KEYS_CASE_INSENSITIVELY`: feature that determines whether loading keys from sources case-insensitively. This feature is disabled by default except for system environment.\n- `LOAD_KEYS_AS_LITTLE_CAMEL_CASE`: feature that determines whether loading keys from sources as little camel case. This feature is enabled by default.\n- `OPTIONAL_SOURCE_BY_DEFAULT`: feature that determines whether sources are optional by default. This feature is disabled by default.\n- `SUBSTITUTE_SOURCE_BEFORE_LOADED`: feature that determines whether sources should be substituted before loaded into config. This feature is enabled by default.\n\n## Build from source\n\nBuild library with Gradle using the following command:\n\n```\n./gradlew clean assemble\n```\n\nTest library with Gradle using the following command:\n\n```\n./gradlew clean test\n```\n\nSince Gradle has excellent incremental build support, you can usually omit executing the `clean` task.\n\nInstall library in a local Maven repository for consumption in other projects via the following command:\n\n```\n./gradlew clean install\n```\n\n## Breaking Changes\n\n### v0.19.0\n\nSince all sources are substituted before loaded into config by default, all path variables will be substituted now. You can use `config.disable(Feature.SUBSTITUTE_SOURCE_BEFORE_LOADED)` to disable this change.\n\n### v0.17.0\n\nAfter migrated to tree-based source APIs, many deprecated APIs are removed, including:\n\n- `Source`: all `isXXX` and `toXXX` APIs\n- `Config`: `layer`, `addSource` and `withSourceFrom`\n\n### v0.15\n\nAfter modularized Konf, `hocon`/`toml`/`xml`/`yaml`/`git`/`watchGit` in `DefaultLoaders` become extension properties/functions and should be imported explicitly.\nFor example, you should import `com.uchuhimo.konf.source.hocon` before using `config.from.hocon`; in Java, `config.from().hocon` is unavailable, please use `config.from().source(HoconProvider.INSTANCE)` instead.\n\nIf you use JitPack, you should use `com.github.uchuhimo.konf:konf:` instead of `com.github.uchuhimo:konf:` now.\n\n### v0.10\n\nAPIs in `ConfigSpec` have been updated to support item name's auto-detection, please migrate to new APIs. Here are some examples:\n\n- `val host = optional(\"host\", \"0.0.0.0\")` to `val host by optional(\"0.0.0.0\")`\n- `val port = required(\"port\")` to `val port by required()`\n- `val nextPort = lazy(\"nextPort\") { config -> config[port] + 1 }` to `val nextPort by lazy { config -> config[port] + 1 }`\n\n# License\n\n© uchuhimo, 2017-2019. Licensed under an [Apache 2.0](./LICENSE) license.\n"
},
{
"path": "build.gradle.kts",
"content": "import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask\nimport org.jetbrains.kotlin.gradle.tasks.KotlinCompile\nimport java.net.URL\nimport java.util.Properties\n\nval ossUserToken by extra { getPrivateProperty(\"ossUserToken\") }\nval ossUserPassword by extra { getPrivateProperty(\"ossUserPassword\") }\nval signPublications by extra { getPrivateProperty(\"signPublications\") }\nval useAliyun by extra { shouldUseAliyun() }\n\ntasks.named(\"wrapper\") {\n gradleVersion = \"7.0\"\n distributionType = Wrapper.DistributionType.ALL\n}\n\nbuildscript {\n repositories {\n if (shouldUseAliyun()) {\n aliyunMaven()\n } else {\n mavenCentral()\n }\n }\n}\n\nplugins {\n java\n `java-test-fixtures`\n jacoco\n `maven-publish`\n signing\n kotlin(\"jvm\") version Versions.kotlin\n kotlin(\"plugin.allopen\") version Versions.kotlin\n id(\"com.dorongold.task-tree\") version Versions.taskTree\n id(\"me.champeau.gradle.jmh\") version Versions.jmhPlugin\n id(\"com.diffplug.spotless\") version Versions.spotless\n id(\"com.github.ben-manes.versions\") version Versions.dependencyUpdate\n id(\"org.jetbrains.dokka\") version Versions.dokka\n}\n\nallprojects {\n apply(plugin = \"java\")\n apply(plugin = \"java-test-fixtures\")\n apply(plugin = \"jacoco\")\n apply(plugin = \"maven-publish\")\n apply(plugin = \"signing\")\n apply(plugin = \"org.jetbrains.kotlin.jvm\")\n apply(plugin = \"kotlin-allopen\")\n apply(plugin = \"com.dorongold.task-tree\")\n apply(plugin = \"me.champeau.gradle.jmh\")\n apply(plugin = \"com.diffplug.spotless\")\n apply(plugin = \"com.github.ben-manes.versions\")\n apply(plugin = \"org.jetbrains.dokka\")\n\n group = \"com.uchuhimo\"\n version = \"1.1.2\"\n\n repositories {\n if (useAliyun) {\n aliyunMaven()\n } else {\n mavenCentral()\n }\n maven {\n url=uri(\"https://kotlin.bintray.com/kotlinx\")\n }\n }\n\n val dependencyUpdates by tasks.existing(DependencyUpdatesTask::class)\n dependencyUpdates {\n revision = \"release\"\n outputFormatter = \"plain\"\n resolutionStrategy {\n componentSelection {\n all {\n val rejected = listOf(\"alpha\", \"beta\", \"rc\", \"cr\", \"m\", \"preview\", \"b\", \"ea\", \"eap\", \"pr\", \"dev\", \"mt\")\n .map { qualifier -> Regex(\"(?i).*[.-]$qualifier[.\\\\d-+]*\") }\n .any { it.matches(candidate.version) }\n if (rejected) {\n reject(\"Release candidate\")\n }\n }\n }\n }\n }\n}\n\nsubprojects {\n configurations.testFixturesImplementation.get().extendsFrom(configurations.implementation.get())\n configurations.testImplementation.get().extendsFrom(configurations.testFixturesImplementation.get())\n\n dependencies {\n api(kotlin(\"stdlib-jdk8\", Versions.kotlin))\n api(\"org.jetbrains.kotlinx\", \"kotlinx-coroutines-core\", Versions.coroutines)\n implementation(kotlin(\"reflect\", Versions.kotlin))\n implementation(\"org.reflections\", \"reflections\", Versions.reflections)\n implementation(\"org.apache.commons\", \"commons-text\", Versions.commonsText)\n arrayOf(\"core\", \"annotations\", \"databind\").forEach { name ->\n api(jacksonCore(name, Versions.jackson))\n }\n implementation(jackson(\"module\", \"kotlin\", Versions.jackson))\n implementation(jackson(\"datatype\", \"jsr310\", Versions.jackson))\n\n testFixturesImplementation(kotlin(\"test\", Versions.kotlin))\n testFixturesImplementation(\"com.natpryce\", \"hamkrest\", Versions.hamkrest)\n testFixturesImplementation(\"org.hamcrest\", \"hamcrest-all\", Versions.hamcrest)\n testImplementation(junit(\"jupiter\", \"api\", Versions.junit))\n testImplementation(\"com.sparkjava\", \"spark-core\", Versions.spark)\n arrayOf(\"api\", \"data-driven-extension\", \"subject-extension\").forEach { name ->\n testFixturesImplementation(spek(name, Versions.spek))\n }\n\n testRuntimeOnly(junit(\"platform\", \"launcher\", Versions.junitPlatform))\n testRuntimeOnly(junit(\"jupiter\", \"engine\", Versions.junit))\n testRuntimeOnly(spek(\"junit-platform-engine\", Versions.spek))\n testRuntimeOnly(\"org.slf4j\", \"slf4j-simple\", Versions.slf4j)\n }\n\n java {\n sourceCompatibility = Versions.java\n targetCompatibility = Versions.java\n }\n\n val test by tasks.existing(Test::class)\n test {\n useJUnitPlatform()\n testLogging.apply {\n showStandardStreams = true\n showExceptions = true\n showCauses = true\n showStackTraces = true\n }\n systemProperties[\"org.slf4j.simpleLogger.defaultLogLevel\"] = \"warn\"\n systemProperties[\"junit.jupiter.execution.parallel.enabled\"] = true\n systemProperties[\"junit.jupiter.execution.parallel.mode.default\"] = \"concurrent\"\n maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).takeIf { it > 0 } ?: 1\n val properties = Properties()\n properties.load(rootProject.file(\"konf-core/src/test/kotlin/com/uchuhimo/konf/source/env/env.properties\").inputStream())\n properties.forEach { key, value ->\n environment(key as String, value)\n }\n }\n\n tasks.withType {\n options.encoding = \"UTF-8\"\n }\n\n tasks.withType {\n kotlinOptions {\n jvmTarget = Versions.java.toString()\n apiVersion = Versions.kotlinApi\n languageVersion = Versions.kotlinLanguage\n }\n }\n\n allOpen {\n annotation(\"org.openjdk.jmh.annotations.BenchmarkMode\")\n annotation(\"org.openjdk.jmh.annotations.State\")\n }\n\n jmh {\n //jvmArgs = [\"-Djmh.separateClasspathJAR=true\"]\n iterations = 10 // Number of measurement iterations to do.\n //benchmarkMode = [\"thrpt\"] // Benchmark mode. Available modes are: [Throughput/thrpt, AverageTime/avgt, SampleTime/sample, SingleShotTime/ss, All/all]\n batchSize = 1\n // Batch size: number of benchmark method calls per operation. (some benchmark modes can ignore this setting)\n fork = 1 // How many times to forks a single benchmark. Use 0 to disable forking altogether\n //operationsPerInvocation = 1 // Operations per invocation.\n timeOnIteration = \"1s\" // Time to spend at each measurement iteration.\n threads = 4 // Number of worker threads to run with.\n timeout = \"10s\" // Timeout for benchmark iteration.\n //timeUnit = \"ns\" // Output time unit. Available time units are: [m, s, ms, us, ns].\n verbosity = \"NORMAL\" // Verbosity mode. Available modes are: [SILENT, NORMAL, EXTRA]\n warmup = \"1s\" // Time to spend at each warmup iteration.\n warmupBatchSize = 1 // Warmup batch size: number of benchmark method calls per operation.\n //warmupForks = 0 // How many warmup forks to make for a single benchmark. 0 to disable warmup forks.\n warmupIterations = 10 // Number of warmup iterations to do.\n isZip64 = false // Use ZIP64 format for bigger archives\n jmhVersion = Versions.jmh // Specifies JMH version\n }\n\n spotless {\n java {\n googleJavaFormat(Versions.googleJavaFormat)\n trimTrailingWhitespace()\n endWithNewline()\n licenseHeaderFile(rootProject.file(\"config/spotless/apache-license-2.0.java\"))\n }\n kotlin {\n ktlint(Versions.ktlint)\n trimTrailingWhitespace()\n endWithNewline()\n licenseHeaderFile(rootProject.file(\"config/spotless/apache-license-2.0.kt\"))\n }\n }\n\n jacoco {\n toolVersion = Versions.jacoco\n }\n\n val jacocoTestReport by tasks.existing(JacocoReport::class) {\n reports {\n xml.isEnabled = true\n html.isEnabled = true\n }\n }\n\n val check by tasks.existing {\n dependsOn(jacocoTestReport)\n }\n\n tasks.dokkaHtml {\n outputDirectory.set(tasks.javadoc.get().destinationDir)\n dokkaSourceSets {\n configureEach {\n jdkVersion.set(9)\n reportUndocumented.set(false)\n sourceLink {\n localDirectory.set(file(\"./\"))\n remoteUrl.set(URL(\"https://github.com/uchuhimo/konf/blob/v${project.version}/\"))\n remoteLineSuffix.set(\"#L\")\n }\n }\n }\n }\n\n val sourcesJar by tasks.registering(Jar::class) {\n archiveClassifier.set(\"sources\")\n from(sourceSets.main.get().allSource)\n }\n\n val javadocJar by tasks.registering(Jar::class) {\n archiveClassifier.set(\"javadoc\")\n from(tasks.dokkaHtml)\n }\n\n val projectDescription = \"A type-safe cascading configuration library for Kotlin/Java, \" +\n \"supporting most configuration formats\"\n val projectGroup = project.group as String\n val projectName = if (project.name == \"konf-all\") \"konf\" else project.name\n val projectVersion = project.version as String\n val projectUrl = \"https://github.com/uchuhimo/konf\"\n\n publishing {\n publications {\n create(\"maven\") {\n from(components[\"java\"])\n artifact(sourcesJar.get())\n artifact(javadocJar.get())\n\n groupId = projectGroup\n artifactId = projectName\n version = projectVersion\n\n suppressPomMetadataWarningsFor(\"testFixturesApiElements\")\n suppressPomMetadataWarningsFor(\"testFixturesRuntimeElements\")\n pom {\n name.set(rootProject.name)\n description.set(projectDescription)\n url.set(projectUrl)\n licenses {\n license {\n name.set(\"The Apache Software License, Version 2.0\")\n url.set(\"http://www.apache.org/licenses/LICENSE-2.0.txt\")\n }\n }\n developers {\n developer {\n id.set(\"uchuhimo\")\n name.set(\"uchuhimo\")\n email.set(\"uchuhimo@outlook.com\")\n }\n }\n scm {\n url.set(projectUrl)\n }\n }\n }\n }\n repositories {\n maven {\n url = uri(\"https://oss.sonatype.org/service/local/staging/deploy/maven2\")\n credentials {\n username = ossUserToken\n password = ossUserPassword\n }\n }\n }\n }\n\n signing {\n setRequired({ signPublications == \"true\" })\n sign(publishing.publications[\"maven\"])\n }\n\n tasks {\n val install by registering\n afterEvaluate {\n val publishToMavenLocal by existing\n val publish by existing\n install.configure { dependsOn(publishToMavenLocal) }\n publish { dependsOn(check, install) }\n }\n }\n}\n"
},
{
"path": "buildSrc/build.gradle.kts",
"content": "plugins {\n `kotlin-dsl`\n}\n\nrepositories {\n mavenCentral()\n}"
},
{
"path": "buildSrc/settings.gradle.kts",
"content": ""
},
{
"path": "buildSrc/src/main/kotlin/Dependencies.kt",
"content": "import org.gradle.api.JavaVersion\n\nobject Versions {\n val java = JavaVersion.VERSION_1_8\n const val commonsText = \"1.9\"\n const val coroutines = \"1.4.3\"\n const val dependencyUpdate = \"0.38.0\"\n const val dokka = \"1.4.30\"\n const val dom4j = \"2.1.3\"\n const val graal = \"21.0.0.2\"\n const val hamcrest = \"1.3\"\n const val hamkrest = \"1.8.0.1\"\n const val hocon = \"1.4.1\"\n const val jacksonMinor = \"2.12\"\n const val jackson = \"$jacksonMinor.2\"\n const val jacoco = \"0.8.6\"\n const val jaxen = \"1.2.0\"\n const val jgit = \"5.11.0.202103091610-r\"\n const val jmh = \"1.25.2\"\n const val jmhPlugin = \"0.5.3\"\n const val junit = \"5.7.1\"\n const val junitPlatform = \"1.7.1\"\n const val kotlin = \"1.4.32\"\n const val kotlinApi = \"1.4\"\n const val kotlinLanguage = \"1.4\"\n const val reflections = \"0.9.12\"\n const val slf4j = \"1.7.30\"\n const val spark = \"2.9.3\"\n const val spek = \"1.1.5\"\n const val spotless = \"5.11.1\"\n const val taskTree = \"1.5\"\n const val toml4j = \"0.7.2\"\n const val yaml = \"1.28\"\n\n // Since 1.8, the minimum supported runtime version is JDK 11.\n const val googleJavaFormat = \"1.7\"\n const val ktlint = \"0.41.0\"\n}\n\n\nfun String?.withColon() = this?.let { \":$this\" } ?: \"\"\n\nfun kotlin(module: String, version: String? = null) =\n \"org.jetbrains.kotlin:kotlin-$module${version.withColon()}\"\n\nfun spek(module: String, version: String? = null) =\n \"org.jetbrains.spek:spek-$module${version.withColon()}\"\n\nfun jackson(scope: String, module: String, version: String? = null) =\n \"com.fasterxml.jackson.$scope:jackson-$scope-$module${version.withColon()}\"\n\nfun jacksonCore(module: String = \"core\", version: String? = null) =\n \"com.fasterxml.jackson.core:jackson-$module${version.withColon()}\"\n\nfun junit(scope: String, module: String, version: String? = null) =\n \"org.junit.$scope:junit-$scope-$module${version.withColon()}\"\n"
},
{
"path": "buildSrc/src/main/kotlin/Utils.kt",
"content": "import org.gradle.api.Project\nimport org.gradle.api.artifacts.dsl.RepositoryHandler\nimport org.gradle.kotlin.dsl.maven\nimport org.w3c.dom.Element\nimport java.util.Properties\n\nfun Project.getPrivateProperty(key: String): String {\n return if (file(\"private.properties\").exists()) {\n val properties = Properties()\n properties.load(file(\"private.properties\").inputStream())\n properties.getProperty(key)\n } else {\n \"\"\n }\n}\n\nfun Project.shouldUseAliyun(): Boolean = if (file(\"private.properties\").exists()) {\n val properties = Properties()\n properties.load(file(\"private.properties\").inputStream())\n properties.getProperty(\"useAliyun\")?.toBoolean() ?: false\n} else {\n false\n}\n\nfun RepositoryHandler.aliyunMaven() = maven(url = \"https://maven.aliyun.com/repository/central\")\n\nfun RepositoryHandler.aliyunGradlePluginPortal() = maven(url = \"https://maven.aliyun.com/repository/gradle-plugin\")\n\nfun Element.appendNode(key: String, action: Element.() -> Unit): Element {\n return apply {\n appendChild(ownerDocument.createElement(key).apply {\n action()\n })\n }\n}\n\nfun Element.appendNode(key: String, value: String): Element {\n return appendNode(key) {\n appendChild(ownerDocument.createTextNode(value))\n }\n}\n"
},
{
"path": "config/spotless/apache-license-2.0.java",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n"
},
{
"path": "config/spotless/apache-license-2.0.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n"
},
{
"path": "gradle/wrapper/gradle-wrapper.properties",
"content": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-7.0-all.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n"
},
{
"path": "gradle.properties",
"content": "org.gradle.jvmargs=-Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en_US\norg.gradle.caching=true\norg.gradle.vfs.watch=true\n#org.gradle.parallel=true\n#org.gradle.configureondemand=true\n"
},
{
"path": "gradlew",
"content": "#!/usr/bin/env sh\n\n#\n# Copyright 2015 the original author or authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS='\"-Xmx64m\" \"-Xms64m\"'\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn () {\n echo \"$*\"\n}\n\ndie () {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\nnonstop=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\n NONSTOP* )\n nonstop=true\n ;;\nesac\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" -a \"$nonstop\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin or MSYS, switch paths to Windows format before running java\nif [ \"$cygwin\" = \"true\" -o \"$msys\" = \"true\" ] ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=`expr $i + 1`\n done\n case $i in\n 0) set -- ;;\n 1) set -- \"$args0\" ;;\n 2) set -- \"$args0\" \"$args1\" ;;\n 3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n 4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n 5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n 6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n 7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n 8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n 9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Escape application args\nsave () {\n for i do printf %s\\\\n \"$i\" | sed \"s/'/'\\\\\\\\''/g;1s/^/'/;\\$s/\\$/' \\\\\\\\/\" ; done\n echo \" \"\n}\nAPP_ARGS=`save \"$@\"`\n\n# Collect all arguments for the java command, following the shell quoting and substitution rules\neval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \"\\\"-Dorg.gradle.appname=$APP_BASE_NAME\\\"\" -classpath \"\\\"$CLASSPATH\\\"\" org.gradle.wrapper.GradleWrapperMain \"$APP_ARGS\"\n\nexec \"$JAVACMD\" \"$@\"\n"
},
{
"path": "gradlew.bat",
"content": "@rem\r\n@rem Copyright 2015 the original author or authors.\r\n@rem\r\n@rem Licensed under the Apache License, Version 2.0 (the \"License\");\r\n@rem you may not use this file except in compliance with the License.\r\n@rem You may obtain a copy of the License at\r\n@rem\r\n@rem https://www.apache.org/licenses/LICENSE-2.0\r\n@rem\r\n@rem Unless required by applicable law or agreed to in writing, software\r\n@rem distributed under the License is distributed on an \"AS IS\" BASIS,\r\n@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n@rem See the License for the specific language governing permissions and\r\n@rem limitations under the License.\r\n@rem\r\n\r\n@if \"%DEBUG%\" == \"\" @echo off\r\n@rem ##########################################################################\r\n@rem\r\n@rem Gradle startup script for Windows\r\n@rem\r\n@rem ##########################################################################\r\n\r\n@rem Set local scope for the variables with windows NT shell\r\nif \"%OS%\"==\"Windows_NT\" setlocal\r\n\r\nset DIRNAME=%~dp0\r\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\r\nset APP_BASE_NAME=%~n0\r\nset APP_HOME=%DIRNAME%\r\n\r\n@rem Resolve any \".\" and \"..\" in APP_HOME to make it shorter.\r\nfor %%i in (\"%APP_HOME%\") do set APP_HOME=%%~fi\r\n\r\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\r\nset DEFAULT_JVM_OPTS=\"-Xmx64m\" \"-Xms64m\"\r\n\r\n@rem Find java.exe\r\nif defined JAVA_HOME goto findJavaFromJavaHome\r\n\r\nset JAVA_EXE=java.exe\r\n%JAVA_EXE% -version >NUL 2>&1\r\nif \"%ERRORLEVEL%\" == \"0\" goto execute\r\n\r\necho.\r\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\r\necho.\r\necho Please set the JAVA_HOME variable in your environment to match the\r\necho location of your Java installation.\r\n\r\ngoto fail\r\n\r\n:findJavaFromJavaHome\r\nset JAVA_HOME=%JAVA_HOME:\"=%\r\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\r\n\r\nif exist \"%JAVA_EXE%\" goto execute\r\n\r\necho.\r\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\r\necho.\r\necho Please set the JAVA_HOME variable in your environment to match the\r\necho location of your Java installation.\r\n\r\ngoto fail\r\n\r\n:execute\r\n@rem Setup the command line\r\n\r\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\r\n\r\n\r\n@rem Execute Gradle\r\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %*\r\n\r\n:end\r\n@rem End local scope for the variables with windows NT shell\r\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\r\n\r\n:fail\r\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\r\nrem the _cmd.exe /c_ return code!\r\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\r\nexit /b 1\r\n\r\n:mainEnd\r\nif \"%OS%\"==\"Windows_NT\" endlocal\r\n\r\n:omega\r\n"
},
{
"path": "konf-all/build.gradle.kts",
"content": "sourceSets {\n register(\"snippet\")\n}\n\nval snippetImplementation by configurations\nsnippetImplementation.extendsFrom(configurations.implementation.get())\n\ndependencies {\n for (name in listOf(\n \":konf-core\",\n \":konf-git\",\n \":konf-hocon\",\n \":konf-toml\",\n \":konf-xml\",\n \":konf-yaml\"\n )) {\n api(project(name))\n testImplementation(testFixtures(project(name)))\n }\n\n snippetImplementation(sourceSets.main.get().output)\n val snippet by sourceSets\n testImplementation(snippet.output)\n}\n"
},
{
"path": "konf-all/src/snippet/java/com/uchuhimo/konf/snippet/ServerInJava.java",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet;\n\nimport com.uchuhimo.konf.Config;\n\npublic class ServerInJava {\n private String host;\n private Integer tcpPort;\n\n public ServerInJava(String host, Integer tcpPort) {\n this.host = host;\n this.tcpPort = tcpPort;\n }\n\n public ServerInJava(Config config) {\n this(config.get(ServerSpecInJava.host), config.get(ServerSpecInJava.tcpPort));\n }\n\n public String getHost() {\n return host;\n }\n\n public Integer getTcpPort() {\n return tcpPort;\n }\n}\n"
},
{
"path": "konf-all/src/snippet/java/com/uchuhimo/konf/snippet/ServerSpecInJava.java",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet;\n\nimport com.uchuhimo.konf.ConfigSpec;\nimport com.uchuhimo.konf.OptionalItem;\nimport com.uchuhimo.konf.RequiredItem;\n\npublic class ServerSpecInJava {\n public static final ConfigSpec spec = new ConfigSpec(\"server\");\n\n public static final OptionalItem host =\n new OptionalItem(spec, \"host\", \"0.0.0.0\") {};\n\n public static final RequiredItem tcpPort = new RequiredItem(spec, \"tcpPort\") {};\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/Config.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.ConfigSpec\n\nfun main(args: Array) {\n val config = Config()\n config.addSpec(Server)\n run {\n val host = config[Server.host]\n }\n run {\n val host = config.get(\"server.host\")\n }\n run {\n val host = config(\"server.host\")\n }\n config.contains(Server.host)\n // or\n Server.host in config\n config.contains(\"server.host\")\n // or\n \"server.host\" in config\n config[Server.tcpPort] = 80\n config[\"server.tcpPort\"] = 80\n config.containsRequired()\n config.validateRequired()\n config.unset(Server.tcpPort)\n config.unset(\"server.tcpPort\")\n val basePort by ConfigSpec(\"server\").required()\n config.lazySet(Server.tcpPort) { it[basePort] + 1 }\n config.lazySet(\"server.tcpPort\") { it[basePort] + 1 }\n run {\n val handler = Server.host.onSet { value -> println(\"the host has changed to $value\") }\n handler.cancel()\n }\n run {\n val handler = Server.host.beforeSet { config, value -> println(\"the host will change to $value\") }\n handler.cancel()\n }\n run {\n val handler = config.beforeSet { item, value -> println(\"${item.name} will change to $value\") }\n handler.cancel()\n }\n run {\n val handler = Server.host.afterSet { config, value -> println(\"the host has changed to $value\") }\n handler.cancel()\n }\n run {\n val handler = config.afterSet { item, value -> println(\"${item.name} has changed to $value\") }\n handler.cancel()\n }\n run {\n var port by config.property(Server.tcpPort)\n port = 9090\n check(port == 9090)\n }\n run {\n val port by config.property(Server.tcpPort)\n check(port == 9090)\n }\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/Export.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.source.base.toFlatMap\nimport com.uchuhimo.konf.source.base.toHierarchicalMap\nimport com.uchuhimo.konf.source.json.toJson\nimport com.uchuhimo.konf.tempFile\n\nfun main(args: Array) {\n val config = Config { addSpec(Server) }\n config[Server.tcpPort] = 1000\n run {\n val map = config.toMap()\n }\n run {\n val map = config.toHierarchicalMap()\n }\n run {\n val map = config.toFlatMap()\n }\n val file = tempFile(suffix = \".json\")\n config.toJson.toFile(file)\n val newConfig = Config {\n addSpec(Server)\n }.from.json.file(file)\n check(config.toMap() == newConfig.toMap())\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/Fork.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\n\nfun main(args: Array) {\n val config = Config { addSpec(Server) }\n config[Server.tcpPort] = 1000\n // fork from parent config\n val childConfig = config.withLayer(\"child\")\n // child config inherit values from parent config\n check(childConfig[Server.tcpPort] == 1000)\n // modifications in parent config affect values in child config\n config[Server.tcpPort] = 2000\n check(config[Server.tcpPort] == 2000)\n check(childConfig[Server.tcpPort] == 2000)\n // modifications in child config don't affect values in parent config\n childConfig[Server.tcpPort] = 3000\n check(config[Server.tcpPort] == 2000)\n check(childConfig[Server.tcpPort] == 3000)\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/Load.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\n\nfun main(args: Array) {\n val config = Config { addSpec(Server) }\n // values in source is loaded into new layer in child config\n val childConfig = config.from.env()\n check(childConfig.parent === config)\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/QuickStart.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.ConfigSpec\nimport com.uchuhimo.konf.source.Source\nimport com.uchuhimo.konf.source.toValue\nimport com.uchuhimo.konf.source.yaml\nimport com.uchuhimo.konf.toValue\nimport java.io.File\n\nobject ServerSpec : ConfigSpec() {\n val host by optional(\"0.0.0.0\")\n val tcpPort by required()\n}\n\nfun main(args: Array) {\n val file = File(\"server.yml\")\n //language=YAML\n file.writeText(\n \"\"\"\n server:\n host: 127.0.0.1\n tcp_port: 8080\n \"\"\".trimIndent()\n )\n file.deleteOnExit()\n val config = Config { addSpec(ServerSpec) }\n .from.yaml.file(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n run {\n val config = Config { addSpec(ServerSpec) }.withSource(\n Source.from.yaml.file(\"server.yml\") +\n Source.from.json.resource(\"server.json\") +\n Source.from.env() +\n Source.from.systemProperties()\n )\n }\n run {\n val config = Config { addSpec(ServerSpec) }\n .from.yaml.watchFile(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n }\n val server = Server(config[ServerSpec.host], config[ServerSpec.tcpPort])\n server.start()\n run {\n val server = Config()\n .from.yaml.file(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n .at(\"server\")\n .toValue()\n server.start()\n }\n run {\n val server = (\n Source.from.yaml.file(\"server.yml\") +\n Source.from.json.resource(\"server.json\") +\n Source.from.env() +\n Source.from.systemProperties()\n )[\"server\"]\n .toValue()\n server.start()\n }\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/Serialize.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.tempFile\nimport java.io.ObjectInputStream\nimport java.io.ObjectOutputStream\n\nfun main(args: Array) {\n val config = Config { addSpec(Server) }\n config[Server.tcpPort] = 1000\n val map = config.toMap()\n val newMap = tempFile().run {\n ObjectOutputStream(outputStream()).use {\n it.writeObject(map)\n }\n ObjectInputStream(inputStream()).use {\n @Suppress(\"UNCHECKED_CAST\")\n it.readObject() as Map\n }\n }\n val newConfig = Config {\n addSpec(Server)\n }.from.map.kv(newMap)\n check(config.toMap() == newConfig.toMap())\n}\n"
},
{
"path": "konf-all/src/snippet/kotlin/com/uchuhimo/konf/snippet/Server.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.snippet\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.ConfigSpec\n\ndata class Server(val host: String, val tcpPort: Int) {\n constructor(config: Config) : this(config[Server.host], config[Server.tcpPort])\n\n fun start() {}\n\n companion object : ConfigSpec(\"server\") {\n val host by optional(\"0.0.0.0\", description = \"host IP of server\")\n val tcpPort by required(description = \"port of server\")\n val nextPort by lazy { config -> config[tcpPort] + 1 }\n }\n}\n"
},
{
"path": "konf-all/src/snippet/resources/server.json",
"content": "{\n \"server\": {\n \"host\": \"127.0.0.1\",\n \"tcp_port\": 8080\n }\n}"
},
{
"path": "konf-all/src/test/kotlin/com/uchuhimo/konf/source/MergeSourcesWithDifferentFeaturesSpec.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.natpryce.hamkrest.assertion.assertThat\nimport com.natpryce.hamkrest.equalTo\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.ConfigSpec\nimport org.jetbrains.spek.api.Spek\nimport org.jetbrains.spek.api.dsl.it\nimport org.jetbrains.spek.api.dsl.on\n\nobject MergeSourcesWithDifferentFeaturesSpec : Spek({\n on(\"load from merged sources\") {\n val config = Config {\n addSpec(ServicingConfig)\n }.withSource(\n Source.from.hocon.string(content) + Source.from.env()\n )\n it(\"should contain the item\") {\n assertThat(config[ServicingConfig.baseURL], equalTo(\"https://service/api\"))\n assertThat(config[ServicingConfig.url], equalTo(\"https://service/api/index.html\"))\n }\n }\n})\n\nobject ServicingConfig : ConfigSpec(\"servicing\") {\n val baseURL by required()\n val url by required()\n}\n\nval content = \"\"\"\n servicing {\n baseURL = \"https://service/api\"\n url = \"${'$'}{servicing.baseURL}/index.html\"\n }\n\"\"\".trimIndent()\n"
},
{
"path": "konf-all/src/test/kotlin/com/uchuhimo/konf/source/MultiLayerConfigToValueSpec.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.fasterxml.jackson.databind.DeserializationFeature\nimport com.natpryce.hamkrest.assertion.assertThat\nimport com.natpryce.hamkrest.equalTo\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.toValue\nimport org.jetbrains.spek.api.Spek\nimport org.jetbrains.spek.api.dsl.it\nimport org.jetbrains.spek.api.dsl.on\n\nobject MultiLayerConfigToValueSpec : Spek({\n val yamlContent = \"\"\"\ndb:\n driverClassName: org.h2.Driver\n url: 'jdbc:h2:mem:db;DB_CLOSE_DELAY=-1'\n \"\"\".trimIndent()\n\n val map = mapOf(\n \"driverClassName\" to \"org.h2.Driver\",\n \"url\" to \"jdbc:h2:mem:db;DB_CLOSE_DELAY=-1\"\n )\n on(\"load from multiple sources\") {\n val config = Config {\n mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)\n }\n .from.yaml.string(yamlContent)\n .from.yaml.file(\n System.getenv(\"SERVICE_CONFIG\")\n ?: \"/opt/legacy-event-service/conf/legacy-event-service.yml\",\n true\n )\n .from.systemProperties()\n .from.env()\n it(\"should cast to value correctly\") {\n val db = config.toValue()\n assertThat(db.db, equalTo(map))\n }\n }\n})\n\ndata class ConfigTestReport(val db: Map)\n"
},
{
"path": "konf-all/src/test/kotlin/com/uchuhimo/konf/source/MultipleDefaultLoadersSpec.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.natpryce.hamkrest.assertion.assertThat\nimport com.natpryce.hamkrest.equalTo\nimport com.uchuhimo.konf.Config\nimport org.jetbrains.spek.api.Spek\nimport org.jetbrains.spek.api.dsl.it\nimport org.jetbrains.spek.api.dsl.on\n\nobject MultipleDefaultLoadersSpec : Spek({\n on(\"load from multiple sources\") {\n val config = Config {\n addSpec(DefaultLoadersConfig)\n }\n val item = DefaultLoadersConfig.type\n val afterLoadEnv = config.from.env()\n System.setProperty(config.nameOf(DefaultLoadersConfig.type), \"system\")\n val afterLoadSystemProperties = afterLoadEnv.from.systemProperties()\n val afterLoadHocon = afterLoadSystemProperties.from.hocon.string(hoconContent)\n val afterLoadJson = afterLoadHocon.from.json.string(jsonContent)\n val afterLoadProperties = afterLoadJson.from.properties.string(propertiesContent)\n val afterLoadToml = afterLoadProperties.from.toml.string(tomlContent)\n val afterLoadXml = afterLoadToml.from.xml.string(xmlContent)\n val afterLoadYaml = afterLoadXml.from.yaml.string(yamlContent)\n val afterLoadFlat = afterLoadYaml.from.map.flat(mapOf(\"source.test.type\" to \"flat\"))\n val afterLoadKv = afterLoadFlat.from.map.kv(mapOf(\"source.test.type\" to \"kv\"))\n val afterLoadHierarchical = afterLoadKv.from.map.hierarchical(\n mapOf(\n \"source\" to\n mapOf(\n \"test\" to\n mapOf(\"type\" to \"hierarchical\")\n )\n )\n )\n it(\"should load the corresponding value in each layer\") {\n assertThat(afterLoadEnv[item], equalTo(\"env\"))\n assertThat(afterLoadSystemProperties[item], equalTo(\"system\"))\n assertThat(afterLoadHocon[item], equalTo(\"conf\"))\n assertThat(afterLoadJson[item], equalTo(\"json\"))\n assertThat(afterLoadProperties[item], equalTo(\"properties\"))\n assertThat(afterLoadToml[item], equalTo(\"toml\"))\n assertThat(afterLoadXml[item], equalTo(\"xml\"))\n assertThat(afterLoadYaml[item], equalTo(\"yaml\"))\n assertThat(afterLoadFlat[item], equalTo(\"flat\"))\n assertThat(afterLoadKv[item], equalTo(\"kv\"))\n assertThat(afterLoadHierarchical[item], equalTo(\"hierarchical\"))\n }\n }\n})\n\n//language=Json\nconst val jsonContent =\n \"\"\"\n{\n \"source\": {\n \"test\": {\n \"type\": \"json\"\n }\n }\n}\n\"\"\"\n"
},
{
"path": "konf-all/src/test/kotlin/com/uchuhimo/konf/source/QuickStartSpec.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.natpryce.hamkrest.assertion.assertThat\nimport com.natpryce.hamkrest.equalTo\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.snippet.Server\nimport com.uchuhimo.konf.snippet.ServerSpec\nimport com.uchuhimo.konf.toValue\nimport org.jetbrains.spek.api.Spek\nimport org.jetbrains.spek.api.dsl.it\nimport org.jetbrains.spek.api.dsl.on\nimport java.io.File\n\nobject QuickStartSpec : Spek({\n on(\"use default loaders\") {\n val config = useFile {\n Config { addSpec(ServerSpec) }\n .from.yaml.file(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n }\n it(\"should load all values\") {\n assertThat(\n config.toMap(),\n equalTo(mapOf(\"server.host\" to \"127.0.0.1\", \"server.tcpPort\" to 8080))\n )\n }\n }\n on(\"use default providers\") {\n val config = useFile {\n Config { addSpec(ServerSpec) }.withSource(\n Source.from.yaml.file(\"server.yml\") +\n Source.from.json.resource(\"server.json\") +\n Source.from.env() +\n Source.from.systemProperties()\n )\n }\n it(\"should load all values\") {\n assertThat(\n config.toMap(),\n equalTo(mapOf(\"server.host\" to \"127.0.0.1\", \"server.tcpPort\" to 8080))\n )\n }\n }\n on(\"watch file\") {\n val config = useFile {\n Config { addSpec(ServerSpec) }\n .from.yaml.watchFile(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n }\n it(\"should load all values\") {\n assertThat(\n config.toMap(),\n equalTo(mapOf(\"server.host\" to \"127.0.0.1\", \"server.tcpPort\" to 8080))\n )\n }\n }\n on(\"cast config to value\") {\n val config = useFile {\n Config()\n .from.yaml.file(\"server.yml\")\n .from.json.resource(\"server.json\")\n .from.env()\n .from.systemProperties()\n .at(\"server\")\n }\n val server = config.toValue()\n it(\"should load all values\") {\n assertThat(server, equalTo(Server(host = \"127.0.0.1\", tcpPort = 8080)))\n }\n }\n on(\"cast source to value\") {\n val source = useFile {\n (\n Source.from.yaml.file(\"server.yml\") +\n Source.from.json.resource(\"server.json\") +\n Source.from.env() +\n Source.from.systemProperties()\n )[\"server\"]\n }\n val server = source.toValue()\n it(\"should load all values\") {\n assertThat(server, equalTo(Server(host = \"127.0.0.1\", tcpPort = 8080)))\n }\n }\n})\n\nprivate fun useFile(block: () -> T): T {\n val file = File(\"server.yml\")\n //language=YAML\n file.writeText(\n \"\"\"\n server:\n host: 127.0.0.1\n tcp_port: 8080\n \"\"\".trimIndent()\n )\n try {\n return block()\n } finally {\n file.delete()\n }\n}\n"
},
{
"path": "konf-core/build.gradle.kts",
"content": "dependencies {\n jmhImplementation(kotlin(\"stdlib\", Versions.kotlin))\n}\n"
},
{
"path": "konf-core/src/jmh/kotlin/com/uchuhimo/konf/ConfigBenchmark.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport org.openjdk.jmh.annotations.Benchmark\nimport org.openjdk.jmh.annotations.BenchmarkMode\nimport org.openjdk.jmh.annotations.Mode.AverageTime\nimport org.openjdk.jmh.annotations.OutputTimeUnit\nimport org.openjdk.jmh.annotations.Scope\nimport org.openjdk.jmh.annotations.State\nimport java.util.concurrent.TimeUnit.NANOSECONDS\n\nclass Buffer {\n companion object : ConfigSpec(\"network.buffer\") {\n val name by optional(\"buffer\", description = \"name of buffer\")\n }\n}\n\n@BenchmarkMode(AverageTime)\n@OutputTimeUnit(NANOSECONDS)\nclass ConfigBenchmark {\n\n @State(Scope.Thread)\n class ConfigState {\n val config = Config { addSpec(Buffer) }\n val path = Buffer.qualify(Buffer.name)\n }\n\n @State(Scope.Benchmark)\n class MultiThreadConfigState {\n val config = Config { addSpec(Buffer) }\n val path = Buffer.qualify(Buffer.name)\n }\n\n @Benchmark\n fun getWithItem(state: ConfigState) = state.config[Buffer.name]\n\n @Benchmark\n fun getWithItemFromMultiThread(state: MultiThreadConfigState) = state.config[Buffer.name]\n\n @Benchmark\n fun setWithItem(state: ConfigState) {\n state.config[Buffer.name] = \"newName\"\n }\n\n @Benchmark\n fun setWithItemFromMultiThread(state: MultiThreadConfigState) {\n state.config[Buffer.name] = \"newName\"\n }\n\n @Benchmark\n fun getWithPath(state: ConfigState) = state.config(state.path)\n\n @Benchmark\n fun getWithPathFromMultiThread(state: MultiThreadConfigState) = state.config(state.path)\n\n @Benchmark\n fun setWithPath(state: ConfigState) {\n state.config[state.path] = \"newName\"\n }\n\n @Benchmark\n fun setWithPathFromMultiThread(state: MultiThreadConfigState) {\n state.config[state.path] = \"newName\"\n }\n}\n\n@BenchmarkMode(AverageTime)\n@OutputTimeUnit(NANOSECONDS)\nclass MultiLevelConfigBenchmark {\n\n @State(Scope.Thread)\n class ConfigState {\n val config = Config { addSpec(Buffer) }.withLayer().withLayer().withLayer().withLayer()\n val path = Buffer.qualify(Buffer.name)\n }\n\n @State(Scope.Benchmark)\n class MultiThreadConfigState {\n val config = Config { addSpec(Buffer) }.withLayer().withLayer().withLayer().withLayer()\n val path = Buffer.qualify(Buffer.name)\n }\n\n @Benchmark\n fun getWithItem(state: ConfigState) = state.config[Buffer.name]\n\n @Benchmark\n fun getWithItemFromMultiThread(state: MultiThreadConfigState) = state.config[Buffer.name]\n\n @Benchmark\n fun setWithItem(state: ConfigState) {\n state.config[Buffer.name] = \"newName\"\n }\n\n @Benchmark\n fun setWithItemFromMultiThread(state: MultiThreadConfigState) {\n state.config[Buffer.name] = \"newName\"\n }\n\n @Benchmark\n fun getWithPath(state: ConfigState) = state.config(state.path)\n\n @Benchmark\n fun getWithPathFromMultiThread(state: MultiThreadConfigState) = state.config(state.path)\n\n @Benchmark\n fun setWithPath(state: ConfigState) {\n state.config[state.path] = \"newName\"\n }\n\n @Benchmark\n fun setWithPathFromMultiThread(state: MultiThreadConfigState) {\n state.config[state.path] = \"newName\"\n }\n}\n"
},
{
"path": "konf-core/src/main/java/com/uchuhimo/konf/Configs.java",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf;\n\nimport java.util.function.Consumer;\n\n/** Helper class for {@link com.uchuhimo.konf.Config Config}. */\npublic final class Configs {\n private Configs() {}\n\n /**\n * Create a new root config.\n *\n * @return a new root config\n */\n public static Config create() {\n return Config.Companion.invoke();\n }\n\n /**\n * Create a new root config and initiate it.\n *\n * @param init initial action\n * @return a new root config\n */\n public static Config create(Consumer init) {\n final Config config = create();\n init.accept(config);\n return config;\n }\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/BaseConfig.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.fasterxml.jackson.databind.DeserializationFeature\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport com.fasterxml.jackson.databind.SerializationFeature\nimport com.fasterxml.jackson.databind.cfg.CoercionAction\nimport com.fasterxml.jackson.databind.cfg.CoercionInputShape\nimport com.fasterxml.jackson.databind.module.SimpleModule\nimport com.fasterxml.jackson.datatype.jsr310.JavaTimeModule\nimport com.fasterxml.jackson.module.kotlin.jacksonObjectMapper\nimport com.uchuhimo.konf.source.MergedSource\nimport com.uchuhimo.konf.source.Source\nimport com.uchuhimo.konf.source.base.EmptyMapSource\nimport com.uchuhimo.konf.source.deserializer.DurationDeserializer\nimport com.uchuhimo.konf.source.deserializer.EmptyStringToCollectionDeserializerModifier\nimport com.uchuhimo.konf.source.deserializer.OffsetDateTimeDeserializer\nimport com.uchuhimo.konf.source.deserializer.StringDeserializer\nimport com.uchuhimo.konf.source.deserializer.ZoneDateTimeDeserializer\nimport com.uchuhimo.konf.source.load\nimport com.uchuhimo.konf.source.loadItem\nimport com.uchuhimo.konf.source.toCompatibleValue\nimport java.time.Duration\nimport java.time.OffsetDateTime\nimport java.time.ZonedDateTime\nimport java.util.WeakHashMap\nimport java.util.concurrent.locks.ReentrantReadWriteLock\nimport kotlin.concurrent.read\nimport kotlin.concurrent.write\nimport kotlin.properties.ReadWriteProperty\nimport kotlin.reflect.KProperty\n\n/**\n * The default implementation for [Config].\n */\nopen class BaseConfig(\n override val name: String = \"\",\n override val parent: BaseConfig? = null,\n override val mapper: ObjectMapper = createDefaultMapper(),\n private val specsInLayer: MutableList = mutableListOf(),\n private val featuresInLayer: MutableMap = mutableMapOf(),\n private val nodeByItem: MutableMap, ItemNode> = mutableMapOf(),\n private val tree: TreeNode = ContainerNode.placeHolder(),\n private val hasChildren: Value = Value(false),\n private val beforeSetFunctions: MutableList<(item: Item<*>, value: Any?) -> Unit> = mutableListOf(),\n private val afterSetFunctions: MutableList<(item: Item<*>, value: Any?) -> Unit> = mutableListOf(),\n private val beforeLoadFunctions: MutableList<(source: Source) -> Unit> = mutableListOf(),\n private val afterLoadFunctions: MutableList<(source: Source) -> Unit> = mutableListOf(),\n private val lock: ReentrantReadWriteLock = ReentrantReadWriteLock()\n) : Config {\n private val _source: Value = Value(EmptyMapSource())\n open val source: Source get() = _source.value\n private val nameByItem: WeakHashMap, String> = WeakHashMap()\n\n override fun lock(action: () -> T): T = lock.write(action)\n\n override fun at(path: String): Config {\n if (path.isEmpty()) {\n return this\n } else {\n val originalConfig = this\n return object : BaseConfig(\n name = name,\n parent = parent?.at(path) as BaseConfig?,\n mapper = mapper,\n specsInLayer = specsInLayer,\n featuresInLayer = featuresInLayer,\n nodeByItem = nodeByItem,\n tree = tree.getOrNull(path) ?: ContainerNode.placeHolder().also {\n lock.write { tree[path] = it }\n },\n hasChildren = hasChildren,\n beforeSetFunctions = beforeSetFunctions,\n afterSetFunctions = afterSetFunctions,\n beforeLoadFunctions = beforeLoadFunctions,\n afterLoadFunctions = afterLoadFunctions,\n lock = lock\n ) {\n override val source: Source\n get() {\n if (path !in originalConfig.source) {\n originalConfig.source.tree[path] = ContainerNode.placeHolder()\n }\n return originalConfig.source[path]\n }\n }\n }\n }\n\n override fun withPrefix(prefix: String): Config {\n if (prefix.isEmpty()) {\n return this\n } else {\n val originalConfig = this\n return object : BaseConfig(\n name = name,\n parent = parent?.withPrefix(prefix) as BaseConfig?,\n mapper = mapper,\n specsInLayer = specsInLayer,\n featuresInLayer = featuresInLayer,\n nodeByItem = nodeByItem,\n tree = if (prefix.isEmpty()) tree\n else ContainerNode.empty().apply {\n set(prefix, tree)\n },\n hasChildren = hasChildren,\n beforeSetFunctions = beforeSetFunctions,\n afterSetFunctions = afterSetFunctions,\n beforeLoadFunctions = beforeLoadFunctions,\n afterLoadFunctions = afterLoadFunctions,\n lock = lock\n ) {\n override val source: Source get() = originalConfig.source.withPrefix(prefix)\n }\n }\n }\n\n override fun iterator(): Iterator> {\n return if (parent != null) {\n (nodeByItem.keys.iterator().asSequence() + parent!!.iterator().asSequence()).iterator()\n } else {\n nodeByItem.keys.iterator()\n }\n }\n\n override val itemWithNames: List, String>>\n get() = lock.read { tree.leafByPath }.map { (name, node) ->\n (node as ItemNode).item to name\n } + (parent?.itemWithNames ?: listOf())\n\n override fun toMap(): Map {\n return lock.read {\n itemWithNames.map { (item, name) ->\n name to try {\n getOrNull(item, errorWhenNotFound = true).toCompatibleValue(mapper)\n } catch (_: UnsetValueException) {\n ValueState.Unset\n }\n }.filter { (_, value) -> value != ValueState.Unset }.toMap()\n }\n }\n\n @Suppress(\"UNCHECKED_CAST\")\n override fun get(item: Item): T = getOrNull(item, errorWhenNotFound = true) as T\n\n @Suppress(\"UNCHECKED_CAST\")\n override fun get(name: String): T = getOrNull(name, errorWhenNotFound = true) as T\n\n @Suppress(\"UNCHECKED_CAST\")\n override fun getOrNull(item: Item): T? = getOrNull(item, errorWhenNotFound = false) as T?\n\n private fun setState(item: Item<*>, state: ValueState) {\n if (item in nodeByItem) {\n nodeByItem[item]!!.value = state\n } else {\n nodeByItem[item] = ItemNode(state, item)\n }\n }\n\n open fun getOrNull(\n item: Item<*>,\n errorWhenNotFound: Boolean,\n errorWhenGetDefault: Boolean = false,\n lazyContext: ItemContainer = this\n ): Any? {\n val valueState = lock.read { nodeByItem[item]?.value }\n if (valueState != null) {\n @Suppress(\"UNCHECKED_CAST\")\n when (valueState) {\n is ValueState.Unset ->\n if (errorWhenNotFound) {\n throw UnsetValueException(item)\n } else {\n return null\n }\n is ValueState.Null -> return null\n is ValueState.Value -> return valueState.value\n is ValueState.Default -> {\n if (errorWhenGetDefault) {\n throw GetDefaultValueException(item)\n } else {\n return valueState.value\n }\n }\n is ValueState.Lazy<*> -> {\n val value = try {\n valueState.thunk(lazyContext)\n } catch (exception: ConfigException) {\n when (exception) {\n is UnsetValueException, is NoSuchItemException -> {\n if (errorWhenNotFound) {\n throw exception\n } else {\n return null\n }\n }\n else -> throw exception\n }\n }\n if (value == null) {\n if (item.nullable) {\n return null\n } else {\n throw InvalidLazySetException(\n \"fail to cast null to ${item.type.rawClass}\" +\n \" when getting item ${item.name} in config\"\n )\n }\n } else {\n if (item.type.rawClass.isInstance(value)) {\n return value\n } else {\n throw InvalidLazySetException(\n \"fail to cast $value with ${value::class} to ${item.type.rawClass}\" +\n \" when getting item ${item.name} in config\"\n )\n }\n }\n }\n }\n } else {\n if (parent != null) {\n return parent!!.getOrNull(item, errorWhenNotFound, errorWhenGetDefault, lazyContext)\n } else {\n if (errorWhenNotFound) {\n throw NoSuchItemException(item)\n } else {\n return null\n }\n }\n }\n }\n\n open fun getItemOrNull(name: String): Item<*>? {\n val trimmedName = name.trim()\n val item = getItemInLayerOrNull(trimmedName)\n return item ?: parent?.getItemOrNull(trimmedName)\n }\n\n private fun getItemInLayerOrNull(name: String): Item<*>? {\n return lock.read {\n (tree.getOrNull(name) as? ItemNode)?.item\n }\n }\n\n @Suppress(\"UNCHECKED_CAST\")\n override fun getOrNull(name: String): T? = getOrNull(name, errorWhenNotFound = false) as T?\n\n private fun getOrNull(name: String, errorWhenNotFound: Boolean): Any? {\n val item = getItemOrNull(name)\n return if (item != null) {\n getOrNull(item, errorWhenNotFound)\n } else {\n if (errorWhenNotFound) {\n throw NoSuchItemException(name)\n } else {\n null\n }\n }\n }\n\n private fun containsInLayer(item: Item<*>) = lock.read { nodeByItem.containsKey(item) }\n\n override fun contains(item: Item<*>): Boolean {\n return if (containsInLayer(item)) {\n true\n } else {\n parent?.contains(item) ?: false\n }\n }\n\n private fun containsInLayer(name: String): Boolean {\n return containsInLayer(name.toPath())\n }\n\n override fun contains(name: String): Boolean {\n return if (containsInLayer(name)) {\n true\n } else {\n parent?.contains(name) ?: false\n }\n }\n\n private fun TreeNode.partialMatch(path: Path): Boolean {\n return if (this is LeafNode) {\n true\n } else if (path.isEmpty()) {\n !isEmpty()\n } else {\n val key = path.first()\n val rest = path.drop(1)\n val result = children[key]\n if (result != null) {\n return result.partialMatch(rest)\n } else {\n return false\n }\n }\n }\n\n private fun containsInLayer(path: Path): Boolean {\n return lock.read {\n tree.partialMatch(path)\n }\n }\n\n override fun contains(path: Path): Boolean =\n containsInLayer(path) || (parent?.contains(path) ?: false)\n\n override fun nameOf(item: Item<*>): String {\n return nameByItem[item] ?: {\n val name = lock.read { tree.firstPath { it is ItemNode && it.item == item } }?.name\n if (name != null) {\n nameByItem[item] = name\n name\n } else {\n parent?.nameOf(item) ?: throw NoSuchItemException(item)\n }\n }()\n }\n\n open fun addBeforeSetFunction(beforeSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n beforeSetFunctions += beforeSetFunction\n parent?.addBeforeSetFunction(beforeSetFunction)\n }\n\n open fun removeBeforeSetFunction(beforeSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n beforeSetFunctions.remove(beforeSetFunction)\n parent?.removeBeforeSetFunction(beforeSetFunction)\n }\n\n override fun beforeSet(beforeSetFunction: (item: Item<*>, value: Any?) -> Unit): Handler {\n addBeforeSetFunction(beforeSetFunction)\n return object : Handler {\n override fun cancel() {\n removeBeforeSetFunction(beforeSetFunction)\n }\n }\n }\n\n private fun notifyBeforeSet(item: Item<*>, value: Any?) {\n for (beforeSetFunction in beforeSetFunctions) {\n beforeSetFunction(item, value)\n }\n }\n\n open fun addAfterSetFunction(afterSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n afterSetFunctions += afterSetFunction\n parent?.addAfterSetFunction(afterSetFunction)\n }\n\n open fun removeAfterSetFunction(afterSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n afterSetFunctions.remove(afterSetFunction)\n parent?.removeAfterSetFunction(afterSetFunction)\n }\n\n override fun afterSet(afterSetFunction: (item: Item<*>, value: Any?) -> Unit): Handler {\n addAfterSetFunction(afterSetFunction)\n return object : Handler {\n override fun cancel() {\n removeAfterSetFunction(afterSetFunction)\n }\n }\n }\n\n private fun notifyAfterSet(item: Item<*>, value: Any?) {\n for (afterSetFunction in afterSetFunctions) {\n afterSetFunction(item, value)\n }\n }\n\n override fun rawSet(item: Item<*>, value: Any?) {\n if (item in this) {\n if (value == null) {\n if (item.nullable) {\n item.notifySet(null)\n item.notifyBeforeSet(this, value)\n notifyBeforeSet(item, value)\n lock.write {\n setState(item, ValueState.Null)\n }\n notifyAfterSet(item, value)\n item.notifyAfterSet(this, value)\n } else {\n throw ClassCastException(\n \"fail to cast null to ${item.type.rawClass}\" +\n \" when setting item ${item.name} in config\"\n )\n }\n } else {\n if (item.type.rawClass.isInstance(value)) {\n item.notifySet(value)\n item.notifyBeforeSet(this, value)\n notifyBeforeSet(item, value)\n lock.write {\n setState(item, ValueState.Value(value))\n }\n notifyAfterSet(item, value)\n item.notifyAfterSet(this, value)\n } else {\n throw ClassCastException(\n \"fail to cast $value with ${value::class} to ${item.type.rawClass}\" +\n \" when setting item ${item.name} in config\"\n )\n }\n }\n } else {\n throw NoSuchItemException(item)\n }\n }\n\n override fun set(item: Item, value: T) {\n rawSet(item, value)\n }\n\n override fun set(name: String, value: T) {\n val item = getItemOrNull(name)\n if (item != null) {\n @Suppress(\"UNCHECKED_CAST\")\n set(item as Item, value)\n } else {\n throw NoSuchItemException(name)\n }\n }\n\n override fun lazySet(item: Item, thunk: (config: ItemContainer) -> T) {\n if (item in this) {\n lock.write {\n setState(item, ValueState.Lazy(thunk))\n }\n } else {\n throw NoSuchItemException(item)\n }\n }\n\n override fun lazySet(name: String, thunk: (config: ItemContainer) -> T) {\n val item = getItemOrNull(name)\n if (item != null) {\n @Suppress(\"UNCHECKED_CAST\")\n lazySet(item as Item, thunk)\n } else {\n throw NoSuchItemException(name)\n }\n }\n\n override fun unset(item: Item<*>) {\n if (item in this) {\n lock.write {\n setState(item, ValueState.Unset)\n }\n } else {\n throw NoSuchItemException(item)\n }\n }\n\n override fun unset(name: String) {\n val item = getItemOrNull(name)\n if (item != null) {\n unset(item)\n } else {\n throw NoSuchItemException(name)\n }\n }\n\n override fun clear() {\n lock.write {\n nodeByItem.clear()\n tree.children.clear()\n if (tree is MapNode) {\n tree.isPlaceHolder = true\n }\n }\n }\n\n override fun clearAll() {\n clear()\n parent?.clearAll()\n }\n\n override fun containsRequired(): Boolean = try {\n validateRequired()\n true\n } catch (ex: UnsetValueException) {\n false\n }\n\n override fun validateRequired(): Config {\n for (item in this) {\n if (item is RequiredItem) {\n getOrNull(item, errorWhenNotFound = true)\n }\n }\n return this\n }\n\n override fun plus(config: Config): Config {\n return when (config) {\n is BaseConfig -> MergedConfig(this, config)\n else -> config.withFallback(this)\n }\n }\n\n override fun withFallback(config: Config): Config {\n return config + this\n }\n\n override fun property(item: Item): ReadWriteProperty {\n if (!contains(item)) {\n throw NoSuchItemException(item)\n }\n return object : ReadWriteProperty {\n override fun getValue(thisRef: Any?, property: KProperty<*>): T = get(item)\n\n override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) =\n set(item, value)\n }\n }\n\n override fun property(name: String): ReadWriteProperty {\n if (!contains(name)) {\n throw NoSuchItemException(name)\n }\n return object : ReadWriteProperty {\n override fun getValue(thisRef: Any?, property: KProperty<*>): T = get(name)\n\n override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) =\n set(name, value)\n }\n }\n\n override val specs: List get() = lock.read { specsInLayer + (parent?.specs ?: listOf()) }\n\n override val sources: List\n get() {\n return lock.read { mutableListOf(source) }.apply {\n for (source in parent?.sources ?: listOf()) {\n add(source)\n }\n }\n }\n\n override fun enable(feature: Feature): Config {\n return apply {\n lock.write {\n featuresInLayer[feature] = true\n }\n }\n }\n\n override fun disable(feature: Feature): Config {\n return apply {\n lock.write {\n featuresInLayer[feature] = false\n }\n }\n }\n\n override fun isEnabled(feature: Feature): Boolean {\n return lock.read {\n featuresInLayer[feature] ?: parent?.isEnabled(feature) ?: feature.enabledByDefault\n }\n }\n\n override fun addItem(item: Item<*>, prefix: String) {\n lock.write {\n if (hasChildren.value) {\n throw LayerFrozenException(this)\n }\n val path = prefix.toPath() + item.name.toPath()\n val name = path.name\n if (item !in this) {\n if (path in this) {\n throw NameConflictException(\"item $name cannot be added\")\n }\n val node = ItemNode(\n when (item) {\n is OptionalItem -> ValueState.Default(item.default)\n is RequiredItem -> ValueState.Unset\n is LazyItem -> ValueState.Lazy(item.thunk)\n },\n item\n )\n tree[name] = node\n nodeByItem[item] = node\n val sources = this.sources\n val mergedSource = if (sources.isNotEmpty()) {\n sources.reduceRight { source, acc -> MergedSource(source, acc) }\n } else {\n null\n }\n mergedSource?.let { loadItem(item, path, it) }\n } else {\n throw RepeatedItemException(name)\n }\n }\n }\n\n override fun addSpec(spec: Spec) {\n lock.write {\n if (hasChildren.value) {\n throw LayerFrozenException(this)\n }\n val sources = this.sources\n val mergedSource = if (sources.isNotEmpty()) {\n sources.reduceRight { source, acc -> MergedSource(source, acc) }\n } else {\n null\n }\n spec.items.forEach { item ->\n val name = spec.qualify(item)\n if (item !in this) {\n val path = name.toPath()\n if (path in this) {\n throw NameConflictException(\"item $name cannot be added\")\n }\n val node = ItemNode(\n when (item) {\n is OptionalItem -> ValueState.Default(item.default)\n is RequiredItem -> ValueState.Unset\n is LazyItem -> ValueState.Lazy(item.thunk)\n },\n item\n )\n tree[name] = node\n nodeByItem[item] = node\n mergedSource?.let { loadItem(item, path, it) }\n } else {\n throw RepeatedItemException(name)\n }\n }\n spec.innerSpecs.forEach { innerSpec ->\n addSpec(innerSpec.withPrefix(spec.prefix))\n }\n specsInLayer += spec\n }\n }\n\n override fun withLayer(name: String): BaseConfig {\n lock.write { hasChildren.value = true }\n return BaseConfig(name, this, mapper)\n }\n\n open fun addBeforeLoadFunction(beforeLoadFunction: (source: Source) -> Unit) {\n beforeLoadFunctions += beforeLoadFunction\n parent?.addBeforeLoadFunction(beforeLoadFunction)\n }\n\n open fun removeBeforeLoadFunction(beforeLoadFunction: (source: Source) -> Unit) {\n beforeLoadFunctions.remove(beforeLoadFunction)\n parent?.removeBeforeLoadFunction(beforeLoadFunction)\n }\n\n override fun beforeLoad(beforeLoadFunction: (source: Source) -> Unit): Handler {\n addBeforeLoadFunction(beforeLoadFunction)\n return object : Handler {\n override fun cancel() {\n removeBeforeLoadFunction(beforeLoadFunction)\n }\n }\n }\n\n private fun notifyBeforeLoad(source: Source) {\n for (beforeLoadFunction in beforeLoadFunctions) {\n beforeLoadFunction(source)\n }\n }\n\n open fun addAfterLoadFunction(afterLoadFunction: (source: Source) -> Unit) {\n afterLoadFunctions += afterLoadFunction\n parent?.addAfterLoadFunction(afterLoadFunction)\n }\n\n open fun removeAfterLoadFunction(afterLoadFunction: (source: Source) -> Unit) {\n afterLoadFunctions.remove(afterLoadFunction)\n parent?.removeAfterLoadFunction(afterLoadFunction)\n }\n\n override fun afterLoad(afterLoadFunction: (source: Source) -> Unit): Handler {\n addAfterLoadFunction(afterLoadFunction)\n return object : Handler {\n override fun cancel() {\n removeAfterLoadFunction(afterLoadFunction)\n }\n }\n }\n\n private fun notifyAfterLoad(source: Source) {\n for (afterLoadFunction in afterLoadFunctions) {\n afterLoadFunction(source)\n }\n }\n\n override fun withSource(source: Source): Config {\n return withLayer(\"source: ${source.description}\").also { config ->\n config.lock.write {\n config._source.value = load(config, source)\n }\n }\n }\n\n override fun withLoadTrigger(\n description: String,\n trigger: (\n config: Config,\n load: (source: Source) -> Unit\n ) -> Unit\n ): Config {\n return withLayer(\"trigger: $description\").apply {\n trigger(this) { source ->\n notifyBeforeLoad(source)\n lock.write {\n this._source.value = load(this, source)\n }\n notifyAfterLoad(source)\n }\n }\n }\n\n override fun toString(): String {\n return \"Config(items=${toMap()})\"\n }\n\n class ItemNode(override var value: ValueState, val item: Item<*>) : ValueNode\n\n data class Value(var value: T)\n\n sealed class ValueState {\n object Unset : ValueState()\n object Null : ValueState()\n data class Lazy(val thunk: (config: ItemContainer) -> T) : ValueState()\n data class Value(val value: Any) : ValueState()\n data class Default(val value: Any?) : ValueState()\n }\n}\n\n/**\n * Returns a new default object mapper for config.\n */\nfun createDefaultMapper(): ObjectMapper = jacksonObjectMapper()\n .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)\n .disable(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS)\n .enable(SerializationFeature.WRITE_DATES_WITH_ZONE_ID)\n .enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)\n .enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)\n .apply {\n coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty)\n }\n .registerModules(\n SimpleModule()\n .addDeserializer(String::class.java, StringDeserializer)\n .setDeserializerModifier(EmptyStringToCollectionDeserializerModifier),\n JavaTimeModule()\n .addDeserializer(Duration::class.java, DurationDeserializer)\n .addDeserializer(OffsetDateTime::class.java, OffsetDateTimeDeserializer)\n .addDeserializer(ZonedDateTime::class.java, ZoneDateTimeDeserializer)\n )\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/Config.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.fasterxml.jackson.databind.JavaType\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport com.fasterxml.jackson.databind.type.TypeFactory\nimport com.uchuhimo.konf.annotation.JavaApi\nimport com.uchuhimo.konf.source.DefaultLoaders\nimport com.uchuhimo.konf.source.Source\nimport com.uchuhimo.konf.source.base.kvToTree\nimport kotlin.properties.PropertyDelegateProvider\nimport kotlin.properties.ReadWriteProperty\nimport kotlin.reflect.KProperty\n\n/**\n * Config containing items and associated values.\n *\n * Config contains items, which can be loaded with [addSpec].\n * Config contains values, each of which is associated with corresponding item.\n * Values can be loaded from [source][Source] with [withSource] or [from].\n *\n * Config contains read-write access operations for item.\n * Items in config is in one of three states:\n * - Unset. Item has not associated value in this state.\n * Use [unset] to change item to this state.\n * - Unevaluated. Item is lazy and the associated value will be evaluated when accessing.\n * Use [lazySet] to change item to this state.\n * - Evaluated. Item has associated value which is evaluated.\n * Use [set] to change item to this state.\n *\n * Config is cascading.\n * Config can fork from another config by adding a new layer on it.\n * The forked config is called child config, and the original config is called parent config.\n * A config without parent config is called root config. The new layer added by child config\n * is called facade layer.\n * Config with ancestor configs has multiple layers. All set operation is executed in facade layer\n * of config.\n * Descendant config inherits items and values in ancestor configs, and can override values for\n * items in ancestor configs. Overridden values in config will affect itself and its descendant\n * configs, without affecting its ancestor configs. Loading items in config will not affect its\n * ancestor configs too. [invoke] can be used to create a root config, and [withLayer] can be used\n * to create a child config from specified config.\n *\n * All methods in Config is thread-safe.\n */\ninterface Config : ItemContainer {\n /**\n * Associate item with specified value without type checking.\n *\n * @param item config item\n * @param value associated value\n */\n fun rawSet(item: Item<*>, value: Any?)\n\n /**\n * Associate item with specified value.\n *\n * @param item config item\n * @param value associated value\n */\n operator fun set(item: Item, value: T)\n\n /**\n * Find item with specified name, and associate it with specified value.\n *\n * @param name item name\n * @param value associated value\n */\n operator fun set(name: String, value: T)\n\n /**\n * Associate item with specified thunk, which can be used to evaluate value for the item.\n *\n * @param item config item\n * @param thunk thunk used to evaluate value for the item\n */\n fun lazySet(item: Item, thunk: (config: ItemContainer) -> T)\n\n /**\n * Find item with specified name, and associate item with specified thunk,\n * which can be used to evaluate value for the item.\n *\n * @param name item name\n * @param thunk thunk used to evaluate value for the item\n */\n fun lazySet(name: String, thunk: (config: ItemContainer) -> T)\n\n /**\n * Discard associated value of specified item.\n *\n * @param item config item\n */\n fun unset(item: Item<*>)\n\n /**\n * Discard associated value of item with specified name.\n *\n * @param name item name\n */\n fun unset(name: String)\n\n /**\n * Subscribe the update event before every set operation.\n *\n * @param beforeSetFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun beforeSet(beforeSetFunction: (item: Item<*>, value: Any?) -> Unit): Handler\n\n /**\n * Subscribe the update event after every set operation.\n *\n * @param afterSetFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun afterSet(afterSetFunction: (item: Item<*>, value: Any?) -> Unit): Handler\n\n /**\n * Remove all values from the facade layer of this config.\n */\n fun clear()\n\n /**\n * Remove all values from all layers of this config.\n */\n fun clearAll()\n\n /**\n * Whether all required items have values or not.\n *\n * @return `true` if all required items have values, `false` otherwise\n */\n fun containsRequired(): Boolean\n\n /**\n * Validate whether all required items have values or not. If not, throws [UnsetValueException].\n *\n * @return the current config\n */\n fun validateRequired(): Config\n\n /**\n * Returns a property that can read/set associated value for specified item.\n *\n * @param item config item\n * @return a property that can read/set associated value for specified item\n */\n fun property(item: Item): ReadWriteProperty\n\n /**\n * Returns a property that can read/set associated value for item with specified name.\n *\n * @param name item name\n * @return a property that can read/set associated value for item with specified name\n */\n fun property(name: String): ReadWriteProperty\n\n /**\n * Name of facade layer of config.\n *\n * Layer name provides information for facade layer in a cascading config.\n */\n val name: String\n\n /**\n * Returns parent of this config, or `null` if this config is a root config.\n */\n val parent: Config?\n\n /**\n * List of config specs from all layers of this config.\n */\n val specs: List\n\n /**\n * List of sources from all layers of this config.\n */\n val sources: List\n\n /**\n * Returns a config overlapped by the specified facade config.\n *\n * All operations will be applied to the facade config first,\n * and then fall back to this config when necessary.\n *\n * @param config the facade config\n * @return a config overlapped by the specified facade config\n */\n operator fun plus(config: Config): Config\n\n /**\n * Returns a config backing by the specified fallback config.\n *\n * All operations will be applied to this config first,\n * and then fall back to the fallback config when necessary.\n *\n * @param config the fallback config\n * @return a config backing by the specified fallback config\n */\n fun withFallback(config: Config): Config\n\n /**\n * Returns sub-config in the specified path.\n *\n * @param path the specified path\n * @return sub-config in the specified path\n */\n fun at(path: String): Config\n\n /**\n * Returns config with the specified additional prefix.\n *\n * @param prefix additional prefix\n * @return config with the specified additional prefix\n */\n fun withPrefix(prefix: String): Config\n\n /**\n * Load item into facade layer with the specified prefix.\n *\n * Same item cannot be added twice.\n * The item cannot have same qualified name with existed items in config.\n *\n * @param item config item\n * @param prefix prefix for the config item\n */\n fun addItem(item: Item<*>, prefix: String = \"\")\n\n /**\n * Load items in specified config spec into facade layer.\n *\n * Same config spec cannot be added twice.\n * All items in specified config spec cannot have same qualified name with existed items in config.\n *\n * @param spec config spec\n */\n fun addSpec(spec: Spec)\n\n /**\n * Executes the given [action] after locking the facade layer of this config.\n *\n * @param action the given action\n * @return the return value of the action.\n */\n fun lock(action: () -> T): T\n\n /**\n * Returns a child config of this config with specified name.\n *\n * @param name name of facade layer in child config\n * @return a child config\n */\n fun withLayer(name: String = \"\"): Config\n\n /**\n * Returns a child config containing values from specified source.\n *\n * Values from specified source will be loaded into facade layer of the returned child config\n * without affecting this config.\n *\n * @param source config source\n * @return a child config containing value from specified source\n */\n fun withSource(source: Source): Config\n\n /**\n * Returns a child config containing values loaded by specified trigger.\n *\n * Values loaded by specified trigger will be loaded into facade layer of\n * the returned child config without affecting this config.\n *\n * @param description trigger description\n * @param trigger load trigger\n * @return a child config containing value loaded by specified trigger\n */\n fun withLoadTrigger(\n description: String,\n trigger: (\n config: Config,\n load: (source: Source) -> Unit\n ) -> Unit\n ): Config\n\n /**\n * Subscribe the update event before every load operation.\n *\n * @param beforeLoadFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun beforeLoad(beforeLoadFunction: (source: Source) -> Unit): Handler\n\n /**\n * Subscribe the update event after every load operation.\n *\n * @param afterLoadFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun afterLoad(afterLoadFunction: (source: Source) -> Unit): Handler\n\n /**\n * Returns default loaders for this config.\n *\n * It is a fluent API for loading source from default loaders.\n *\n * @return default loaders for this config\n */\n @JavaApi\n fun from(): DefaultLoaders = from\n\n /**\n * Returns default loaders for this config.\n *\n * It is a fluent API for loading source from default loaders.\n */\n val from: DefaultLoaders get() = DefaultLoaders(this)\n\n /**\n * Returns [ObjectMapper] using to map from source to value in config.\n */\n val mapper: ObjectMapper\n\n /**\n * Returns a map in key-value format for this config.\n *\n * The returned map contains all items in this config, with item name as key and\n * associated value as value.\n * This map can be loaded into config as [com.uchuhimo.konf.source.base.KVSource] using\n * `config.from.map.kv(map)`.\n */\n fun toMap(): Map\n\n /**\n * Enables the specified feature and returns this config.\n *\n * @param feature the specified feature\n * @return this config\n */\n fun enable(feature: Feature): Config\n\n /**\n * Disables the specified feature and returns this config.\n *\n * @param feature the specified feature\n * @return this config\n */\n fun disable(feature: Feature): Config\n\n /**\n * Check whether the specified feature is enabled or not.\n *\n * @param feature the specified feature\n * @return whether the specified feature is enabled or not\n */\n fun isEnabled(feature: Feature): Boolean\n\n companion object {\n /**\n * Create a new root config.\n *\n * @return a new root config\n */\n operator fun invoke(): Config = BaseConfig()\n\n /**\n * Create a new root config and initiate it.\n *\n * @param init initial action\n * @return a new root config\n */\n operator fun invoke(init: Config.() -> Unit): Config = Config().apply(init)\n }\n}\n\n/**\n * Returns a property that can read/set associated value casted from config.\n *\n * @return a property that can read/set associated value casted from config\n */\ninline fun Config.cast() =\n object : RequiredConfigProperty(this.withPrefix(\"root\").withLayer(), name = \"root\") {}\n\n/**\n * Returns a value casted from config.\n *\n * @return a value casted from config\n */\ninline fun Config.toValue(): T {\n val value by cast()\n return value\n}\n\n/**\n * Returns a property that can read/set associated value for specified required item.\n *\n * @param prefix prefix for the config item\n * @param name item name without prefix\n * @param description description for this item\n * @return a property that can read/set associated value for specified required item\n */\ninline fun Config.required(\n prefix: String = \"\",\n name: String? = null,\n description: String = \"\"\n) =\n object : RequiredConfigProperty(this, prefix, name, description, null is T) {}\n\nopen class RequiredConfigProperty(\n private val config: Config,\n private val prefix: String = \"\",\n private val name: String? = null,\n private val description: String = \"\",\n private val nullable: Boolean = false\n) : PropertyDelegateProvider> {\n override operator fun provideDelegate(thisRef: Any?, property: KProperty<*>):\n ReadWriteProperty {\n val type: JavaType = TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(RequiredConfigProperty::class.java).bindings.typeParameters[0]\n val item = object : RequiredItem(\n Spec.dummy,\n name\n ?: property.name,\n description,\n type,\n nullable\n ) {}\n config.addItem(item, prefix)\n return config.property(item)\n }\n}\n\n/**\n * Returns a property that can read/set associated value for specified optional item.\n *\n * @param default default value returned before associating this item with specified value\n * @param prefix prefix for the config item\n * @param name item name without prefix\n * @param description description for this item\n * @return a property that can read/set associated value for specified optional item\n */\ninline fun Config.optional(\n default: T,\n prefix: String = \"\",\n name: String? = null,\n description: String = \"\"\n) =\n object : OptionalConfigProperty(this, default, prefix, name, description, null is T) {}\n\nopen class OptionalConfigProperty(\n private val config: Config,\n private val default: T,\n private val prefix: String = \"\",\n private val name: String? = null,\n private val description: String = \"\",\n private val nullable: Boolean = false\n) : PropertyDelegateProvider> {\n override operator fun provideDelegate(thisRef: Any?, property: KProperty<*>):\n ReadWriteProperty {\n val type: JavaType = TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(OptionalConfigProperty::class.java).bindings.typeParameters[0]\n val item = object : OptionalItem(\n Spec.dummy,\n name\n ?: property.name,\n default,\n description,\n type,\n nullable\n ) {}\n config.addItem(item, prefix)\n return config.property(item)\n }\n}\n\n/**\n * Returns a property that can read/set associated value for specified lazy item.\n *\n * @param prefix prefix for the config item\n * @param name item name without prefix\n * @param description description for this item\n * @param thunk thunk used to evaluate value for this item\n * @return a property that can read/set associated value for specified lazy item\n */\ninline fun Config.lazy(\n prefix: String = \"\",\n name: String? = null,\n description: String = \"\",\n noinline thunk: (config: ItemContainer) -> T\n) =\n object : LazyConfigProperty(this, thunk, prefix, name, description, null is T) {}\n\nopen class LazyConfigProperty(\n private val config: Config,\n private val thunk: (config: ItemContainer) -> T,\n private val prefix: String = \"\",\n private val name: String? = null,\n private val description: String = \"\",\n private val nullable: Boolean = false\n) : PropertyDelegateProvider> {\n override operator fun provideDelegate(thisRef: Any?, property: KProperty<*>):\n ReadWriteProperty {\n val type: JavaType = TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(LazyConfigProperty::class.java).bindings.typeParameters[0]\n val item = object : LazyItem(\n Spec.dummy,\n name\n ?: property.name,\n thunk,\n description,\n type,\n nullable\n ) {}\n config.addItem(item, prefix)\n return config.property(item)\n }\n}\n\n/**\n * Convert the config to a tree node.\n *\n * @return a tree node\n */\nfun Config.toTree(): TreeNode {\n return toMap().kvToTree()\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/ConfigException.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\n/**\n * Exception for config.\n */\nopen class ConfigException : RuntimeException {\n constructor(message: String) : super(message)\n constructor(message: String, cause: Throwable) : super(message, cause)\n}\n\n/**\n * Exception indicates that there is existed item with same name in config.\n */\nclass RepeatedItemException(val name: String) : ConfigException(\"item $name has been added\")\n\n/**\n * Exception indicates that there is existed inner spec in config.\n */\nclass RepeatedInnerSpecException(val spec: Spec) :\n ConfigException(\"spec ${spec.javaClass.simpleName}(prefix=\\\"${spec.prefix}\\\") has been added\")\n\n/**\n * Exception indicates that there is existed item with conflicted name in config.\n */\nclass NameConflictException(message: String) : ConfigException(message)\n\n/**\n * Exception indicates that the evaluated result of lazy thunk is invalid.\n */\nclass InvalidLazySetException(message: String) : ConfigException(message)\n\nval Item<*>.asName: String get() = \"item $name\"\n\n/**\n * Exception indicates that the specified item is in unset state.\n */\nclass UnsetValueException(val name: String) : ConfigException(\"$name is unset\") {\n constructor(item: Item<*>) : this(item.asName)\n}\n\n/**\n * Exception indicates that the specified item has default value.\n */\nclass GetDefaultValueException(val name: String) : ConfigException(\"$name has default value\") {\n constructor(item: Item<*>) : this(item.asName)\n}\n\n/**\n * Exception indicates that the specified item is not in this config.\n */\nclass NoSuchItemException(val name: String) : ConfigException(\"cannot find $name in config\") {\n constructor(item: Item<*>) : this(item.asName)\n}\n\n/**\n * Exception indicates that item cannot be added to this config because it has child layer.\n */\nclass LayerFrozenException(val config: Config) :\n ConfigException(\"config ${config.name} has child layer, cannot add new item\")\n\n/**\n * Exception indicates that expected value in specified path is not existed in the source.\n */\nclass NoSuchPathException(val path: String) :\n ConfigException(\"cannot find path \\\"$path\\\" in config spec\")\n\n/**\n * Exception indicates that the specified path is invalid.\n */\nclass InvalidPathException(val path: String) :\n ConfigException(\"\\\"$path\\\" is not a valid path\")\n\n/**\n * Exception indicates that the specified path conflicts with existed paths in the tree node.\n */\nclass PathConflictException(val path: String) :\n ConfigException(\"\\\"$path\\\" conflicts with existed paths in the tree node\")\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/ConfigSpec.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.fasterxml.jackson.module.kotlin.isKotlinClass\n\n/**\n * The default implementation for [Spec].\n *\n * @param prefix common prefix for items in this config spec\n */\nopen class ConfigSpec @JvmOverloads constructor(\n prefix: String? = null,\n items: Set> = mutableSetOf(),\n innerSpecs: Set = mutableSetOf()\n) : Spec {\n final override val prefix: String = prefix ?: {\n if (javaClass == ConfigSpec::class.java || javaClass.isAnonymousClass) {\n \"\"\n } else {\n javaClass.let { clazz ->\n if (this::class.isCompanion) clazz.declaringClass else clazz\n }.simpleName.let { name ->\n if (name == null || name.contains('$')) {\n \"\"\n } else {\n name.toLittleCase()\n }\n }.let { name ->\n if (name.endsWith(\"Spec\")) {\n name.removeSuffix(\"Spec\")\n } else {\n name\n }\n }\n }\n }()\n\n init {\n checkPath(this.prefix)\n }\n\n private val _items = items as? MutableSet> ?: items.toMutableSet()\n\n override val items: Set> = _items\n\n override fun addItem(item: Item<*>) {\n if (item !in _items) {\n _items += item\n } else {\n throw RepeatedItemException(item.name)\n }\n }\n\n private val _innerSpecs = innerSpecs as? MutableSet ?: innerSpecs.toMutableSet()\n\n override val innerSpecs: Set = _innerSpecs\n\n override fun addInnerSpec(spec: Spec) {\n if (spec !in _innerSpecs) {\n _innerSpecs += spec\n } else {\n throw RepeatedInnerSpecException(spec)\n }\n }\n\n init {\n if (javaClass.isKotlinClass()) {\n javaClass.kotlin.nestedClasses.map {\n it.objectInstance\n }.filterIsInstance().forEach { spec ->\n addInnerSpec(spec)\n }\n }\n }\n\n /**\n * Specify a required item in this config spec.\n *\n * @param name item name without prefix\n * @param description description for this item\n * @return a property of a required item with prefix of this config spec\n */\n inline fun required(name: String? = null, description: String = \"\") =\n object : RequiredProperty(this, name, description, null is T) {}\n\n /**\n * Specify an optional item in this config spec.\n *\n * @param default default value returned before associating this item with specified value\n * @param name item name without prefix\n * @param description description for this item\n *\n * @return a property of an optional item with prefix of this config spec\n */\n inline fun optional(default: T, name: String? = null, description: String = \"\") =\n object : OptionalProperty(this, default, name, description, null is T) {}\n\n /**\n * Specify a lazy item in this config spec.\n *\n * @param name item name without prefix\n * @param description description for this item\n * @param thunk thunk used to evaluate value for this item\n * @return a property of a lazy item with prefix of this config spec\n */\n inline fun lazy(\n name: String? = null,\n description: String = \"\",\n noinline thunk: (config: ItemContainer) -> T\n ) =\n object : LazyProperty(this, thunk, name, description, null is T) {}\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/Feature.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\n/**\n * Enumeration that defines simple on/off features.\n */\nenum class Feature(val enabledByDefault: Boolean) {\n /**\n * Feature that determines what happens when unknown paths appear in the source.\n * If enabled, an exception is thrown when loading from the source\n * to indicate it contains unknown paths.\n *\n * Feature is disabled by default.\n */\n FAIL_ON_UNKNOWN_PATH(false),\n /**\n * Feature that determines whether loading keys from sources case-insensitively.\n *\n * Feature is disabled by default.\n */\n LOAD_KEYS_CASE_INSENSITIVELY(false),\n /**\n * Feature that determines whether loading keys from sources as little camel case.\n *\n * Feature is enabled by default.\n */\n LOAD_KEYS_AS_LITTLE_CAMEL_CASE(true),\n /**\n * Feature that determines whether sources are optional by default.\n *\n * Feature is disabled by default.\n */\n OPTIONAL_SOURCE_BY_DEFAULT(false),\n /**\n * Feature that determines whether sources should be substituted before loaded into config.\n *\n * Feature is enabled by default.\n */\n SUBSTITUTE_SOURCE_BEFORE_LOADED(true)\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/Item.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.fasterxml.jackson.databind.JavaType\nimport com.fasterxml.jackson.databind.type.TypeFactory\n\n/**\n * Item that can be contained by config.\n *\n * Item can be associated with value in config, containing metadata for the value.\n * The metadata for value includes name, path, type, description and so on.\n * Item can be used as key to operate value in config, guaranteeing type safety.\n * There are three kinds of item: [required item][RequiredItem], [optional item][OptionalItem]\n * and [lazy item][LazyItem].\n *\n * @param T type of value that can be associated with this item.\n * @param spec config spec that contains this item\n * @param name item name without prefix\n * @param description description for this item\n * @see Config\n */\nsealed class Item(\n /**\n * Config spec that contains this item.\n */\n val spec: Spec,\n /**\n * Item name without prefix.\n */\n val name: String,\n /**\n * Description for this item.\n */\n val description: String = \"\",\n type: JavaType? = null,\n val nullable: Boolean = false\n) {\n init {\n checkPath(name)\n @Suppress(\"LeakingThis\")\n spec.addItem(this)\n }\n\n /**\n * Item path without prefix.\n */\n val path: Path = this.name.toPath()\n\n /**\n * Type of value that can be associated with this item.\n */\n @Suppress(\"LeakingThis\")\n val type: JavaType = type ?: TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(Item::class.java).bindings.typeParameters[0]\n\n /**\n * Whether this is a required item or not.\n */\n open val isRequired: Boolean get() = false\n\n /**\n * Whether this is an optional item or not.\n */\n open val isOptional: Boolean get() = false\n\n /**\n * Whether this is a lazy item or not.\n */\n open val isLazy: Boolean get() = false\n\n /**\n * Cast this item to a required item.\n */\n val asRequiredItem: RequiredItem get() = this as RequiredItem\n\n /**\n * Cast this item to an optional item.\n */\n val asOptionalItem: OptionalItem get() = this as OptionalItem\n\n /**\n * Cast this item to a lazy item.\n */\n val asLazyItem: LazyItem get() = this as LazyItem\n\n private val onSetFunctions: MutableList<(value: T) -> Unit> = mutableListOf()\n private val beforeSetFunctions: MutableList<(config: Config, value: T) -> Unit> = mutableListOf()\n private val afterSetFunctions: MutableList<(config: Config, value: T) -> Unit> = mutableListOf()\n\n /**\n * Subscribe the update event of this item.\n *\n * @param onSetFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun onSet(onSetFunction: (value: T) -> Unit): Handler {\n onSetFunctions += onSetFunction\n return object : Handler {\n override fun cancel() {\n onSetFunctions.remove(onSetFunction)\n }\n }\n }\n\n /**\n * Subscribe the update event of this item before every set operation.\n *\n * @param beforeSetFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun beforeSet(beforeSetFunction: (config: Config, value: T) -> Unit): Handler {\n beforeSetFunctions += beforeSetFunction\n return object : Handler {\n override fun cancel() {\n beforeSetFunctions.remove(beforeSetFunction)\n }\n }\n }\n\n /**\n * Subscribe the update event of this item after every set operation.\n *\n * @param afterSetFunction the subscription function\n * @return the handler to cancel this subscription\n */\n fun afterSet(afterSetFunction: (config: Config, value: T) -> Unit): Handler {\n afterSetFunctions += afterSetFunction\n return object : Handler {\n override fun cancel() {\n afterSetFunctions.remove(afterSetFunction)\n }\n }\n }\n\n fun notifySet(value: Any?) {\n for (onSetFunction in onSetFunctions) {\n @Suppress(\"UNCHECKED_CAST\")\n onSetFunction(value as T)\n }\n }\n\n fun notifyBeforeSet(config: Config, value: Any?) {\n for (beforeSetFunction in beforeSetFunctions) {\n @Suppress(\"UNCHECKED_CAST\")\n beforeSetFunction(config, value as T)\n }\n }\n\n fun notifyAfterSet(config: Config, value: Any?) {\n for (afterSetFunction in afterSetFunctions) {\n @Suppress(\"UNCHECKED_CAST\")\n afterSetFunction(config, value as T)\n }\n }\n}\n\ninterface Handler : AutoCloseable {\n fun cancel()\n\n override fun close() {\n cancel()\n }\n}\n\n/**\n * Type of Item path.\n */\ntypealias Path = List\n\n/**\n * Returns corresponding item name of the item path.\n *\n * @receiver item path\n * @return item name\n */\nval Path.name: String get() = joinToString(\".\")\n\n/**\n * Returns corresponding item path of the item name.\n *\n * @receiver item name\n * @return item path\n */\nfun String.toPath(): Path {\n val name = this.trim()\n return if (name.isEmpty()) {\n listOf()\n } else {\n val path = name.split('.')\n if (\"\" in path) {\n throw InvalidPathException(this)\n }\n path\n }\n}\n\nfun checkPath(path: String) {\n val trimmedPath = path.trim()\n if (trimmedPath.isNotEmpty()) {\n if (\"\" in trimmedPath.split('.')) {\n throw InvalidPathException(path)\n }\n }\n}\n\n/**\n * Required item without default value.\n *\n * Required item must be set with value before retrieved in config.\n */\nopen class RequiredItem @JvmOverloads constructor(\n spec: Spec,\n name: String,\n description: String = \"\",\n type: JavaType? = null,\n nullable: Boolean = false\n) : Item(spec, name, description, type, nullable) {\n override val isRequired: Boolean = true\n}\n\n/**\n * Optional item with default value.\n *\n * Before associated with specified value, default value will be returned when accessing.\n * After associated with specified value, the specified value will be returned when accessing.\n */\nopen class OptionalItem @JvmOverloads constructor(\n spec: Spec,\n name: String,\n /**\n * Default value returned before associating this item with specified value.\n */\n val default: T,\n description: String = \"\",\n type: JavaType? = null,\n nullable: Boolean = false\n) : Item(spec, name, description, type, nullable) {\n init {\n if (!nullable) {\n requireNotNull(default)\n }\n }\n\n override val isOptional: Boolean = true\n}\n\n/**\n * Lazy item evaluated value every time from thunk before associated with specified value.\n *\n * Before associated with specified value, value evaluated from thunk will be returned when accessing.\n * After associated with specified value, the specified value will be returned when accessing.\n * Returned value of the thunk will not be cached. The thunk will be evaluated every time\n * when needed to reflect modifying of other values in config.\n */\nopen class LazyItem @JvmOverloads constructor(\n spec: Spec,\n name: String,\n /**\n * Thunk used to evaluate value for this item.\n *\n * [ItemContainer] is provided as evaluation environment to avoid unexpected modification\n * to config.\n * Thunk will be evaluated every time when needed to reflect modifying of other values in config.\n */\n val thunk: (config: ItemContainer) -> T,\n description: String = \"\",\n type: JavaType? = null,\n nullable: Boolean = false\n) : Item(spec, name, description, type, nullable) {\n override val isLazy: Boolean = true\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/ItemContainer.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\n/**\n * Container of items.\n *\n * Item container contains read-only access operations for item.\n *\n * @see Config\n */\ninterface ItemContainer : Iterable> {\n /**\n * Get associated value with specified item.\n *\n * @param item config item\n * @return associated value\n */\n operator fun get(item: Item): T\n\n /**\n * Get associated value with specified item name.\n *\n * @param name item name\n * @return associated value\n */\n operator fun get(name: String): T\n\n /**\n * Returns associated value if specified item exists, `null` otherwise.\n *\n * @param item config item\n * @return associated value if specified item exists, `null` otherwise\n */\n fun getOrNull(item: Item): T?\n\n /**\n * Returns associated value if specified item name exists, `null` otherwise.\n *\n * @param name item name\n * @return associated value if specified item name exists, `null` otherwise\n */\n fun getOrNull(name: String): T?\n\n /**\n * Get associated value with specified item name.\n *\n * @param name item name\n * @return associated value\n */\n operator fun invoke(name: String): T = get(name)\n\n /**\n * Returns iterator of items in this item container.\n *\n * @return iterator of items in this item container\n */\n override operator fun iterator(): Iterator>\n\n /**\n * Whether this item container contains specified item or not.\n *\n * @param item config item\n * @return `true` if this item container contains specified item, `false` otherwise\n */\n operator fun contains(item: Item<*>): Boolean\n\n /**\n * Whether this item container contains item with specified name or not.\n *\n * @param name item name\n * @return `true` if this item container contains item with specified name, `false` otherwise\n */\n operator fun contains(name: String): Boolean\n\n /**\n * Whether this item container contains the specified path or not.\n *\n * @param path the specified path\n * @return `true` if this item container contains the specified path, `false` otherwise\n */\n operator fun contains(path: Path): Boolean\n\n /**\n * Returns the qualified name of the specified item.\n *\n * @param item the specified item\n * @return the qualified name of the specified item\n */\n fun nameOf(item: Item<*>): String\n\n /**\n * Returns the qualified path of the specified item.\n *\n * @param item the specified item\n * @return the qualified path of the specified item\n */\n fun pathOf(item: Item<*>): Path = nameOf(item).toPath()\n\n /**\n * List of items in this item container.\n */\n val items: List>\n get() = mutableListOf>().apply {\n addAll(this@ItemContainer.iterator().asSequence())\n }\n\n /**\n * List of qualified names of items in this item container.\n */\n val nameOfItems: List get() = itemWithNames.map { it.second }\n\n /**\n * List of items with the corresponding qualified names in this item container.\n */\n val itemWithNames: List, String>>\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/MergedConfig.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.uchuhimo.konf.source.Source\n\n/**\n * Config that merge [fallback] and [facade].\n *\n * All operations will be applied to [facade] first, and then fall back to [facade] when necessary.\n */\nopen class MergedConfig(val fallback: BaseConfig, val facade: BaseConfig) :\n BaseConfig(\"merged(facade=${facade.name.notEmptyOr(\"\\\"\\\"\")}, fallback=${fallback.name.notEmptyOr(\"\\\"\\\"\")})\") {\n\n override fun rawSet(item: Item<*>, value: Any?) {\n if (item in facade) {\n facade.rawSet(item, value)\n } else {\n fallback.rawSet(item, value)\n }\n }\n\n override fun getItemOrNull(name: String): Item<*>? {\n return facade.getItemOrNull(name) ?: fallback.getItemOrNull(name)\n }\n\n override fun lazySet(item: Item, thunk: (config: ItemContainer) -> T) {\n if (item in facade) {\n facade.lazySet(item, thunk)\n } else {\n fallback.lazySet(item, thunk)\n }\n }\n\n override fun unset(item: Item<*>) {\n if (item in facade) {\n facade.unset(item)\n } else {\n fallback.unset(item)\n }\n }\n\n override fun addBeforeLoadFunction(beforeLoadFunction: (source: Source) -> Unit) {\n facade.addBeforeLoadFunction(beforeLoadFunction)\n fallback.addBeforeLoadFunction(beforeLoadFunction)\n }\n\n override fun removeBeforeLoadFunction(beforeLoadFunction: (source: Source) -> Unit) {\n facade.removeBeforeLoadFunction(beforeLoadFunction)\n fallback.removeBeforeLoadFunction(beforeLoadFunction)\n }\n\n override fun addAfterLoadFunction(afterLoadFunction: (source: Source) -> Unit) {\n facade.addAfterLoadFunction(afterLoadFunction)\n fallback.addAfterLoadFunction(afterLoadFunction)\n }\n\n override fun removeAfterLoadFunction(afterLoadFunction: (source: Source) -> Unit) {\n facade.removeAfterLoadFunction(afterLoadFunction)\n fallback.removeAfterLoadFunction(afterLoadFunction)\n }\n\n override fun addBeforeSetFunction(beforeSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n facade.addBeforeSetFunction(beforeSetFunction)\n fallback.addBeforeSetFunction(beforeSetFunction)\n }\n\n override fun removeBeforeSetFunction(beforeSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n facade.removeBeforeSetFunction(beforeSetFunction)\n fallback.removeBeforeSetFunction(beforeSetFunction)\n }\n\n override fun addAfterSetFunction(afterSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n facade.addAfterSetFunction(afterSetFunction)\n fallback.addAfterSetFunction(afterSetFunction)\n }\n\n override fun removeAfterSetFunction(afterSetFunction: (item: Item<*>, value: Any?) -> Unit) {\n facade.removeAfterSetFunction(afterSetFunction)\n fallback.removeAfterSetFunction(afterSetFunction)\n }\n\n override fun clear() {\n facade.clear()\n fallback.clear()\n }\n\n override fun clearAll() {\n facade.clearAll()\n fallback.clearAll()\n }\n\n override val specs: List\n get() = facade.specs + fallback.specs\n\n override val sources: List\n get() = facade.sources.toMutableList().apply {\n for (source in fallback.sources) {\n add(source)\n }\n }\n\n override fun addItem(item: Item<*>, prefix: String) {\n val path = prefix.toPath() + item.name.toPath()\n val name = path.name\n if (item !in fallback) {\n if (path in fallback) {\n throw NameConflictException(\"item $name cannot be added\")\n }\n } else {\n throw RepeatedItemException(name)\n }\n facade.addItem(item, prefix)\n }\n\n override fun addSpec(spec: Spec) {\n spec.items.forEach { item ->\n val name = spec.qualify(item)\n if (item !in fallback) {\n val path = name.toPath()\n if (path in fallback) {\n throw NameConflictException(\"item $name cannot be added\")\n }\n } else {\n throw RepeatedItemException(name)\n }\n }\n facade.addSpec(spec)\n }\n\n override fun lock(action: () -> T): T = facade.lock { fallback.lock(action) }\n\n override fun getOrNull(\n item: Item<*>,\n errorWhenNotFound: Boolean,\n errorWhenGetDefault: Boolean,\n lazyContext: ItemContainer\n ): Any? {\n if (item in facade && item in fallback) {\n try {\n return facade.getOrNull(item, errorWhenNotFound, true, lazyContext)\n } catch (ex: Exception) {\n when (ex) {\n is UnsetValueException -> {\n return fallback.getOrNull(item, errorWhenNotFound, errorWhenGetDefault, lazyContext)\n }\n is GetDefaultValueException -> {\n try {\n return fallback.getOrNull(item, errorWhenNotFound, errorWhenGetDefault, lazyContext)\n } catch (ex: Exception) {\n when (ex) {\n is UnsetValueException -> {\n if (errorWhenGetDefault) {\n throw GetDefaultValueException(item)\n } else {\n return (item as OptionalItem).default\n }\n }\n else -> throw ex\n }\n }\n }\n else -> throw ex\n }\n }\n } else if (item in facade) {\n return facade.getOrNull(item, errorWhenNotFound, errorWhenGetDefault, lazyContext)\n } else {\n return fallback.getOrNull(item, errorWhenNotFound, errorWhenGetDefault, lazyContext)\n }\n }\n\n override fun iterator(): Iterator> =\n (facade.iterator().asSequence() + fallback.iterator().asSequence()).iterator()\n\n override fun contains(item: Item<*>): Boolean = item in facade || item in fallback\n\n override fun contains(name: String): Boolean = name in facade || name in fallback\n\n override fun contains(path: Path): Boolean = path in facade || path in fallback\n\n override fun nameOf(item: Item<*>): String {\n return if (item in facade) {\n facade.nameOf(item)\n } else {\n fallback.nameOf(item)\n }\n }\n\n override val itemWithNames: List, String>>\n get() = facade.itemWithNames + fallback.itemWithNames\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/MergedMap.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nclass MergedMap(val fallback: MutableMap, val facade: MutableMap) : MutableMap {\n override val size: Int\n get() = keys.size\n\n override fun containsKey(key: K): Boolean {\n return facade.containsKey(key) || fallback.containsKey(key)\n }\n\n override fun containsValue(value: V): Boolean {\n return facade.containsValue(value) || fallback.containsValue(value)\n }\n\n override fun get(key: K): V? {\n return facade[key] ?: fallback[key]\n }\n\n override fun isEmpty(): Boolean {\n return facade.isEmpty() && fallback.isEmpty()\n }\n\n override val entries: MutableSet>\n get() = keys.map { it to getValue(it) }.toMap(LinkedHashMap()).entries\n override val keys: MutableSet\n get() = facade.keys.union(fallback.keys).toMutableSet()\n override val values: MutableCollection\n get() = keys.map { getValue(it) }.toMutableList()\n\n override fun clear() {\n facade.clear()\n fallback.clear()\n }\n\n override fun put(key: K, value: V): V? {\n return facade.put(key, value)\n }\n\n override fun putAll(from: Map) {\n facade.putAll(from)\n }\n\n override fun remove(key: K): V? {\n if (key in facade) {\n if (key in fallback) {\n fallback.remove(key)\n }\n return facade.remove(key)\n } else {\n return fallback.remove(key)\n }\n }\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/Prefix.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.uchuhimo.konf.source.Source\n\n/**\n * Convenient class for constructing [Spec]/[Config]/[Source] with prefix.\n */\ndata class Prefix(\n /**\n * The path of the prefix\n */\n val path: String = \"\"\n) {\n /**\n * Returns a config spec with this prefix.\n *\n * @param spec the base config spec\n * @return a config spec with this prefix\n */\n operator fun plus(spec: Spec): Spec = spec.withPrefix(path)\n\n /**\n * Returns a config with this prefix.\n *\n * @param config the base config\n * @return a config with this prefix\n */\n operator fun plus(config: Config): Config = config.withPrefix(path)\n\n /**\n * Returns a source with this prefix.\n *\n * @param source the base source\n * @return a source with this prefix\n */\n operator fun plus(source: Source): Source = source.withPrefix(path)\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/SizeInBytes.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.fasterxml.jackson.annotation.JsonCreator\nimport com.fasterxml.jackson.annotation.JsonValue\nimport com.uchuhimo.konf.source.ParseException\nimport java.io.Serializable\nimport java.math.BigDecimal\nimport java.math.BigInteger\n\n/**\n * Represents size in unit of bytes.\n */\ndata class SizeInBytes(\n /**\n * Number of bytes.\n */\n @JsonValue\n val bytes: Long\n) : Serializable {\n init {\n require(bytes >= 0)\n }\n\n companion object {\n /**\n * Parses a size-in-bytes string. If no units are specified in the string,\n * it is assumed to be in bytes. The returned value is in bytes.\n *\n * @param input the string to parse\n * @return size in bytes\n */\n @JsonCreator\n @JvmStatic\n fun parse(input: String): SizeInBytes {\n val s = input.trim()\n val unitString = getUnits(s)\n val numberString = s.substring(\n 0,\n s.length - unitString.length\n ).trim()\n\n // this would be caught later anyway, but the error message\n // is more helpful if we check it here.\n if (numberString.isEmpty())\n throw ParseException(\"No number in size-in-bytes value '$input'\")\n\n val units = MemoryUnit.parseUnit(unitString)\n ?: throw ParseException(\n \"Could not parse size-in-bytes unit '$unitString'\" +\n \" (try k, K, kB, KiB, kilobytes, kibibytes)\"\n )\n\n try {\n val result: BigInteger\n // if the string is purely digits, parse as an integer to avoid\n // possible precision loss; otherwise as a double.\n result = if (numberString.matches(\"[0-9]+\".toRegex())) {\n units.bytes.multiply(BigInteger(numberString))\n } else {\n val resultDecimal = BigDecimal(units.bytes).multiply(BigDecimal(numberString))\n resultDecimal.toBigInteger()\n }\n return if (result.bitLength() < 64) {\n SizeInBytes(result.toLong())\n } else {\n throw ParseException(\"size-in-bytes value is out of range for a 64-bit long: '$input'\")\n }\n } catch (e: NumberFormatException) {\n throw ParseException(\"Could not parse size-in-bytes number '$numberString'\")\n }\n }\n\n private enum class Radix {\n KILO {\n override fun toInt(): Int = 1000\n },\n KIBI {\n override fun toInt(): Int = 1024\n };\n\n abstract fun toInt(): Int\n }\n\n private enum class MemoryUnit(\n private val prefix: String,\n private val radix: Radix,\n private val power: Int\n ) {\n BYTES(\"\", Radix.KIBI, 0),\n\n KILOBYTES(\"kilo\", Radix.KILO, 1),\n MEGABYTES(\"mega\", Radix.KILO, 2),\n GIGABYTES(\"giga\", Radix.KILO, 3),\n TERABYTES(\"tera\", Radix.KILO, 4),\n PETABYTES(\"peta\", Radix.KILO, 5),\n EXABYTES(\"exa\", Radix.KILO, 6),\n ZETTABYTES(\"zetta\", Radix.KILO, 7),\n YOTTABYTES(\"yotta\", Radix.KILO, 8),\n\n KIBIBYTES(\"kibi\", Radix.KIBI, 1),\n MEBIBYTES(\"mebi\", Radix.KIBI, 2),\n GIBIBYTES(\"gibi\", Radix.KIBI, 3),\n TEBIBYTES(\"tebi\", Radix.KIBI, 4),\n PEBIBYTES(\"pebi\", Radix.KIBI, 5),\n EXBIBYTES(\"exbi\", Radix.KIBI, 6),\n ZEBIBYTES(\"zebi\", Radix.KIBI, 7),\n YOBIBYTES(\"yobi\", Radix.KIBI, 8);\n\n internal val bytes: BigInteger = BigInteger.valueOf(radix.toInt().toLong()).pow(power)\n\n companion object {\n\n private val unitsMap = mutableMapOf().apply {\n for (unit in MemoryUnit.values()) {\n put(unit.prefix + \"byte\", unit)\n put(unit.prefix + \"bytes\", unit)\n if (unit.prefix.isEmpty()) {\n put(\"b\", unit)\n put(\"B\", unit)\n put(\"\", unit) // no unit specified means bytes\n } else {\n val first = unit.prefix.substring(0, 1)\n val firstUpper = first.toUpperCase()\n when (unit.radix) {\n Radix.KILO -> {\n if (unit.power == 1) {\n put(first + \"B\", unit) // 512kB\n } else {\n put(firstUpper + \"B\", unit) // 512MB\n }\n }\n Radix.KIBI -> {\n put(first, unit) // 512m\n put(firstUpper, unit) // 512M\n put(firstUpper + \"i\", unit) // 512Mi\n put(firstUpper + \"iB\", unit) // 512MiB\n }\n }\n }\n }\n }\n\n internal fun parseUnit(unit: String): MemoryUnit? {\n return unitsMap[unit]\n }\n }\n }\n }\n}\n\n/**\n * Converts a string to [SizeInBytes].\n */\nfun String.toSizeInBytes(): SizeInBytes = SizeInBytes.parse(this)\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/Spec.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport com.fasterxml.jackson.databind.JavaType\nimport com.fasterxml.jackson.databind.type.TypeFactory\nimport kotlin.properties.PropertyDelegateProvider\nimport kotlin.properties.ReadOnlyProperty\nimport kotlin.reflect.KProperty\n\n/**\n * Config spec is specification for config.\n *\n * Config spec describes a group of items with common prefix, which can be loaded into config\n * together using [Config.addSpec].\n * Config spec also provides convenient API to specify item in it without hand-written object\n * declaration.\n *\n * @see Config\n */\ninterface Spec {\n /**\n * Common prefix for items in this config spec.\n *\n * An empty prefix means names of items in this config spec are unqualified.\n */\n val prefix: String\n\n /**\n * Qualify item name with prefix of this config spec.\n *\n * When prefix is empty, original item name will be returned.\n *\n * @param item the config item\n * @return qualified item name\n */\n fun qualify(item: Item<*>): String = (prefix.toPath() + item.path).name\n\n /**\n * Add the specified item into this config spec.\n *\n * @param item the specified item\n */\n fun addItem(item: Item<*>)\n\n /**\n * Set of specified items in this config spec.\n */\n val items: Set>\n\n /**\n * Add the specified inner spec into this config spec.\n *\n * @param spec the specified spec\n */\n fun addInnerSpec(spec: Spec)\n\n /**\n * Set of inner specs in this config spec.\n */\n val innerSpecs: Set\n\n /**\n * Returns a config spec overlapped by the specified facade config spec.\n *\n * New items will be added to the facade config spec.\n *\n * @param spec the facade config spec\n * @return a config spec overlapped by the specified facade config spec\n */\n operator fun plus(spec: Spec): Spec {\n return object : Spec by spec {\n override fun addItem(item: Item<*>) {\n if (item !in this@Spec.items) {\n spec.addItem(item)\n } else {\n throw RepeatedItemException(item.name)\n }\n }\n\n override val items: Set>\n get() = this@Spec.items + spec.items\n\n override fun qualify(item: Item<*>): String {\n return if (item in spec.items) {\n spec.qualify(item)\n } else {\n this@Spec.qualify(item)\n }\n }\n }\n }\n\n /**\n * Returns a config spec backing by the specified fallback config spec.\n *\n * New items will be added to the current config spec.\n *\n * @param spec the fallback config spec\n * @return a config spec backing by the specified fallback config spec\n */\n fun withFallback(spec: Spec): Spec = spec + this\n\n /**\n * Returns sub-spec in the specified path.\n *\n * @param path the specified path\n * @return sub-source with specified prefix\n */\n operator fun get(path: String): Spec = get(prefix.toPath(), path.toPath())\n\n private fun get(prefix: Path, path: Path): Spec {\n return if (path.isEmpty()) {\n this\n } else if (prefix.size >= path.size && prefix.subList(0, path.size) == path) {\n ConfigSpec(prefix.subList(path.size, prefix.size).name, items, innerSpecs)\n } else {\n if (prefix.size < path.size && path.subList(0, prefix.size) == prefix) {\n val pathForInnerSpec = path.subList(prefix.size, path.size).name\n val filteredInnerSpecs = innerSpecs.mapNotNull { spec ->\n try {\n spec[pathForInnerSpec]\n } catch (_: NoSuchPathException) {\n null\n }\n }\n if (filteredInnerSpecs.isEmpty()) {\n throw NoSuchPathException(path.name)\n } else if (filteredInnerSpecs.size == 1) {\n return filteredInnerSpecs[0]\n } else {\n ConfigSpec(\"\", emptySet(), filteredInnerSpecs.toMutableSet())\n }\n } else {\n throw NoSuchPathException(path.name)\n }\n }\n }\n\n /**\n * Returns config spec with the specified additional prefix.\n *\n * @param prefix additional prefix\n * @return config spec with the specified additional prefix\n */\n fun withPrefix(prefix: String): Spec = withPrefix(this.prefix.toPath(), prefix.toPath())\n\n private fun withPrefix(prefix: Path, newPrefix: Path): Spec {\n return if (newPrefix.isEmpty()) {\n this\n } else {\n ConfigSpec((newPrefix + prefix).name, items, innerSpecs)\n }\n }\n\n companion object {\n /**\n * A dummy implementation for [Spec].\n *\n * It will swallow all items added to it. Used for items belonged to no config spec.\n */\n val dummy: Spec = object : Spec {\n override val prefix: String = \"\"\n\n override fun addItem(item: Item<*>) {}\n\n override val items: Set> = emptySet()\n\n override fun addInnerSpec(spec: Spec) {}\n\n override val innerSpecs: Set = emptySet()\n }\n }\n}\n\n/**\n * Specify a required item in this config spec.\n *\n * @param name item name without prefix\n * @param description description for this item\n * @return a property of a required item with prefix of this config spec\n */\ninline fun Spec.required(name: String? = null, description: String = \"\") =\n object : RequiredProperty(this, name, description, null is T) {}\n\nopen class RequiredProperty(\n private val spec: Spec,\n private val name: String? = null,\n private val description: String = \"\",\n private val nullable: Boolean = false\n) : PropertyDelegateProvider>> {\n override operator fun provideDelegate(thisRef: Any?, property: KProperty<*>):\n ReadOnlyProperty> {\n val type: JavaType = TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(RequiredProperty::class.java).bindings.typeParameters[0]\n val item = object : RequiredItem(\n spec,\n name\n ?: property.name,\n description,\n type,\n nullable\n ) {}\n return ReadOnlyProperty> { _, _ -> item }\n }\n}\n\n/**\n * Specify an optional item in this config spec.\n *\n * @param default default value returned before associating this item with specified value\n * @param name item name without prefix\n * @param description description for this item\n *\n * @return a property of an optional item with prefix of this config spec\n */\ninline fun Spec.optional(default: T, name: String? = null, description: String = \"\") =\n object : OptionalProperty(this, default, name, description, null is T) {}\n\nopen class OptionalProperty(\n private val spec: Spec,\n private val default: T,\n private val name: String? = null,\n private val description: String = \"\",\n private val nullable: Boolean = false\n) : PropertyDelegateProvider>> {\n override operator fun provideDelegate(thisRef: Any?, property: KProperty<*>):\n ReadOnlyProperty> {\n val type: JavaType = TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(OptionalProperty::class.java).bindings.typeParameters[0]\n val item = object : OptionalItem(\n spec,\n name\n ?: property.name,\n default,\n description,\n type,\n nullable\n ) {}\n return ReadOnlyProperty> { _, _ -> item }\n }\n}\n\n/**\n * Specify a lazy item in this config spec.\n *\n * @param name item name without prefix\n * @param description description for this item\n * @param thunk thunk used to evaluate value for this item\n * @return a property of a lazy item with prefix of this config spec\n */\ninline fun Spec.lazy(\n name: String? = null,\n description: String = \"\",\n noinline thunk: (config: ItemContainer) -> T\n) =\n object : LazyProperty(this, thunk, name, description, null is T) {}\n\nopen class LazyProperty(\n private val spec: Spec,\n private val thunk: (config: ItemContainer) -> T,\n private val name: String? = null,\n private val description: String = \"\",\n private val nullable: Boolean = false\n) : PropertyDelegateProvider>> {\n override operator fun provideDelegate(thisRef: Any?, property: KProperty<*>):\n ReadOnlyProperty> {\n val type: JavaType = TypeFactory.defaultInstance().constructType(this::class.java)\n .findSuperType(LazyProperty::class.java).bindings.typeParameters[0]\n val item = object : LazyItem(\n spec,\n name\n ?: property.name,\n thunk,\n description,\n type,\n nullable\n ) {}\n return ReadOnlyProperty> { _, _ -> item }\n }\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/TreeNode.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport java.util.Collections\n\n/**\n * Tree node that represents internal structure of config/source.\n */\ninterface TreeNode {\n /**\n * Children nodes in this tree node with their names as keys.\n */\n val children: MutableMap\n\n /**\n * Associate path with specified node.\n *\n * @param path path\n * @param node associated node\n */\n operator fun set(path: Path, node: TreeNode) {\n if (path.isEmpty()) {\n throw PathConflictException(path.name)\n }\n val key = path.first()\n if (this is LeafNode) {\n throw PathConflictException(path.name)\n }\n try {\n return if (path.size == 1) {\n children[key] = node\n } else {\n val rest = path.drop(1)\n var child = children[key]\n if (child == null) {\n child = ContainerNode(mutableMapOf())\n children[key] = child\n }\n child[rest] = node\n }\n } catch (_: PathConflictException) {\n throw PathConflictException(path.name)\n } finally {\n if (this is MapNode && isPlaceHolder) {\n isPlaceHolder = false\n }\n }\n }\n\n /**\n * Associate path with specified node.\n *\n * @param path path\n * @param node associated node\n */\n operator fun set(path: String, node: TreeNode) {\n set(path.toPath(), node)\n }\n\n /**\n * Whether this tree node contains node(s) in specified path or not.\n *\n * @param path item path\n * @return `true` if this tree node contains node(s) in specified path, `false` otherwise\n */\n operator fun contains(path: Path): Boolean {\n return if (path.isEmpty()) {\n true\n } else {\n val key = path.first()\n val rest = path.drop(1)\n val result = children[key]\n if (result != null) {\n return rest in result\n } else {\n return false\n }\n }\n }\n\n /**\n * Returns tree node in specified path if this tree node contains value(s) in specified path,\n * `null` otherwise.\n *\n * @param path item path\n * @return tree node in specified path if this tree node contains value(s) in specified path,\n * `null` otherwise\n */\n fun getOrNull(path: Path): TreeNode? {\n return if (path.isEmpty()) {\n this\n } else {\n val key = path.first()\n val rest = path.drop(1)\n val result = children[key]\n result?.getOrNull(rest)\n }\n }\n\n /**\n * Returns tree node in specified path if this tree node contains value(s) in specified path,\n * `null` otherwise.\n *\n * @param path item path\n * @return tree node in specified path if this tree node contains value(s) in specified path,\n * `null` otherwise\n */\n fun getOrNull(path: String): TreeNode? = getOrNull(path.toPath())\n\n /**\n * Returns a node backing by specified fallback node.\n *\n * @param fallback fallback node\n * @return a node backing by specified fallback node\n */\n fun withFallback(fallback: TreeNode): TreeNode {\n fun traverseTree(facade: TreeNode, fallback: TreeNode, path: Path): TreeNode {\n if (facade is LeafNode || fallback is LeafNode) {\n return facade\n } else {\n return ContainerNode(\n facade.children.toMutableMap().also { map ->\n for ((key, child) in fallback.children) {\n if (key in facade.children) {\n map[key] = traverseTree(facade.children.getValue(key), child, path + key)\n } else {\n map[key] = child\n }\n }\n }\n )\n }\n }\n return traverseTree(this, fallback, \"\".toPath())\n }\n\n /**\n * Returns a node overlapped by the specified facade node.\n *\n * @param facade the facade node\n * @return a node overlapped by the specified facade node\n */\n operator fun plus(facade: TreeNode): TreeNode = facade.withFallback(this)\n\n /**\n * Returns a tree node containing all nodes of the original tree node\n * except the nodes contained in the given [other] tree node.\n *\n * @return a tree node\n */\n operator fun minus(other: TreeNode): TreeNode {\n fun traverseTree(left: TreeNode, right: TreeNode): TreeNode {\n if (left is LeafNode) {\n return EmptyNode\n } else {\n if (right is LeafNode) {\n return EmptyNode\n } else {\n val leftKeys = left.children.keys\n val rightKeys = right.children.keys\n val diffKeys = leftKeys - rightKeys\n val sharedKeys = leftKeys.intersect(rightKeys)\n val children = mutableMapOf()\n diffKeys.forEach { key ->\n children[key] = left.children[key]!!\n }\n sharedKeys.forEach { key ->\n val child = traverseTree(left.children[key]!!, right.children[key]!!)\n if (child != EmptyNode) {\n children[key] = child\n }\n }\n return if (children.isEmpty()) {\n EmptyNode\n } else {\n ContainerNode(children)\n }\n }\n }\n }\n return traverseTree(this, other)\n }\n\n /**\n * List of all paths in this tree node.\n */\n val paths: List\n get() {\n return mutableListOf().also { list ->\n fun traverseTree(node: TreeNode, path: Path) {\n if (node is LeafNode) {\n list.add(path.name)\n } else {\n node.children.forEach { (key, child) ->\n traverseTree(child, path + key)\n }\n }\n }\n traverseTree(this, \"\".toPath())\n }\n }\n\n fun firstPath(predicate: (TreeNode) -> Boolean): Path? {\n fun traverseTree(node: TreeNode, path: Path): Path? {\n if (predicate(node)) {\n return path\n } else {\n node.children.forEach { (key, child) ->\n val matchPath = traverseTree(child, path + key)\n if (matchPath != null) {\n return matchPath\n }\n }\n return null\n }\n }\n return traverseTree(this, \"\".toPath())\n }\n\n /**\n * Map of all leaves indexed by paths in this tree node.\n */\n val leafByPath: Map\n get() {\n return mutableMapOf().also { map ->\n fun traverseTree(node: TreeNode, path: Path) {\n if (node is LeafNode) {\n map[path.name] = node\n } else {\n node.children.forEach { (key, child) ->\n traverseTree(child, path + key)\n }\n }\n }\n traverseTree(this, \"\".toPath())\n }\n }\n\n fun withoutPlaceHolder(): TreeNode {\n when (this) {\n is NullNode -> return this\n is ValueNode -> return this\n is ListNode -> return this\n is MapNode -> {\n val newChildren = children.mapValues { (_, child) ->\n child.withoutPlaceHolder()\n }\n if (newChildren.isNotEmpty() && newChildren.all { (_, child) -> child is MapNode && child.isPlaceHolder }) {\n return ContainerNode.placeHolder()\n } else {\n return withMap(newChildren.filterValues { !(it is MapNode && it.isPlaceHolder) })\n }\n }\n else -> return this\n }\n }\n\n fun isEmpty(): Boolean {\n when (this) {\n is EmptyNode -> return true\n is MapNode -> {\n return children.isEmpty() || children.all { (_, child) -> child.isEmpty() }\n }\n else -> return false\n }\n }\n\n fun isPlaceHolderNode(): Boolean {\n when (this) {\n is MapNode -> {\n if (isPlaceHolder) {\n return true\n } else {\n return children.isNotEmpty() && children.all { (_, child) -> child.isPlaceHolderNode() }\n }\n }\n else -> return false\n }\n }\n}\n\ninterface LeafNode : TreeNode\n\ninterface MapNode : TreeNode {\n fun withMap(map: Map): MapNode = throw NotImplementedError()\n var isPlaceHolder: Boolean\n}\n\nval emptyMutableMap: MutableMap = Collections.unmodifiableMap(mutableMapOf())\n\ninterface ValueNode : LeafNode {\n val value: Any\n override val children: MutableMap\n get() = emptyMutableMap\n}\n\ninterface NullNode : LeafNode\n\ninterface ListNode : LeafNode {\n val list: List\n fun withList(list: List): ListNode = throw NotImplementedError()\n}\n\n/**\n * Tree node that contains children nodes.\n */\nopen class ContainerNode(\n override val children: MutableMap,\n override var isPlaceHolder: Boolean = false\n) : MapNode {\n override fun withMap(map: Map): MapNode {\n val isPlaceHolder = map.isEmpty() && this.isPlaceHolder\n if (map is MutableMap) {\n return ContainerNode(map, isPlaceHolder)\n } else {\n return ContainerNode(map.toMutableMap(), isPlaceHolder)\n }\n }\n\n companion object {\n fun empty(): ContainerNode = ContainerNode(mutableMapOf())\n fun placeHolder(): ContainerNode = ContainerNode(mutableMapOf(), true)\n }\n}\n\n/**\n * Tree node that represents a empty tree.\n */\nobject EmptyNode : LeafNode {\n override val children: MutableMap = emptyMutableMap\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/Utils.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf\n\nimport java.io.File\n\n/**\n * Throws [UnsupportedOperationException].\n *\n * @throws UnsupportedOperationException\n */\n@Suppress(\"NOTHING_TO_INLINE\")\ninline fun unsupported(): Nothing {\n throw UnsupportedOperationException()\n}\n\ninternal fun getUnits(s: String): String {\n var i = s.length - 1\n while (i >= 0) {\n val c = s[i]\n if (!c.isLetter())\n break\n i -= 1\n }\n return s.substring(i + 1)\n}\n\n/**\n * Returns default value if string is empty, original string otherwise.\n */\nfun String.notEmptyOr(default: String): String = if (isEmpty()) default else this\n\nfun String.toLittleCase(): String {\n return if (this.all { it.isUpperCase() }) {\n this.toLowerCase()\n } else {\n when (val firstLowerCaseIndex = this.indexOfFirst { it.isLowerCase() }) {\n -1, 0 -> this\n 1 -> this[0].toLowerCase() + this.drop(1)\n else ->\n this.substring(0, firstLowerCaseIndex - 1).toLowerCase() +\n this.substring(firstLowerCaseIndex - 1)\n }\n }\n}\n\n/**\n * Modified implementation from [org.apache.commons.text.CaseUtils.toCamelCase].\n */\nfun String.toCamelCase(): String {\n if (isEmpty()) {\n return this\n }\n val strLen = this.length\n val newCodePoints = IntArray(strLen)\n var outOffset = 0\n val delimiterSet = setOf(\" \".codePointAt(0), \"_\".codePointAt(0))\n var capitalizeNext = Character.isUpperCase(this.codePointAt(0))\n var lowercaseNext = false\n var previousIsUppercase = false\n var index = 0\n while (index < strLen) {\n val codePoint: Int = this.codePointAt(index)\n when {\n delimiterSet.contains(codePoint) -> {\n capitalizeNext = outOffset != 0\n lowercaseNext = false\n previousIsUppercase = false\n index += Character.charCount(codePoint)\n }\n capitalizeNext -> {\n val upperCaseCodePoint = Character.toUpperCase(codePoint)\n newCodePoints[outOffset++] = upperCaseCodePoint\n index += Character.charCount(upperCaseCodePoint)\n capitalizeNext = false\n lowercaseNext = true\n }\n lowercaseNext -> {\n val lowerCaseCodePoint = Character.toLowerCase(codePoint)\n newCodePoints[outOffset++] = lowerCaseCodePoint\n index += Character.charCount(lowerCaseCodePoint)\n if (Character.isLowerCase(codePoint)) {\n lowercaseNext = false\n if (previousIsUppercase) {\n previousIsUppercase = false\n val previousCodePoint = newCodePoints[outOffset - 2]\n val upperCaseCodePoint = Character.toUpperCase(previousCodePoint)\n newCodePoints[outOffset - 2] = upperCaseCodePoint\n }\n } else {\n previousIsUppercase = true\n }\n }\n else -> {\n newCodePoints[outOffset++] = codePoint\n index += Character.charCount(codePoint)\n }\n }\n }\n return if (outOffset != 0) {\n String(newCodePoints, 0, outOffset)\n } else this\n}\n\nfun String.toLittleCamelCase(): String {\n return this.toCamelCase().toLittleCase()\n}\n\nfun tempDirectory(\n prefix: String = \"tmp\",\n suffix: String? = null,\n directory: File? = null\n): File {\n return createTempDir(prefix, suffix, directory)\n}\n\nfun tempFile(prefix: String = \"tmp\", suffix: String? = null, directory: File? = null): File {\n return createTempFile(prefix, suffix, directory)\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/annotation/Annotations.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.annotation\n\n/**\n * Indicates that this API is specially designed to be used in Java.\n */\n@Target(\n AnnotationTarget.FUNCTION,\n AnnotationTarget.CONSTRUCTOR,\n AnnotationTarget.PROPERTY_GETTER,\n AnnotationTarget.PROPERTY_SETTER,\n AnnotationTarget.CLASS\n)\n@Retention(AnnotationRetention.SOURCE)\nannotation class JavaApi\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/source/DefaultLoaders.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.Feature\nimport com.uchuhimo.konf.source.base.FlatSource\nimport com.uchuhimo.konf.source.base.KVSource\nimport com.uchuhimo.konf.source.base.MapSource\nimport com.uchuhimo.konf.source.env.EnvProvider\nimport com.uchuhimo.konf.source.json.JsonProvider\nimport com.uchuhimo.konf.source.properties.PropertiesProvider\nimport kotlinx.coroutines.Dispatchers\nimport java.io.File\nimport java.net.URL\nimport java.util.concurrent.TimeUnit\nimport kotlin.coroutines.CoroutineContext\n\n/**\n * Default loaders for config.\n *\n * If [transform] is provided, source will be applied the given [transform] function when loaded.\n *\n * @param config parent config for loader\n * @param transform the given transformation function\n */\nclass DefaultLoaders(\n /**\n * Parent config for loader.\n */\n val config: Config,\n /**\n * The given transformation function.\n */\n private val transform: ((Source) -> Source)? = null\n) {\n val optional = config.isEnabled(Feature.OPTIONAL_SOURCE_BY_DEFAULT)\n fun Provider.orMapped(): Provider =\n if (transform != null) this.map(transform) else this\n\n fun Source.orMapped(): Source = transform?.invoke(this) ?: this\n\n /**\n * Returns default loaders applied the given [transform] function.\n *\n * @param transform the given transformation function\n * @return the default loaders applied the given [transform] function\n */\n fun mapped(transform: (Source) -> Source): DefaultLoaders = DefaultLoaders(config) {\n transform(it.orMapped())\n }\n\n /**\n * Returns default loaders where sources have specified additional prefix.\n *\n * @param prefix additional prefix\n * @return the default loaders where sources have specified additional prefix\n */\n fun prefixed(prefix: String): DefaultLoaders = mapped { it.withPrefix(prefix) }\n\n /**\n * Returns default loaders where sources are scoped in specified path.\n *\n * @param path path that is the scope of sources\n * @return the default loaders where sources are scoped in specified path\n */\n fun scoped(path: String): DefaultLoaders = mapped { it[path] }\n\n fun enabled(feature: Feature): DefaultLoaders = mapped { it.enabled(feature) }\n\n fun disabled(feature: Feature): DefaultLoaders = mapped { it.disabled(feature) }\n\n /**\n * Loader for JSON source.\n */\n @JvmField\n val json = Loader(config, JsonProvider.orMapped())\n\n /**\n * Loader for properties source.\n */\n @JvmField\n val properties = Loader(config, PropertiesProvider.orMapped())\n\n /**\n * Loader for map source.\n */\n @JvmField\n val map = MapLoader(config, transform)\n\n /**\n * Loader for a source from the specified provider.\n *\n * @param provider the specified provider\n * @return a loader for a source from the specified provider\n */\n fun source(provider: Provider) = Loader(config, provider.orMapped())\n\n /**\n * Returns a child config containing values from system environment.\n *\n * @param nested whether to treat \"AA_BB_CC\" as nested format \"AA.BB.CC\" or not. True by default.\n * @return a child config containing values from system environment\n */\n @JvmOverloads\n fun env(nested: Boolean = true): Config = config.withSource(EnvProvider.env(nested).orMapped())\n\n @JvmOverloads\n fun envMap(map: Map, nested: Boolean = true): Config = config.withSource(EnvProvider.envMap(map, nested).orMapped())\n\n /**\n * Returns a child config containing values from system properties.\n *\n * @return a child config containing values from system properties\n */\n fun systemProperties(): Config = config.withSource(PropertiesProvider.system().orMapped())\n\n /**\n * Returns corresponding loader based on extension.\n *\n * @param extension the file extension\n * @param source the source description for error message\n * @return the corresponding loader based on extension\n */\n fun dispatchExtension(extension: String, source: String = \"\"): Loader =\n Loader(\n config,\n Provider.of(extension)?.orMapped()\n ?: throw UnsupportedExtensionException(source)\n )\n\n /**\n * Returns a child config containing values from specified file.\n *\n * Format of the file is auto-detected from the file extension.\n * Supported file formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the file extension is unsupported.\n *\n * @param file specified file\n * @param optional whether the source is optional\n * @return a child config containing values from specified file\n * @throws UnsupportedExtensionException\n */\n fun file(file: File, optional: Boolean = this.optional): Config = dispatchExtension(file.extension, file.name).file(file, optional)\n\n /**\n * Returns a child config containing values from specified file path.\n *\n * Format of the file is auto-detected from the file extension.\n * Supported file formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the file extension is unsupported.\n *\n * @param file specified file path\n * @param optional whether the source is optional\n * @return a child config containing values from specified file path\n * @throws UnsupportedExtensionException\n */\n fun file(file: String, optional: Boolean = this.optional): Config = file(File(file), optional)\n\n /**\n * Returns a child config containing values from specified file,\n * and reloads values when file content has been changed.\n *\n * Format of the file is auto-detected from the file extension.\n * Supported file formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the file extension is unsupported.\n *\n * @param file specified file\n * @param delayTime delay to observe between every check. The default value is 5.\n * @param unit time unit of delay. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated file is loaded\n * @return a child config containing values from watched file\n * @throws UnsupportedExtensionException\n */\n fun watchFile(\n file: File,\n delayTime: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config = dispatchExtension(file.extension, file.name)\n .watchFile(file, delayTime, unit, context, optional, onLoad)\n\n /**\n * Returns a child config containing values from specified file path,\n * and reloads values when file content has been changed.\n *\n * Format of the file is auto-detected from the file extension.\n * Supported file formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the file extension is unsupported.\n *\n * @param file specified file path\n * @param delayTime delay to observe between every check. The default value is 5.\n * @param unit time unit of delay. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated file is loaded\n * @return a child config containing values from watched file\n * @throws UnsupportedExtensionException\n */\n fun watchFile(\n file: String,\n delayTime: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config = watchFile(File(file), delayTime, unit, context, optional, onLoad)\n\n /**\n * Returns a child config containing values from specified url.\n *\n * Format of the url is auto-detected from the url extension.\n * Supported url formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the url extension is unsupported.\n *\n * @param url specified url\n * @param optional whether the source is optional\n * @return a child config containing values from specified url\n * @throws UnsupportedExtensionException\n */\n fun url(url: URL, optional: Boolean = this.optional): Config = dispatchExtension(File(url.path).extension, url.toString()).url(url, optional)\n\n /**\n * Returns a child config containing values from specified url string.\n *\n * Format of the url is auto-detected from the url extension.\n * Supported url formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the url extension is unsupported.\n *\n * @param url specified url string\n * @param optional whether the source is optional\n * @return a child config containing values from specified url string\n * @throws UnsupportedExtensionException\n */\n fun url(url: String, optional: Boolean = this.optional): Config = url(URL(url), optional)\n\n /**\n * Returns a child config containing values from specified url,\n * and reloads values periodically.\n *\n * Format of the url is auto-detected from the url extension.\n * Supported url formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the url extension is unsupported.\n *\n * @param url specified url\n * @param period reload period. The default value is 5.\n * @param unit time unit of delay. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated URL is loaded\n * @return a child config containing values from specified url\n * @throws UnsupportedExtensionException\n */\n fun watchUrl(\n url: URL,\n period: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config = dispatchExtension(File(url.path).extension, url.toString())\n .watchUrl(url, period, unit, context, optional, onLoad)\n\n /**\n * Returns a child config containing values from specified url string,\n * and reloads values periodically.\n *\n * Format of the url is auto-detected from the url extension.\n * Supported url formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the url extension is unsupported.\n *\n * @param url specified url string\n * @param period reload period. The default value is 5.\n * @param unit time unit of delay. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated URL is loaded\n * @return a child config containing values from specified url string\n * @throws UnsupportedExtensionException\n */\n fun watchUrl(\n url: String,\n period: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config = watchUrl(URL(url), period, unit, context, optional, onLoad)\n}\n\n/**\n * Loader to load source from map of variant formats.\n *\n * If [transform] is provided, source will be applied the given [transform] function when loaded.\n *\n * @param config parent config\n */\nclass MapLoader(\n /**\n * Parent config for all child configs loading source in this loader.\n */\n val config: Config,\n /**\n * The given transformation function.\n */\n private val transform: ((Source) -> Source)? = null\n) {\n fun Source.orMapped(): Source = transform?.invoke(this) ?: this\n\n /**\n * Returns a child config containing values from specified hierarchical map.\n *\n * @param map a hierarchical map\n * @return a child config containing values from specified hierarchical map\n */\n fun hierarchical(map: Map): Config = config.withSource(MapSource(map).orMapped())\n\n /**\n * Returns a child config containing values from specified map in key-value format.\n *\n * @param map a map in key-value format\n * @return a child config containing values from specified map in key-value format\n */\n fun kv(map: Map): Config = config.withSource(KVSource(map).orMapped())\n\n /**\n * Returns a child config containing values from specified map in flat format.\n *\n * @param map a map in flat format\n * @return a child config containing values from specified map in flat format\n */\n fun flat(map: Map): Config = config.withSource(FlatSource(map).orMapped())\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/source/DefaultProviders.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.uchuhimo.konf.source.base.FlatSource\nimport com.uchuhimo.konf.source.base.KVSource\nimport com.uchuhimo.konf.source.base.MapSource\nimport com.uchuhimo.konf.source.env.EnvProvider\nimport com.uchuhimo.konf.source.json.JsonProvider\nimport com.uchuhimo.konf.source.properties.PropertiesProvider\nimport java.io.File\nimport java.net.URL\n\n/**\n * Default providers.\n */\nobject DefaultProviders {\n /**\n * Provider for JSON source.\n */\n @JvmField\n val json = JsonProvider\n\n /**\n * Provider for properties source.\n */\n @JvmField\n val properties = PropertiesProvider\n\n /**\n * Provider for map source.\n */\n @JvmField\n val map = DefaultMapProviders\n\n /**\n * Returns a source from system environment.\n *\n * @param nested whether to treat \"AA_BB_CC\" as nested format \"AA.BB.CC\" or not. True by default.\n * @return a source from system environment\n */\n @JvmOverloads\n fun env(nested: Boolean = true): Source = EnvProvider.env(nested)\n\n /**\n * Returns a source from system properties.\n *\n * @return a source from system properties\n */\n fun systemProperties(): Source = PropertiesProvider.system()\n\n /**\n * Returns corresponding provider based on extension.\n *\n * @param extension the file extension\n * @param source the source description for error message\n * @return the corresponding provider based on extension\n */\n fun dispatchExtension(extension: String, source: String = \"\"): Provider =\n Provider.of(extension) ?: throw UnsupportedExtensionException(source)\n\n /**\n * Returns a source from specified file.\n *\n * Format of the file is auto-detected from the file extension.\n * Supported file formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the file extension is unsupported.\n *\n * @param file specified file\n * @param optional whether the source is optional\n * @return a source from specified file\n * @throws UnsupportedExtensionException\n */\n fun file(file: File, optional: Boolean = false): Source = dispatchExtension(file.extension, file.name).file(file, optional)\n\n /**\n * Returns a source from specified file path.\n *\n * Format of the file is auto-detected from the file extension.\n * Supported file formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the file extension is unsupported.\n *\n * @param file specified file path\n * @param optional whether the source is optional\n * @return a source from specified file path\n * @throws UnsupportedExtensionException\n */\n fun file(file: String, optional: Boolean = false): Source = file(File(file), optional)\n\n /**\n * Returns a source from specified url.\n *\n * Format of the url is auto-detected from the url extension.\n * Supported url formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the url extension is unsupported.\n *\n * @param url specified url\n * @param optional whether the source is optional\n * @return a source from specified url\n * @throws UnsupportedExtensionException\n */\n fun url(url: URL, optional: Boolean = false): Source =\n dispatchExtension(File(url.path).extension, url.toString()).url(url, optional)\n\n /**\n * Returns a source from specified url string.\n *\n * Format of the url is auto-detected from the url extension.\n * Supported url formats and the corresponding extensions:\n * - HOCON: conf\n * - JSON: json\n * - Properties: properties\n * - TOML: toml\n * - XML: xml\n * - YAML: yml, yaml\n *\n * Throws [UnsupportedExtensionException] if the url extension is unsupported.\n *\n * @param url specified url string\n * @param optional whether the source is optional\n * @return a source from specified url string\n * @throws UnsupportedExtensionException\n */\n fun url(url: String, optional: Boolean = false): Source = url(URL(url), optional)\n}\n\n/**\n * Providers for map of variant formats.\n */\nobject DefaultMapProviders {\n /**\n * Returns a source from specified hierarchical map.\n *\n * @param map a hierarchical map\n * @return a source from specified hierarchical map\n */\n fun hierarchical(map: Map): Source = MapSource(map)\n\n /**\n * Returns a source from specified map in key-value format.\n *\n * @param map a map in key-value format\n * @return a source from specified map in key-value format\n */\n fun kv(map: Map): Source = KVSource(map)\n\n /**\n * Returns a source from specified map in flat format.\n *\n * @param map a map in flat format\n * @return a source from specified map in flat format\n */\n fun flat(map: Map): Source = FlatSource(map)\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/source/Loader.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.Feature\nimport kotlinx.coroutines.Dispatchers\nimport kotlinx.coroutines.GlobalScope\nimport kotlinx.coroutines.delay\nimport kotlinx.coroutines.launch\nimport java.io.File\nimport java.io.InputStream\nimport java.io.Reader\nimport java.net.URL\nimport java.nio.file.FileSystems\nimport java.nio.file.Path\nimport java.nio.file.StandardWatchEventKinds\nimport java.nio.file.WatchEvent\nimport java.security.DigestInputStream\nimport java.security.MessageDigest\nimport java.util.concurrent.TimeUnit\nimport kotlin.coroutines.CoroutineContext\n\n/**\n * Loader to load source from various input formats.\n *\n * @param config parent config\n */\nclass Loader(\n /**\n * Parent config for all child configs loading source in this loader.\n */\n val config: Config,\n /**\n * Source provider to provide source from various input format.\n */\n val provider: Provider\n) {\n val optional = config.isEnabled(Feature.OPTIONAL_SOURCE_BY_DEFAULT)\n\n /**\n * Returns a child config containing values from specified reader.\n *\n * @param reader specified reader for reading character streams\n * @return a child config containing values from specified reader\n */\n fun reader(reader: Reader): Config =\n config.withSource(provider.reader(reader))\n\n /**\n * Returns a child config containing values from specified input stream.\n *\n * @param inputStream specified input stream of bytes\n * @return a child config containing values from specified input stream\n */\n fun inputStream(inputStream: InputStream): Config =\n config.withSource(provider.inputStream(inputStream))\n\n /**\n * Returns a child config containing values from specified file.\n *\n * @param file specified file\n * @param optional whether the source is optional\n * @return a child config containing values from specified file\n */\n fun file(file: File, optional: Boolean = this.optional): Config =\n config.withSource(provider.file(file, optional))\n\n /**\n * Returns a child config containing values from specified file path.\n *\n * @param file specified file path\n * @param optional whether the source is optional\n * @return a child config containing values from specified file path\n */\n fun file(file: String, optional: Boolean = this.optional): Config =\n config.withSource(provider.file(file, optional))\n\n private val File.digest: ByteArray\n get() {\n val messageDigest = MessageDigest.getInstance(\"MD5\")\n DigestInputStream(inputStream().buffered(), messageDigest).use { it.readBytes() }\n return messageDigest.digest()\n }\n\n /**\n * Returns a child config containing values from specified file,\n * and reloads values when file content has been changed.\n *\n * @param file specified file\n * @param delayTime delay to observe between every check. The default value is 5.\n * @param unit time unit of delay. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated file is loaded\n * @return a child config containing values from watched file\n */\n fun watchFile(\n file: File,\n delayTime: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config {\n val absoluteFile = file.absoluteFile\n return provider.file(absoluteFile, optional).let { source ->\n config.withLoadTrigger(\"watch ${source.description}\") { newConfig, load ->\n newConfig.lock {\n load(source)\n }\n onLoad?.invoke(newConfig, source)\n val path = absoluteFile.toPath().parent\n val isMac = \"mac\" in System.getProperty(\"os.name\").toLowerCase()\n val watcher = FileSystems.getDefault().newWatchService()\n path.register(\n watcher,\n StandardWatchEventKinds.ENTRY_MODIFY,\n StandardWatchEventKinds.ENTRY_CREATE\n )\n var digest = absoluteFile.digest\n GlobalScope.launch(context) {\n while (true) {\n delay(unit.toMillis(delayTime))\n if (isMac) {\n val newDigest = absoluteFile.digest\n if (!newDigest.contentEquals(digest)) {\n digest = newDigest\n val newSource = provider.file(file, optional)\n newConfig.lock {\n newConfig.clear()\n load(newSource)\n }\n onLoad?.invoke(newConfig, newSource)\n }\n } else {\n val key = watcher.poll()\n if (key != null) {\n for (event in key.pollEvents()) {\n val kind = event.kind()\n @Suppress(\"UNCHECKED_CAST\")\n event as WatchEvent\n val filename = event.context()\n if (filename.toString() == absoluteFile.name) {\n if (kind == StandardWatchEventKinds.OVERFLOW) {\n continue\n } else if (kind == StandardWatchEventKinds.ENTRY_MODIFY ||\n kind == StandardWatchEventKinds.ENTRY_CREATE\n ) {\n val newSource = provider.file(file, optional)\n newConfig.lock {\n newConfig.clear()\n load(newSource)\n }\n onLoad?.invoke(newConfig, newSource)\n }\n }\n val valid = key.reset()\n if (!valid) {\n watcher.close()\n throw InvalidWatchKeyException(source)\n }\n }\n }\n }\n }\n }\n }.withLayer()\n }\n }\n\n /**\n * Returns a child config containing values from specified file path,\n * and reloads values when file content has been changed.\n *\n * @param file specified file path\n * @param delayTime delay to observe between every check. The default value is 5.\n * @param unit time unit of delay. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated file is loaded\n * @return a child config containing values from watched file\n */\n fun watchFile(\n file: String,\n delayTime: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config =\n watchFile(File(file), delayTime, unit, context, optional, onLoad)\n\n /**\n * Returns a child config containing values from specified string.\n *\n * @param content specified string\n * @return a child config containing values from specified string\n */\n fun string(content: String): Config =\n config.withSource(provider.string(content))\n\n /**\n * Returns a child config containing values from specified byte array.\n *\n * @param content specified byte array\n * @return a child config containing values from specified byte array\n */\n fun bytes(content: ByteArray): Config =\n config.withSource(provider.bytes(content))\n\n /**\n * Returns a child config containing values from specified portion of byte array.\n *\n * @param content specified byte array\n * @param offset the start offset of the portion of the array to read\n * @param length the length of the portion of the array to read\n * @return a child config containing values from specified portion of byte array\n */\n fun bytes(content: ByteArray, offset: Int, length: Int): Config =\n config.withSource(provider.bytes(content, offset, length))\n\n /**\n * Returns a child config containing values from specified url.\n *\n * @param url specified url\n * @param optional whether the source is optional\n * @return a child config containing values from specified url\n */\n fun url(url: URL, optional: Boolean = this.optional): Config =\n config.withSource(provider.url(url, optional))\n\n /**\n * Returns a child config containing values from specified url string.\n *\n * @param url specified url string\n * @param optional whether the source is optional\n * @return a child config containing values from specified url string\n */\n fun url(url: String, optional: Boolean = this.optional): Config =\n config.withSource(provider.url(url, optional))\n\n /**\n * Returns a child config containing values from specified url,\n * and reloads values periodically.\n *\n * @param url specified url\n * @param period reload period. The default value is 5.\n * @param unit time unit of reload period. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated URL is loaded\n * @return a child config containing values from specified url\n */\n fun watchUrl(\n url: URL,\n period: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config {\n return provider.url(url, optional).let { source ->\n config.withLoadTrigger(\"watch ${source.description}\") { newConfig, load ->\n newConfig.lock {\n load(source)\n }\n onLoad?.invoke(newConfig, source)\n GlobalScope.launch(context) {\n while (true) {\n delay(unit.toMillis(period))\n val newSource = provider.url(url, optional)\n newConfig.lock {\n newConfig.clear()\n load(newSource)\n }\n onLoad?.invoke(newConfig, newSource)\n }\n }\n }.withLayer()\n }\n }\n\n /**\n * Returns a child config containing values from specified url string,\n * and reloads values periodically.\n *\n * @param url specified url string\n * @param period reload period. The default value is 5.\n * @param unit time unit of reload period. The default value is [TimeUnit.SECONDS].\n * @param context context of the coroutine. The default value is [Dispatchers.Default].\n * @param optional whether the source is optional\n * @param onLoad function invoked after the updated URL is loaded\n * @return a child config containing values from specified url string\n */\n fun watchUrl(\n url: String,\n period: Long = 5,\n unit: TimeUnit = TimeUnit.SECONDS,\n context: CoroutineContext = Dispatchers.Default,\n optional: Boolean = this.optional,\n onLoad: ((config: Config, source: Source) -> Unit)? = null\n ): Config =\n watchUrl(URL(url), period, unit, context, optional, onLoad)\n\n /**\n * Returns a child config containing values from specified resource.\n *\n * @param resource path of specified resource\n * @param optional whether the source is optional\n * @return a child config containing values from specified resource\n */\n fun resource(resource: String, optional: Boolean = this.optional): Config =\n config.withSource(provider.resource(resource, optional))\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/source/MergedSource.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.uchuhimo.konf.Feature\nimport com.uchuhimo.konf.MergedMap\nimport com.uchuhimo.konf.Path\nimport com.uchuhimo.konf.TreeNode\nimport java.util.Collections\n\nclass MergedSource(val facade: Source, val fallback: Source) : Source {\n override val info: SourceInfo by lazy {\n SourceInfo(\n \"facade\" to facade.description,\n \"fallback\" to fallback.description\n )\n }\n\n override val tree: TreeNode by lazy { facade.tree.withFallback(fallback.tree) }\n\n override val features: Map by lazy {\n MergedMap(\n Collections.unmodifiableMap(fallback.features),\n Collections.unmodifiableMap(facade.features)\n )\n }\n\n override fun disabled(feature: Feature): Source = MergedSource(facade.disabled(feature), fallback)\n\n override fun enabled(feature: Feature): Source = MergedSource(facade.enabled(feature), fallback)\n\n override fun substituted(root: Source, enabled: Boolean, errorWhenUndefined: Boolean): Source {\n val substitutedFacade = facade.substituted(root, enabled, errorWhenUndefined)\n val substitutedFallback = fallback.substituted(root, enabled, errorWhenUndefined)\n if (substitutedFacade === facade && substitutedFallback === fallback) {\n return this\n } else {\n return MergedSource(substitutedFacade, substitutedFallback)\n }\n }\n\n override fun lowercased(enabled: Boolean): Source {\n val lowercasedFacade = facade.lowercased(enabled)\n val lowercasedFallback = fallback.lowercased(enabled)\n if (lowercasedFacade === facade && lowercasedFallback === fallback) {\n return this\n } else {\n return MergedSource(lowercasedFacade, lowercasedFallback)\n }\n }\n\n override fun littleCamelCased(enabled: Boolean): Source {\n val littleCamelCasedFacade = facade.littleCamelCased(enabled)\n val littleCamelCasedFallback = fallback.littleCamelCased(enabled)\n if (littleCamelCasedFacade === facade && littleCamelCasedFallback === fallback) {\n return this\n } else {\n return MergedSource(littleCamelCasedFacade, littleCamelCasedFallback)\n }\n }\n\n override fun normalized(lowercased: Boolean, littleCamelCased: Boolean): Source {\n val normalizedFacade = facade.normalized(lowercased, littleCamelCased)\n val normalizedFallback = fallback.normalized(lowercased, littleCamelCased)\n if (normalizedFacade === facade && normalizedFallback === fallback) {\n return this\n } else {\n return MergedSource(normalizedFacade, normalizedFallback)\n }\n }\n\n override fun getNodeOrNull(path: Path, lowercased: Boolean, littleCamelCased: Boolean): TreeNode? {\n val facadeNode = facade.getNodeOrNull(path, lowercased, littleCamelCased)\n val fallbackNode = fallback.getNodeOrNull(path, lowercased, littleCamelCased)\n return if (facadeNode != null) {\n if (fallbackNode != null) {\n facadeNode.withFallback(fallbackNode)\n } else {\n facadeNode\n }\n } else {\n fallbackNode\n }\n }\n\n override fun getOrNull(path: Path): Source? {\n return if (path.isEmpty()) {\n this\n } else {\n val subFacade = facade.getOrNull(path)\n val subFallback = fallback.getOrNull(path)\n if (subFacade != null) {\n if (subFallback != null) {\n MergedSource(subFacade, subFallback)\n } else {\n subFacade\n }\n } else {\n subFallback\n }\n }\n }\n\n override fun withPrefix(prefix: Path): Source {\n return if (prefix.isEmpty()) {\n this\n } else {\n MergedSource(facade.withPrefix(prefix), fallback.withPrefix(prefix))\n }\n }\n}\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/source/Provider.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.uchuhimo.konf.source.base.EmptyMapSource\nimport com.uchuhimo.konf.source.json.JsonProvider\nimport com.uchuhimo.konf.source.properties.PropertiesProvider\nimport org.reflections.ReflectionUtils\nimport org.reflections.Reflections\nimport org.reflections.scanners.SubTypesScanner\nimport org.reflections.scanners.TypeAnnotationsScanner\nimport java.io.File\nimport java.io.IOException\nimport java.io.InputStream\nimport java.io.Reader\nimport java.net.URL\nimport java.util.concurrent.ConcurrentHashMap\n\n/**\n * Provides source from various input format.\n */\ninterface Provider {\n /**\n * Returns a new source from specified reader.\n *\n * @param reader specified reader for reading character streams\n * @return a new source from specified reader\n */\n fun reader(reader: Reader): Source\n\n /**\n * Returns a new source from specified input stream.\n *\n * @param inputStream specified input stream of bytes\n * @return a new source from specified input stream\n */\n fun inputStream(inputStream: InputStream): Source\n\n /**\n * Returns a new source from specified file.\n *\n * @param file specified file\n * @param optional whether this source is optional\n * @return a new source from specified file\n */\n fun file(file: File, optional: Boolean = false): Source {\n val extendContext: Source.() -> Unit = {\n info[\"file\"] = file.toString()\n }\n if (!file.exists() && optional) {\n return EmptyMapSource().apply(extendContext)\n }\n return file.inputStream().buffered().use { inputStream ->\n inputStream(inputStream).apply(extendContext)\n }\n }\n\n /**\n * Returns a new source from specified file path.\n *\n * @param file specified file path\n * @param optional whether this source is optional\n * @return a new source from specified file path\n */\n fun file(file: String, optional: Boolean = false): Source = file(File(file), optional)\n\n /**\n * Returns a new source from specified string.\n *\n * @param content specified string\n * @return a new source from specified string\n */\n fun string(content: String): Source = reader(content.reader()).apply {\n info[\"content\"] = \"\\\"\\n$content\\n\\\"\"\n }\n\n /**\n * Returns a new source from specified byte array.\n *\n * @param content specified byte array\n * @return a new source from specified byte array\n */\n fun bytes(content: ByteArray): Source {\n return content.inputStream().use {\n inputStream(it)\n }\n }\n\n /**\n * Returns a new source from specified portion of byte array.\n *\n * @param content specified byte array\n * @param offset the start offset of the portion of the array to read\n * @param length the length of the portion of the array to read\n * @return a new source from specified portion of byte array\n */\n fun bytes(content: ByteArray, offset: Int, length: Int): Source {\n return content.inputStream(offset, length).use {\n inputStream(it)\n }\n }\n\n /**\n * Returns a new source from specified url.\n *\n * @param url specified url\n * @param optional whether this source is optional\n * @return a new source from specified url\n */\n fun url(url: URL, optional: Boolean = false): Source {\n // from com.fasterxml.jackson.core.JsonFactory._optimizedStreamFromURL in version 2.8.9\n val extendContext: Source.() -> Unit = {\n info[\"url\"] = url.toString()\n }\n if (url.protocol == \"file\") {\n val host = url.host\n if (host == null || host.isEmpty()) {\n val path = url.path\n if (path.indexOf('%') < 0) {\n val file = File(path)\n if (!file.exists() && optional) {\n return EmptyMapSource().apply(extendContext)\n }\n return file.inputStream().use {\n inputStream(it).apply(extendContext)\n }\n }\n }\n }\n return try {\n val stream = url.openStream()\n stream.use {\n inputStream(it).apply(extendContext)\n }\n } catch (ex: IOException) {\n if (optional) {\n EmptyMapSource().apply(extendContext)\n } else {\n throw ex\n }\n }\n }\n\n /**\n * Returns a new source from specified url string.\n *\n * @param url specified url string\n * @param optional whether this source is optional\n * @return a new source from specified url string\n */\n fun url(url: String, optional: Boolean = false): Source = url(URL(url), optional)\n\n /**\n * Returns a new source from specified resource.\n *\n * @param resource path of specified resource\n * @param optional whether this source is optional\n * @return a new source from specified resource\n */\n fun resource(resource: String, optional: Boolean = false): Source {\n val extendContext: Source.() -> Unit = {\n info[\"resource\"] = resource\n }\n val loader = Thread.currentThread().contextClassLoader\n val e = try {\n loader.getResources(resource)\n } catch (ex: IOException) {\n if (optional) {\n return EmptyMapSource().apply(extendContext)\n } else {\n throw ex\n }\n }\n if (!e.hasMoreElements()) {\n if (optional) {\n return EmptyMapSource().apply(extendContext)\n } else {\n throw SourceNotFoundException(\"resource not found on classpath: $resource\")\n }\n }\n val sources = mutableListOf()\n while (e.hasMoreElements()) {\n val url = e.nextElement()\n val source = url(url, optional)\n sources.add(source)\n }\n\n return sources.reduce(Source::withFallback).apply(extendContext)\n }\n\n /**\n * Returns a provider providing sources that applying the given [transform] function.\n *\n * @param transform the given transformation function\n * @return a provider providing sources that applying the given [transform] function\n */\n fun map(transform: (Source) -> Source): Provider {\n return object : Provider {\n override fun reader(reader: Reader): Source =\n this@Provider.reader(reader).let(transform)\n\n override fun inputStream(inputStream: InputStream): Source =\n this@Provider.inputStream(inputStream).let(transform)\n\n override fun file(file: File, optional: Boolean): Source =\n this@Provider.file(file, optional).let(transform)\n\n override fun file(file: String, optional: Boolean): Source =\n this@Provider.file(file, optional).let(transform)\n\n override fun string(content: String): Source =\n this@Provider.string(content).let(transform)\n\n override fun bytes(content: ByteArray): Source =\n this@Provider.bytes(content).let(transform)\n\n override fun bytes(content: ByteArray, offset: Int, length: Int): Source =\n this@Provider.bytes(content, offset, length).let(transform)\n\n override fun url(url: URL, optional: Boolean): Source =\n this@Provider.url(url, optional).let(transform)\n\n override fun url(url: String, optional: Boolean): Source =\n this@Provider.url(url, optional).let(transform)\n\n override fun resource(resource: String, optional: Boolean): Source =\n this@Provider.resource(resource, optional).let(transform)\n }\n }\n\n companion object {\n private val extensionToProvider = ConcurrentHashMap(\n mutableMapOf(\n \"json\" to JsonProvider,\n \"properties\" to PropertiesProvider\n )\n )\n\n init {\n val reflections = Reflections(\n \"com.uchuhimo.konf\",\n SubTypesScanner(),\n TypeAnnotationsScanner()\n )\n val providers = reflections.getSubTypesOf(Provider::class.java)\n .intersect(reflections.getTypesAnnotatedWith(RegisterExtension::class.java))\n for (provider in providers) {\n for (\n annotation in ReflectionUtils.getAnnotations(provider).filter {\n it.annotationClass == RegisterExtension::class\n }\n ) {\n for (extension in (annotation as RegisterExtension).value) {\n registerExtension(extension, provider.kotlin.objectInstance!! as Provider)\n }\n }\n }\n }\n\n /**\n * Register extension with the corresponding provider.\n *\n * @param extension the file extension\n * @param provider the corresponding provider\n */\n fun registerExtension(extension: String, provider: Provider) {\n extensionToProvider[extension] = provider\n }\n\n /**\n * Unregister the given extension.\n *\n * @param extension the file extension\n */\n fun unregisterExtension(extension: String): Provider? =\n extensionToProvider.remove(extension)\n\n /**\n * Returns corresponding provider based on extension.\n *\n * Returns null if the specific extension is unregistered.\n *\n * @param extension the file extension\n * @return the corresponding provider based on extension\n */\n fun of(extension: String): Provider? =\n extensionToProvider[extension]\n }\n}\n\n@Retention(AnnotationRetention.RUNTIME)\n@Target(AnnotationTarget.CLASS)\nannotation class RegisterExtension(val value: Array)\n"
},
{
"path": "konf-core/src/main/kotlin/com/uchuhimo/konf/source/Source.kt",
"content": "/*\n * Copyright 2017-2021 the original author or authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.uchuhimo.konf.source\n\nimport com.fasterxml.jackson.core.JsonProcessingException\nimport com.fasterxml.jackson.databind.JavaType\nimport com.fasterxml.jackson.databind.JsonNode\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport com.fasterxml.jackson.databind.node.ArrayNode\nimport com.fasterxml.jackson.databind.node.BigIntegerNode\nimport com.fasterxml.jackson.databind.node.BooleanNode\nimport com.fasterxml.jackson.databind.node.DecimalNode\nimport com.fasterxml.jackson.databind.node.DoubleNode\nimport com.fasterxml.jackson.databind.node.FloatNode\nimport com.fasterxml.jackson.databind.node.IntNode\nimport com.fasterxml.jackson.databind.node.JsonNodeFactory\nimport com.fasterxml.jackson.databind.node.LongNode\nimport com.fasterxml.jackson.databind.node.ObjectNode\nimport com.fasterxml.jackson.databind.node.ShortNode\nimport com.fasterxml.jackson.databind.node.TextNode\nimport com.fasterxml.jackson.databind.node.TreeTraversingParser\nimport com.fasterxml.jackson.databind.type.ArrayType\nimport com.fasterxml.jackson.databind.type.CollectionLikeType\nimport com.fasterxml.jackson.databind.type.MapLikeType\nimport com.fasterxml.jackson.databind.type.SimpleType\nimport com.fasterxml.jackson.databind.type.TypeFactory\nimport com.fasterxml.jackson.module.kotlin.convertValue\nimport com.uchuhimo.konf.Config\nimport com.uchuhimo.konf.ContainerNode\nimport com.uchuhimo.konf.EmptyNode\nimport com.uchuhimo.konf.Feature\nimport com.uchuhimo.konf.Item\nimport com.uchuhimo.konf.ListNode\nimport com.uchuhimo.konf.MapNode\nimport com.uchuhimo.konf.MergedMap\nimport com.uchuhimo.konf.NullNode\nimport com.uchuhimo.konf.Path\nimport com.uchuhimo.konf.SizeInBytes\nimport com.uchuhimo.konf.TreeNode\nimport com.uchuhimo.konf.ValueNode\nimport com.uchuhimo.konf.annotation.JavaApi\nimport com.uchuhimo.konf.source.base.ListStringNode\nimport com.uchuhimo.konf.source.base.toHierarchical\nimport com.uchuhimo.konf.toLittleCamelCase\nimport com.uchuhimo.konf.toPath\nimport com.uchuhimo.konf.toTree\nimport com.uchuhimo.konf.toValue\nimport org.apache.commons.text.StringSubstitutor\nimport org.apache.commons.text.lookup.StringLookup\nimport org.apache.commons.text.lookup.StringLookupFactory\nimport java.lang.reflect.InvocationTargetException\nimport java.math.BigDecimal\nimport java.math.BigInteger\nimport java.time.Duration\nimport java.time.Instant\nimport java.time.LocalDate\nimport java.time.LocalDateTime\nimport java.time.LocalTime\nimport java.time.OffsetDateTime\nimport java.time.OffsetTime\nimport java.time.Year\nimport java.time.YearMonth\nimport java.time.ZoneOffset\nimport java.time.ZonedDateTime\nimport java.time.format.DateTimeParseException\nimport java.util.ArrayDeque\nimport java.util.Collections\nimport java.util.Date\nimport java.util.Queue\nimport java.util.SortedMap\nimport java.util.SortedSet\nimport java.util.TreeMap\nimport java.util.TreeSet\nimport java.util.regex.Pattern\nimport kotlin.Byte\nimport kotlin.Char\nimport kotlin.Double\nimport kotlin.Float\nimport kotlin.Int\nimport kotlin.Long\nimport kotlin.Short\nimport kotlin.String\nimport kotlin.reflect.KClass\nimport kotlin.reflect.full.isSubclassOf\nimport kotlin.reflect.full.starProjectedType\nimport com.fasterxml.jackson.databind.node.NullNode as JacksonNullNode\n\n/**\n * Source to provide values for config.\n *\n * When config loads values from source, config will iterate all items in it, and\n * retrieve value with path of each item from source.\n * When source contains single value, a series of `is` operations can be used to\n * judge the actual type of value, and `to` operation can be used to get the value\n * with specified type.\n * When source contains multiple value, `contains` operations can be used to check\n * whether value(s) in specified path is in this source, and `get` operations can be used\n * to retrieve the corresponding sub-source.\n */\ninterface Source {\n /**\n * Description of this source.\n */\n val description: String\n get() = this.info.map { (name, value) ->\n \"$name: $value\"\n }.joinToString(separator = \", \", prefix = \"[\", postfix = \"]\")\n\n /**\n * Information about this source.\n *\n * Info is in form of key-value pairs.\n */\n val info: SourceInfo\n\n /**\n * a tree node that represents internal structure of this source.\n */\n val tree: TreeNode\n\n /**\n * Feature flags in this source.\n */\n val features: Map get() = emptyMap()\n\n /**\n * Whether this source contains value(s) in specified path or not.\n *\n * @param path item path\n * @return `true` if this source contains value(s) in specified path, `false` otherwise\n */\n operator fun contains(path: Path): Boolean = path in tree\n\n /**\n * Returns sub-source in specified path if this source contains value(s) in specified path,\n * `null` otherwise.\n *\n * @param path item path\n * @return sub-source in specified path if this source contains value(s) in specified path,\n * `null` otherwise\n */\n fun getOrNull(path: Path): Source? {\n return if (path.isEmpty()) {\n this\n } else {\n getTreeOrNull(tree, normalizedPath(path))?.let {\n Source(info = info, tree = it, features = features)\n }\n }\n }\n\n private fun getTreeOrNull(tree: TreeNode, path: Path): TreeNode? {\n return if (path.isEmpty()) {\n tree\n } else {\n val key = normalizedKey(path.first())\n val rest = path.drop(1)\n var result: TreeNode? = null\n for ((childKey, child) in tree.children) {\n if (key == normalizedKey(childKey)) {\n result = child\n break\n }\n }\n result?.let { getTreeOrNull(it, rest) }\n }\n }\n\n private fun normalizedKey(key: String): String {\n var currentKey = key\n if (isEnabled(Feature.LOAD_KEYS_AS_LITTLE_CAMEL_CASE)) {\n currentKey = currentKey.toLittleCamelCase()\n }\n if (isEnabled(Feature.LOAD_KEYS_CASE_INSENSITIVELY)) {\n currentKey = currentKey.toLowerCase()\n }\n return currentKey\n }\n\n private fun normalizedPath(path: Path, lowercased: Boolean = false, littleCamelCased: Boolean = true): Path {\n var currentPath = path\n if (littleCamelCased && isEnabled(Feature.LOAD_KEYS_AS_LITTLE_CAMEL_CASE)) {\n currentPath = currentPath.map { it.toLittleCamelCase() }\n }\n if (lowercased || isEnabled(Feature.LOAD_KEYS_CASE_INSENSITIVELY)) {\n currentPath = currentPath.map { it.toLowerCase() }\n }\n return currentPath\n }\n\n fun getNodeOrNull(path: Path, lowercased: Boolean = false, littleCamelCased: Boolean = true): TreeNode? {\n return tree.getOrNull(normalizedPath(path, lowercased, littleCamelCased))\n }\n\n /**\n * Returns sub-source in specified path.\n *\n * Throws [NoSuchPathException] if there is no value in specified path.\n *\n * @param path item path\n * @return sub-source in specified path\n * @throws NoSuchPathException\n */\n operator fun get(path: Path): Source = getOrNull(path) ?: throw NoSuchPathException(this, path)\n\n /**\n * Whether this source contains value(s) with specified prefix or not.\n *\n * @param prefix item prefix\n * @return `true` if this source contains value(s) with specified prefix, `false` otherwise\n */\n operator fun contains(prefix: String): Boolean = contains(prefix.toPath())\n\n /**\n * Returns sub-source in specified path if this source contains value(s) in specified path,\n * `null` otherwise.\n *\n * @param path item path\n * @return sub-source in specified path if this source contains value(s) in specified path,\n * `null` otherwise\n */\n fun getOrNull(path: String): Source? = getOrNull(path.toPath())\n\n /**\n * Returns sub-source in specified path.\n *\n * Throws [NoSuchPathException] if there is no value in specified path.\n *\n * @param path item path\n * @return sub-source in specified path\n * @throws NoSuchPathException\n */\n operator fun get(path: String): Source = get(path.toPath())\n\n /**\n * Returns source with specified additional prefix.\n *\n * @param prefix additional prefix\n * @return source with specified additional prefix\n */\n fun withPrefix(prefix: Path): Source {\n return if (prefix.isEmpty()) {\n this\n } else {\n var prefixedTree = tree\n for (key in prefix.asReversed()) {\n prefixedTree = ContainerNode(mutableMapOf(key to prefixedTree))\n }\n Source(\n info = this@Source.info,\n tree = prefixedTree,\n features = features\n )\n }\n }\n\n /**\n * Returns source with specified additional prefix.\n *\n * @param prefix additional prefix\n * @return source with specified additional prefix\n */\n fun withPrefix(prefix: String): Source = withPrefix(prefix.toPath())\n\n /**\n * Returns a source backing by specified fallback source.\n *\n * When config fails to retrieve values from this source, it will try to retrieve them from\n * fallback source.\n *\n * @param fallback fallback source\n * @return a source backing by specified fallback source\n */\n fun withFallback(fallback: Source): Source = MergedSource(this, fallback)\n\n /**\n * Returns a source overlapped by the specified facade source.\n *\n * When config fails to retrieve values from the facade source, it will try to retrieve them\n * from this source.\n *\n * @param facade the facade source\n * @return a source overlapped by the specified facade source\n */\n operator fun plus(facade: Source): Source = facade.withFallback(this)\n\n /**\n * Return a source that substitutes path variables within all strings by values.\n *\n * See [StringSubstitutor](https://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/StringSubstitutor.html)\n * for detailed substitution rules. An exception is when the string is in reference format like `${path}`,\n * the whole node will be replace by a reference to the sub-tree in the specified path.\n *\n * @param root the root source for substitution\n * @param enabled whether enabled or let the source decide by itself\n * @param errorWhenUndefined whether throw exception when this source contains undefined path variables\n * @return a source that substitutes path variables within all strings by values\n * @throws UndefinedPathVariableException\n */\n fun substituted(root: Source = this, enabled: Boolean = true, errorWhenUndefined: Boolean = true): Source {\n return if (!enabled || !this.isEnabled(Feature.SUBSTITUTE_SOURCE_BEFORE_LOADED)) {\n this\n } else {\n Source(info, tree.substituted(root, errorWhenUndefined), features)\n }\n }\n\n fun lowercased(enabled: Boolean = false): Source {\n return if (enabled || this.isEnabled(Feature.LOAD_KEYS_CASE_INSENSITIVELY)) {\n Source(info, tree.lowercased(), features)\n } else {\n this\n }\n }\n\n fun littleCamelCased(enabled: Boolean = true): Source {\n return if (!enabled || !this.isEnabled(Feature.LOAD_KEYS_AS_LITTLE_CAMEL_CASE)) {\n this\n } else {\n Source(info, tree.littleCamelCased(), features)\n }\n }\n\n fun normalized(lowercased: Boolean = false, littleCamelCased: Boolean = true): Source {\n var currentSource = this\n currentSource = currentSource.littleCamelCased(littleCamelCased)\n currentSource = currentSource.lowercased(lowercased)\n return currentSource\n }\n\n /**\n * Returns a new source that enables the specified feature.\n *\n * @param feature the specified feature\n * @return a new source\n */\n fun enabled(feature: Feature): Source = Source(\n info,\n tree,\n MergedMap(Collections.unmodifiableMap(features), mutableMapOf(feature to true))\n )\n\n /**\n * Returns a new source that disables the specified feature.\n *\n * @param feature the specified feature\n * @return a new source\n */\n fun disabled(feature: Feature): Source = Source(\n info,\n tree,\n MergedMap(Collections.unmodifiableMap(features), mutableMapOf(feature to false))\n )\n\n /**\n * Check whether the specified feature is enabled or not.\n *\n * @param feature the specified feature\n * @return whether the specified feature is enabled or not\n */\n fun isEnabled(feature: Feature): Boolean = features[feature] ?: feature.enabledByDefault\n\n companion object {\n operator fun invoke(\n info: SourceInfo = SourceInfo(),\n tree: TreeNode = ContainerNode.empty(),\n features: Map = emptyMap()\n ): Source {\n return BaseSource(info, tree, features)\n }\n\n /**\n * Returns default providers.\n *\n * It is a fluent API for default providers.\n */\n val from = DefaultProviders\n\n /**\n * Returns default providers.\n *\n * It is a fluent API for default providers.\n *\n * @return default providers.\n */\n @JavaApi\n @JvmStatic\n fun from() = from\n }\n}\n\n/**\n * Returns a value casted from source.\n *\n * @return a value casted from source\n */\ninline fun Source.toValue(): T {\n return Config().withSource(this).toValue()\n}\n\nprivate val singleVariablePattern = Pattern.compile(\"^\\\\$\\\\{(.+)}$\")\n\nprivate fun TreeNode.substituted(\n source: Source,\n errorWhenUndefined: Boolean,\n lookup: TreeLookup = TreeLookup(source.tree, source, errorWhenUndefined)\n): TreeNode {\n when (this) {\n is NullNode -> return this\n is ValueNode -> {\n if (this is SubstitutableNode && value is String) {\n val text = (if (substituted) originalValue else value) as String\n val matcher = singleVariablePattern.matcher(text.trim())\n if (matcher.find()) {\n val matchedValue = matcher.group(1)\n try {\n val resolvedValue = lookup.replace(matchedValue)\n val node = lookup.root.getOrNull(resolvedValue)\n if (node != null) {\n return node.substituted(source, true, lookup)\n }\n } catch (_: Exception) {\n }\n }\n try {\n return substitute(lookup.replace(text))\n } catch (_: IllegalArgumentException) {\n throw UndefinedPathVariableException(source, text)\n }\n } else {\n return this\n }\n }\n is ListNode -> {\n return withList(list.map { it.substituted(source, errorWhenUndefined, lookup) })\n }\n is MapNode -> {\n return withMap(\n children.mapValues { (_, child) ->\n child.substituted(source, errorWhenUndefined, lookup)\n }\n )\n }\n else -> throw UnsupportedNodeTypeException(source, this)\n }\n}\n\nprivate fun TreeNode.lowercased(): TreeNode {\n if (this is ContainerNode) {\n return withMap(\n children.mapKeys { (key, _) ->\n key.toLowerCase()\n }.mapValues { (_, child) ->\n child.lowercased()\n }\n )\n } else {\n return this\n }\n}\n\nprivate fun TreeNode.littleCamelCased(): TreeNode {\n if (this is ContainerNode) {\n return withMap(\n children.mapKeys { (key, _) ->\n key.toLittleCamelCase()\n }.mapValues { (_, child) ->\n child.littleCamelCased()\n }\n )\n } else {\n return this\n }\n}\n\nclass TreeLookup(val root: TreeNode, val source: Source, errorWhenUndefined: Boolean) : StringLookup {\n val substitutor: StringSubstitutor = StringSubstitutor(\n StringLookupFactory.INSTANCE.interpolatorStringLookup(this)\n ).apply {\n isEnableSubstitutionInVariables = true\n isEnableUndefinedVariableException = errorWhenUndefined\n }\n\n override fun lookup(key: String): String? {\n val node = root.getOrNull(key)\n if (node != null && node is ValueNode) {\n if (node.value::class in listOf(\n String::class,\n Char::class,\n Byte::class,\n Short::class,\n Int::class,\n Long::class,\n BigInteger::class\n )\n ) {\n val value = node.value.toString()\n return substitutor.replace(value)\n } else {\n throw WrongTypeException(\n \"${node.value} in ${source.description}\",\n node.value::class.java.simpleName,\n \"String\"\n )\n }\n } else {\n return null\n }\n }\n\n fun replace(text: String): String {\n return substitutor.replace(text)\n }\n}\n\nopen class BaseSource(\n override val info: SourceInfo = SourceInfo(),\n override val tree: TreeNode = ContainerNode.empty(),\n override val features: Map = emptyMap()\n) : Source\n\n/**\n * Information of source for debugging.\n */\nclass SourceInfo(\n private val info: MutableMap = mutableMapOf()\n) : MutableMap by info {\n constructor(vararg pairs: Pair) : this(mutableMapOf(*pairs))\n\n fun with(vararg pairs: Pair): SourceInfo {\n return SourceInfo(MergedMap(fallback = this, facade = mutableMapOf(*pairs)))\n }\n\n fun with(sourceInfo: SourceInfo): SourceInfo {\n return SourceInfo(MergedMap(fallback = this, facade = sourceInfo.toMutableMap()))\n }\n}\n\ninline fun Source.asValue(): T {\n return tree.asValueOf(this, T::class.java) as T\n}\n\nfun TreeNode.asValueOf(source: Source, type: Class<*>): Any {\n return castOrNull(source, type)\n ?: throw WrongTypeException(\n if (this is ValueNode) \"${this.value} in ${source.description}\"\n else \"$this in ${source.description}\",\n if (this is ValueNode) this.value::class.java.simpleName else \"Unknown\",\n type.simpleName\n )\n}\n\ninternal fun Any?.toCompatibleValue(mapper: ObjectMapper): Any {\n return when (this) {\n is OffsetTime,\n is OffsetDateTime,\n is ZonedDateTime,\n is LocalDate,\n is LocalDateTime,\n is LocalTime,\n is Year,\n is YearMonth,\n is Instant,\n is Duration -> this.toString()\n is Date -> this.toInstant().toString()\n is SizeInBytes -> this.bytes.toString()\n is Enum<*> -> this.name\n is ByteArray -> this.toList()\n is CharArray -> this.toList().map { it.toString() }\n is BooleanArray -> this.toList()\n is IntArray -> this.toList()\n is ShortArray -> this.toList()\n is LongArray -> this.toList()\n is DoubleArray -> this.toList()\n is FloatArray -> this.toList()\n is List<*> -> this.map { it!!.toCompatibleValue(mapper) }\n is Set<*> -> this.map { it!!.toCompatibleValue(mapper) }\n is Array<*> -> this.map { it!!.toCompatibleValue(mapper) }\n is Map<*, *> -> this.mapValues { (_, value) -> value.toCompatibleValue(mapper) }\n is Char -> this.toString()\n is String,\n is Boolean,\n is Int,\n is Short,\n is Byte,\n is Long,\n is BigInteger,\n is Double,\n is Float,\n is BigDecimal -> this\n else -> {\n if (this == null) {\n \"null\"\n } else {\n mapper.convertValue(this).toCompatibleValue(mapper)\n }\n }\n }\n}\n\ninternal fun Config.loadItem(item: Item<*>, path: Path, source: Source): Boolean {\n try {\n val itemNode = source.getNodeOrNull(\n path,\n lowercased = this.isEnabled(Feature.LOAD_KEYS_CASE_INSENSITIVELY),\n littleCamelCased = this.isEnabled(Feature.LOAD_KEYS_AS_LITTLE_CAMEL_CASE)\n )\n if (itemNode != null && !itemNode.isPlaceHolderNode()) {\n if (item.nullable &&\n (\n (itemNode is NullNode) ||\n (itemNode is ValueNode && itemNode.value == \"null\")\n )\n ) {\n rawSet(item, null)\n } else {\n rawSet(item, itemNode.toValue(source, item.type, mapper))\n }\n return true\n } else {\n return false\n }\n } catch (cause: SourceException) {\n throw LoadException(path, cause)\n }\n}\n\ninternal fun load(config: Config, source: Source): Source {\n var currentSource = source\n currentSource = currentSource.normalized(\n lowercased = config.isEnabled(Feature.LOAD_KEYS_CASE_INSENSITIVELY),\n littleCamelCased = config.isEnabled(Feature.LOAD_KEYS_AS_LITTLE_CAMEL_CASE)\n )\n currentSource = currentSource.substituted(\n enabled = config.isEnabled(Feature.SUBSTITUTE_SOURCE_BEFORE_LOADED)\n )\n config.lock {\n for (item in config) {\n config.loadItem(item, config.pathOf(item), currentSource)\n }\n if (currentSource.isEnabled(Feature.FAIL_ON_UNKNOWN_PATH) ||\n config.isEnabled(Feature.FAIL_ON_UNKNOWN_PATH)\n ) {\n val treeFromSource = currentSource.tree\n val treeFromConfig = config.toTree()\n val diffTree = treeFromSource - treeFromConfig\n if (diffTree != EmptyNode) {\n val unknownPaths = diffTree.paths\n throw UnknownPathsException(currentSource, unknownPaths)\n }\n }\n }\n return currentSource\n}\n\nprivate inline fun TreeNode.cast(source: Source): T {\n if (this !is ValueNode) {\n throw WrongTypeException(\"$this in ${source.description}\", this::class.java.simpleName, T::class.java.simpleName)\n }\n if (T::class.java.isInstance(value)) {\n return value as T\n } else {\n throw WrongTypeException(\"$value in ${source.description}\", value::class.java.simpleName, T::class.java.simpleName)\n }\n}\n\ninternal fun stringToBoolean(value: String): Boolean {\n return when {\n value.toLowerCase() == \"true\" -> true\n value.toLowerCase() == \"false\" -> false\n else -> throw ParseException(\"$value cannot be parsed to a boolean\")\n }\n}\n\ninternal fun shortToByte(value: Short): Byte {\n if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {\n throw ParseException(\"$value cannot be parsed to a byte\")\n }\n return value.toByte()\n}\n\ninternal fun intToShort(value: Int): Short {\n if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {\n throw ParseException(\"$value cannot be parsed to a short\")\n }\n return value.toShort()\n}\n\ninternal fun longToInt(value: Long): Int {\n if (value < Int.MIN_VALUE || value > Int.MAX_VALUE) {\n throw ParseException(\"$value cannot be parsed to an int\")\n }\n return value.toInt()\n}\n\ninternal fun stringToChar(value: String): Char {\n if (value.length != 1) {\n throw ParseException(\"$value cannot be parsed to a char\")\n }\n return value[0]\n}\n\nprivate inline fun String.tryParse(block: (String) -> T): T {\n try {\n return block(this)\n } catch (cause: DateTimeParseException) {\n throw ParseException(\"fail to parse \\\"$this\\\" as data time\", cause)\n }\n}\n\ninternal fun stringToDate(value: String): Date {\n return try {\n Date.from(value.tryParse { Instant.parse(it) })\n } catch (e: ParseException) {\n try {\n Date.from(\n value.tryParse {\n LocalDateTime.parse(it)\n }.toInstant(ZoneOffset.UTC)\n )\n } catch (e: ParseException) {\n Date.from(\n value.tryParse {\n LocalDate.parse(it)\n }.atStartOfDay().toInstant(ZoneOffset.UTC)\n )\n }\n }\n}\n\nprivate fun ((In) -> Out).asPromote(): PromoteFunc<*> {\n return { value, _ ->\n @Suppress(\"UNCHECKED_CAST\")\n this(value as In)\n }\n}\n\nprivate inline fun tryParseAsPromote(noinline block: (String) -> T): PromoteFunc<*> {\n return { value, _ ->\n try {\n block(value as String)\n } catch (cause: Exception) {\n if (cause is DateTimeParseException || cause is NumberFormatException) {\n throw ParseException(\"fail to parse \\\"$value\\\" as ${T::class.simpleName}\", cause)\n } else {\n throw cause\n }\n }\n }\n}\n\ntypealias PromoteFunc = (Any, Source) -> Out\n\nprivate val promoteMap: MutableMap, List, PromoteFunc<*>>>> = mutableMapOf(\n String::class to listOf(\n Boolean::class to ::stringToBoolean.asPromote(),\n Char::class to ::stringToChar.asPromote(),\n\n Byte::class to tryParseAsPromote { value: String -> value.toByte() },\n Short::class to tryParseAsPromote { value: String -> value.toShort() },\n Int::class to tryParseAsPromote { value: String -> value.toInt() },\n Long::class to tryParseAsPromote { value: String -> value.toLong() },\n Float::class to tryParseAsPromote { value: String -> value.toFloat() },\n Double::class to tryParseAsPromote { value: String -> value.toDouble() },\n BigInteger::class to tryParseAsPromote { value: String -> value.toBigInteger() },\n BigDecimal::class to tryParseAsPromote { value: String -> value.toBigDecimal() },\n\n OffsetTime::class to tryParseAsPromote { OffsetTime.parse(it) },\n OffsetDateTime::class to tryParseAsPromote { OffsetDateTime.parse(it) },\n ZonedDateTime::class to tryParseAsPromote { ZonedDateTime.parse(it) },\n LocalDate::class to tryParseAsPromote { LocalDate.parse(it) },\n LocalTime::class to tryParseAsPromote { LocalTime.parse(it) },\n LocalDateTime::class to tryParseAsPromote { LocalDateTime.parse(it) },\n Year::class to tryParseAsPromote { Year.parse(it) },\n YearMonth::class to tryParseAsPromote { YearMonth.parse(it) },\n Instant::class to tryParseAsPromote { Instant.parse(it) },\n\n Date::class to ::stringToDate.asPromote(),\n Duration::class to String::toDuration.asPromote(),\n\n SizeInBytes::class to { value: String -> SizeInBytes.parse(value) }.asPromote()\n ),\n Char::class to listOf(\n String::class to { value: Char -> \"$value\" }.asPromote()\n ),\n Byte::class to listOf(\n Short::class to Byte::toShort.asPromote(),\n Int::class to Byte::toInt.asPromote(),\n Long::class to Byte::toLong.asPromote(),\n Float::class to Byte::toFloat.asPromote(),\n Double::class to Byte::toDouble.asPromote()\n ),\n Short::class to listOf(\n Byte::class to ::shortToByte.asPromote(),\n Int::class to Short::toInt.asPromote(),\n Long::class to Short::toLong.asPromote(),\n Float::class to Short::toFloat.asPromote(),\n Double::class to Short::toDouble.asPromote()\n ),\n Int::class to listOf(\n Short::class to ::intToShort.asPromote(),\n Long::class to Int::toLong.asPromote(),\n Float::class to Int::toFloat.asPromote(),\n Double::class to Int::toDouble.asPromote()\n ),\n Long::class to listOf(\n Int::class to ::longToInt.asPromote(),\n Float::class to Long::toFloat.asPromote(),\n Double::class to Long::toDouble.asPromote(),\n BigInteger::class to { value: Long -> BigInteger.valueOf(value) }.asPromote()\n ),\n Float::class to listOf(\n Double::class to Float::toDouble.asPromote()\n ),\n Double::class to listOf(\n Float::class to Double::toFloat.asPromote(),\n BigDecimal::class to { value: Double -> BigDecimal.valueOf(value) }.asPromote()\n )\n)\n\nprivate val promoteMatchers: MutableList) -> Boolean, List, PromoteFunc<*>>>>> = mutableListOf(\n { type: KClass<*> -> type.starProjectedType == Array::class.starProjectedType } to listOf(\n List::class to { value: Array<*> -> value.asList() }.asPromote(),\n Set::class to { value: Array<*> -> value.asList().toSet() }.asPromote()\n ),\n { type: KClass<*> -> type.isSubclassOf(Set::class) } to listOf(\n List::class to { value: Set<*> -> value.toList() }.asPromote()\n )\n)\n\nprivate fun walkPromoteMap(\n valueType: KClass<*>,\n targetType: KClass<*>,\n tasks: Queue<() -> PromoteFunc<*>?>,\n visitedTypes: MutableSet>,\n previousPromoteFunc: PromoteFunc<*>? = null\n): PromoteFunc<*>? {\n if (valueType in visitedTypes) {\n return null\n }\n visitedTypes.add(valueType)\n var promotedTypes = promoteMap[valueType]\n if (promotedTypes == null) {\n for ((matcher, types) in promoteMatchers) {\n if (matcher(valueType)) {\n promotedTypes = types\n break\n }\n }\n }\n if (promotedTypes == null) {\n return null\n }\n for ((promotedType, promoteFunc) in promotedTypes) {\n val currentPromoteFunc: PromoteFunc<*> = if (previousPromoteFunc != null) {\n { value, source -> promoteFunc(previousPromoteFunc(value, source)!!, source) }\n } else {\n promoteFunc\n }\n if (promotedType == targetType) {\n return currentPromoteFunc\n } else {\n tasks.offer {\n walkPromoteMap(promotedType, targetType, tasks, visitedTypes, currentPromoteFunc)\n }\n }\n }\n return null\n}\n\nprivate fun getPromoteFunc(valueType: KClass<*>, targetType: KClass<*>): PromoteFunc<*>? {\n val tasks = ArrayDeque<() -> PromoteFunc<*>?>()\n tasks.offer {\n walkPromoteMap(valueType, targetType, tasks, mutableSetOf())\n }\n while (tasks.isNotEmpty()) {\n val func = tasks.poll()()\n if (func != null) {\n return func\n }\n }\n return null\n}\n\nprivate fun