SRSoftware/Configuration
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

initial commit

Browse Source 
Signed-off-by: Stephan Richter <s.richter@srsoftware.de>
This commit is contained in:
Stephan Richter
2024-12-22 12:55:41 +01:00
commit 1e62c2e8a7
15 changed files with 1117 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
.gitignore vendored Normal file
View File

@@ -0,0 +1,43 @@
.gradle
build/
!gradle/wrapper/gradle-wrapper.jar
!**/src/main/**/build/
!**/src/test/**/build/
### IntelliJ IDEA ###
.idea/modules.xml
.idea/jarRepositories.xml
.idea/compiler.xml
.idea/libraries/
*.iws
*.iml
*.ipr
out/
!**/src/main/**/out/
!**/src/test/**/out/
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
bin/
!**/src/main/**/bin/
!**/src/test/**/bin/
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store
.idea

42
build.gradle.kts Normal file
View File

@@ -0,0 +1,42 @@
plugins {
id("com.diffplug.spotless") version "latest.release"
}
repositories {
mavenCentral()
}
spotless {
java {
target("**/src/**/java/**/*.java")
removeUnusedImports()
importOrder()
clangFormat("18.1.8").style("file:config/clang-format")
licenseHeader("/* © SRSoftware 2024 */")
}
}
subprojects {
group = "de.srsoftware"
apply(plugin = "java-library")
repositories {
mavenLocal()
mavenCentral()
}
val implementation by configurations
val compileOnly by configurations
val testImplementation by configurations
val testRuntimeOnly by configurations
dependencies {
testImplementation(platform("org.junit:junit-bom:5.10.0"))
testImplementation("org.junit.jupiter:junit-jupiter")
}
tasks.withType<Test>() {
useJUnitPlatform()
}
}

269
config/clang-format Normal file
View File

@@ -0,0 +1,269 @@
---
Language: Java
AccessModifierOffset: -1
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveAssignments:
Enabled: true
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: true
AlignConsecutiveBitFields:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: false
AlignConsecutiveDeclarations:
Enabled: true
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: false
AlignConsecutiveMacros:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
PadOperators: false
AlignConsecutiveShortCaseStatements:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCaseColons: false
AlignEscapedNewlines: Left
AlignOperands: Align
AlignTrailingComments:
Kind: Always
OverEmptyLines: 0
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: false
AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes
AttributeMacros:
- __capability
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: Both
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterExternBlock: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakAfterAttributes: Never
BreakAfterJavaFieldAnnotations: false
BreakArrays: true
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: Always
BreakBeforeBraces: Attach
BreakBeforeInlineASMColon: OnlyMultiline
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
BreakStringLiterals: true
ColumnLimit: 999
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: true
DisableFormat: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IfMacros:
- KJ_IF_MAYBE
IncludeBlocks: Regroup
IncludeCategories:
- Regex: '^<ext/.*\.h>'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '^<.*\.h>'
Priority: 1
SortPriority: 0
CaseSensitive: false
- Regex: '^<.*'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '.*'
Priority: 3
SortPriority: 0
CaseSensitive: false
IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: true
IndentExternBlock: AfterExternBlock
IndentGotoLabels: true
IndentPPDirectives: None
IndentRequiresClause: true
IndentWidth: 16
IndentWrappedFunctionNames: false
InsertBraces: false
InsertNewlineAtEOF: false
InsertTrailingCommas: None
IntegerLiteralSeparator:
Binary: 0
BinaryMinDigits: 0
Decimal: 0
DecimalMinDigits: 0
Hex: 0
HexMinDigits: 0
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
KeepEmptyLinesAtEOF: false
LambdaBodyIndentation: Signature
LineEnding: DeriveLF
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 2
NamespaceIndentation: None
ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PackConstructorInitializers: NextLine
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakOpenParenthesis: 0
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyIndentedWhitespace: 0
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
PPIndentWidth: -1
QualifierAlignment: Leave
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
- ParseTestProto
- ParsePartialTestProto
CanonicalDelimiter: pb
BasedOnStyle: google
ReferenceAlignment: Pointer
ReflowComments: true
RemoveBracesLLVM: false
RemoveParentheses: Leave
RemoveSemicolon: false
RequiresClausePosition: OwnLine
RequiresExpressionIndentation: OuterScope
SeparateDefinitionBlocks: Leave
ShortNamespaceLines: 1
SortIncludes: CaseSensitive
SortJavaStaticImport: Before
SortUsingDeclarations: LexicographicNumeric
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeJsonColon: false
SpaceBeforeParens: ControlStatements
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterForeachMacros: true
AfterFunctionDefinitionName: false
AfterFunctionDeclarationName: false
AfterIfMacros: true
AfterOverloadedOperator: false
AfterRequiresInClause: false
AfterRequiresInExpression: false
BeforeNonEmptyParentheses: false
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: Never
SpacesInContainerLiterals: true
SpacesInLineCommentPrefix:
Minimum: 1
Maximum: -1
SpacesInParens: Never
SpacesInParensOptions:
InCStyleCasts: false
InConditionalStatements: false
InEmptyParentheses: false
Other: false
SpacesInSquareBrackets: false
Standard: Auto
StatementAttributeLikeMacros:
- Q_EMIT
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 16
UseTab: Always
VerilogBreakBetweenInstancePorts: true
WhitespaceSensitiveMacros:
- BOOST_PP_STRINGIZE
- CF_SWIFT_NAME
- NS_SWIFT_NAME
- PP_STRINGIZE
- STRINGIZE
...

69
de.srsoftware.configuration.api/build.gradle.kts Normal file
View File

@@ -0,0 +1,69 @@
description = "SRSoftware Configuration API"
plugins {
id("eu.kakde.gradle.sonatype-maven-central-publisher") version "1.0.6"
}
object Meta {
val COMPONENT_TYPE = "java" // "java" or "versionCatalog"
val GROUP = "de.srsoftware"
val ARTIFACT_ID = "configuration.api"
val VERSION = "1.0.0"
val PUBLISHING_TYPE = "AUTOMATIC" // USER_MANAGED or AUTOMATIC
val SHA_ALGORITHMS = listOf("SHA-256", "SHA-512") // sha256 and sha512 are supported but not mandatory. Only sha1 is mandatory but it is supported by default.
val DESC = "SRSoftware Configuration API"
val LICENSE = "MIT License"
val LICENSE_URL = "http://www.opensource.org/licenses/mit-license.php"
val GITHUB_REPO = "srsoftware-de/de.srsoftware.configuration"
val DEVELOPER_ID = "srichter"
val DEVELOPER_NAME = "Stephan Richter"
val DEVELOPER_ORGANIZATION = "SRSoftware"
val DEVELOPER_ORGANIZATION_URL = "https://srsoftware.de"
}
val sonatypeUsername: String? by project // this is defined in ~/.gradle/gradle.properties
val sonatypePassword: String? by project // this is defined in ~/.gradle/gradle.properties
sonatypeCentralPublishExtension {
// Set group ID, artifact ID, version, and other publication details
groupId.set(Meta.GROUP)
artifactId.set(Meta.ARTIFACT_ID)
version.set(Meta.VERSION)
componentType.set(Meta.COMPONENT_TYPE) // "java" or "versionCatalog"
publishingType.set(Meta.PUBLISHING_TYPE) // USER_MANAGED or AUTOMATIC
// Set username and password for Sonatype repository
username.set(sonatypeUsername)
password.set(sonatypePassword)
// Configure POM metadata
pom {
name.set(Meta.ARTIFACT_ID)
description.set(Meta.DESC)
url.set("https://github.com/${Meta.GITHUB_REPO}")
licenses {
license {
name.set(Meta.LICENSE)
url.set(Meta.LICENSE_URL)
}
}
developers {
developer {
id.set(Meta.DEVELOPER_ID)
name.set(Meta.DEVELOPER_NAME)
organization.set(Meta.DEVELOPER_ORGANIZATION)
organizationUrl.set(Meta.DEVELOPER_ORGANIZATION_URL)
}
}
scm {
url.set("https://github.com/${Meta.GITHUB_REPO}")
connection.set("scm:git:https://github.com/${Meta.GITHUB_REPO}")
developerConnection.set("scm:git:https://github.com/${Meta.GITHUB_REPO}")
}
issueManagement {
system.set("GitHub")
url.set("https://github.com/${Meta.GITHUB_REPO}/issues")
}
}
}

47
de.srsoftware.configuration.api/src/main/java/de/srsoftware/configuration/Configuration.java Normal file
View File

@@ -0,0 +1,47 @@
/* © SRSoftware 2024 */
package de.srsoftware.configuration;
import java.io.IOException;
import java.util.Optional;
/**
* Configuration Interface.
* Provieds methods to add values to a configuration and read values from it.
*/
public interface Configuration {
/**
* remove a value from the confuguration
* @param key specifies, which value shall be deleted
* @return the altered configuration
* @param <C> the class of the configuration implementation
* @throws IOException if altering the config is not possible
*/
<C extends Configuration> C drop(String key) throws IOException;
/**
* read a value from the configuration
* @param key specifies, which value is requested
* @return an Optional containing the value, if it is present, empty otherwise
* @param <T> the expected type of the value
*/
<T> Optional<T> get(String key);
/**
* read a value from the configuration and set it, if it is not present
* @param key specifies, which value is requested
* @param defaultValue the value which will be set and returned, if the requested value is not available
* @return the value assigned with the key or defaultValue, if no value was assigned with the key
* @param <T> the expected type of the return value
*/
<T> T get(String key, T defaultValue);
/**
* Assign a specific key with a new value. If the key was assigned with another value before, the old value is overwritten
* @param key specifies, which value is to be assigned
* @param value the new value
* @return the altered configuration
* @param <C> the type of the configuration
* @throws IOException if altering the configuration fails
*/
<C extends Configuration> C set(String key, Object value) throws IOException;
}

25
de.srsoftware.configuration.api/src/main/java/de/srsoftware/configuration/Locator.java Normal file
View File

@@ -0,0 +1,25 @@
/* © SRSoftware 2024 */
package de.srsoftware.configuration;
import java.io.File;
import java.nio.file.Path;
/**
* Helper for getting a config file
*/
public class Locator {
private Locator(){}
/**
* Get the proper configuration file for a given application name with the desired extension
* @param applicationName the name of the application
* @param extension the extension of the requested file
* @return a file Object
*/
public static File locateConfig(String applicationName, String extension) {
var filename = applicationName + "." + extension;
var home = System.getProperty("user.home");
return Path.of(home).resolve(".config").resolve(filename).toFile();
}
}

16
de.srsoftware.configuration.api/src/test/java/de/srsoftware/configuration/api/LocatorTest.java Normal file
View File

@@ -0,0 +1,16 @@
/* © SRSoftware 2024 */
package de.srsoftware.configuration.api;
import static org.junit.jupiter.api.Assertions.assertEquals;
import de.srsoftware.configuration.Locator;
import org.junit.jupiter.api.Test;
public class LocatorTest {
@Test
public void testLocator() {
var file = Locator.locateConfig("Test", "json");
var home = System.getProperty("user.home");
assertEquals(home + "/.config/Test.json", file.toString());
}
}

6
de.srsoftware.configuration.json/build.gradle.kts Normal file
View File

@@ -0,0 +1,6 @@
description = "SRSoftware Configuration | JSON Configuration"
dependencies {
implementation(project(":de.srsoftware.configuration.api"))
implementation("org.json:json:latest.release")
}

128
de.srsoftware.configuration.json/src/main/java/de/srsoftware/configuration/JsonConfig.java Normal file
View File

@@ -0,0 +1,128 @@
/* © SRSoftware 2024 */
package de.srsoftware.configuration;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.util.*;
import org.json.JSONObject;
public class JsonConfig implements Configuration {
private final File file;
private final JSONObject json;
public JsonConfig(File jsonConfigurationFile) throws IOException {
file = jsonConfigurationFile;
if (file.isDirectory()) throw new IllegalArgumentException("%s is a directory, file expected".formatted(file));
if (!file.exists()) try (var out = new FileWriter(file)) {
out.write("{}\n");
}
json = new JSONObject(Files.readString(file.toPath()));
}
public JsonConfig(String applicationName) throws IOException {
this(Locator.locateConfig(applicationName, "json"));
}
@Override
public <C extends Configuration> C drop(String key) throws IOException {
drop(json, toPath(key));
return (C)this;
}
private void drop(JSONObject json, Stack<String> path) {
String key = path.pop();
if (!json.has(key)) return;
if (path.isEmpty()) {
json.remove(key);
return;
}
if (json.get(key) instanceof JSONObject inner) drop(inner, path);
}
public File file() {
return file;
}
public String flat() {
return json.toString();
}
@Override
public <T> Optional<T> get(String key) {
return Optional.ofNullable(get(json, toPath(key), null));
}
@Override
@SuppressWarnings("unchecked")
public <T> T get(String key, T defaultValue) {
return (T)get(json, toPath(key), defaultValue);
}
@SuppressWarnings("unchecked")
private <T> T get(JSONObject json, Stack<String> path, T defaultValue) {
String key = path.pop();
if (path.isEmpty()) {
if (json.has(key)) try {
return (T)json.get(key);
} catch (ClassCastException ignored) {
// overwrite value
}
json.put(key, defaultValue);
return defaultValue;
} else {
if (!json.has(key)) {
if (defaultValue != null) {
var inner = new JSONObject();
set(inner, path, defaultValue);
json.put(key, inner);
}
return defaultValue;
}
var inner = json.get(key);
if (!(inner instanceof JSONObject)) {
if (defaultValue != null) {
inner = new JSONObject();
set((JSONObject)inner, path, defaultValue);
json.put(key, inner);
}
return defaultValue;
};
return get((JSONObject)inner, path, defaultValue);
}
}
@Override
@SuppressWarnings("unchecked")
public <C extends Configuration> C set(String key, Object value) throws IOException {
set(json, toPath(key), value);
return (C)this;
}
private void set(JSONObject json, Stack<String> path, Object value) {
var key = path.pop();
if (path.empty()) {
json.put(key, value);
} else {
if (!json.has(key)) json.put(key, new JSONObject());
var inner = json.get(key);
if (!(inner instanceof JSONObject)) json.put(key, inner = new JSONObject());
set((JSONObject)inner, path, value);
}
}
private Stack<String> toPath(String key) {
var parts = key.split("\\.");
var path = new Stack<String>();
for (int i = parts.length; i > 0; i--) path.push(parts[i - 1]);
return path;
}
@Override
public String toString() {
return json.toString(2);
}
}

120
de.srsoftware.configuration.json/src/test/java/de/srsoftware/configuration/JsonConfigTest.java Normal file
View File

@@ -0,0 +1,120 @@
/* © SRSoftware 2024 */
package de.srsoftware.configuration;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.Optional;
import org.json.JSONObject;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class JsonConfigTest {
private static final String STRING = "string";
private static final String HELLO_WORLD = "hello world";
private static final String MAP = "map";
private JsonConfig config;
@BeforeEach
public void setup() throws IOException {
var configFile = new File("/tmp/test.json");
if (configFile.exists()) configFile.delete();
config = new JsonConfig(configFile);
}
@Test
public void testEmptyConfig() {
assertTrue(config.file().exists());
assertTrue(config.file().isFile());
assertEquals("{}", config.flat());
}
@Test
void testSetFlat() throws IOException {
config.set("hello", "world");
assertEquals("{\"hello\":\"world\"}", config.flat());
}
@Test
void testSetNested() throws IOException {
// set nested
config.set("this.is.a", "test");
assertEquals("{\"this\":{\"is\":{\"a\":\"test\"}}}", config.flat());
// several nested attributes
config.set("this.is.no", "joke");
assertEquals("{\"this\":{\"is\":{\"a\":\"test\",\"no\":\"joke\"}}}", config.flat());
// overwrite value
config.set("this.is.a", "farce");
assertEquals("{\"this\":{\"is\":{\"a\":\"farce\",\"no\":\"joke\"}}}", config.flat());
// overwrite subset
config.set("this.is", "gone");
assertEquals("{\"this\":{\"is\":\"gone\"}}", config.flat());
config.set("int", 3);
assertEquals("{\"this\":{\"is\":\"gone\"},\"int\":3}", config.flat());
}
@Test
public void testGetFlat() throws IOException {
config.set("hello", "world");
config.set("this.is.a", "test");
Optional<String> res = config.get("hello");
assertTrue(res.isPresent());
assertEquals("world", res.get());
}
@Test
public void testGetNested() throws IOException {
config.set("hello", "world");
config.set("this.is.a", "test");
Optional<String> res = config.get("this.is.a");
assertTrue(res.isPresent());
assertEquals("test", res.get());
}
@Test
public void testGetJson() throws IOException {
config.set("hello", "world");
config.set("this.is.a", "test");
Optional<JSONObject> res = config.get("this");
assertTrue(res.isPresent());
assertEquals("{\"is\":{\"a\":\"test\"}}", res.get().toString());
}
@Test
public void testGetOrSet() {
String val = config.get("hello", "world");
assertEquals("world", val);
val = config.get("hello", "sunshine");
assertEquals("world", val);
}
@Test
public void testGetOrSetNested() {
String val = config.get("this.is.a", "test");
assertEquals("test", val);
val = config.get("this.is.a", "farce");
assertEquals("test", val);
assertEquals("{\"this\":{\"is\":{\"a\":\"test\"}}}", config.flat());
}
@Test
public void testDrop() throws IOException {
config.set("hello", "world");
config.set("this.is.a", "test");
assertEquals("{\"this\":{\"is\":{\"a\":\"test\"}},\"hello\":\"world\"}", config.flat());
config.drop("test.is.an");
assertEquals("{\"this\":{\"is\":{\"a\":\"test\"}},\"hello\":\"world\"}", config.flat());
config.drop("this.is.a");
assertEquals("{\"this\":{\"is\":{}},\"hello\":\"world\"}", config.flat());
config.drop("this");
assertEquals("{\"hello\":\"world\"}", config.flat());
config.drop("hello");
assertEquals("{}", config.flat());
}
}

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

7
gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

@@ -0,0 +1,7 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

249
gradlew vendored Executable file
View File

@@ -0,0 +1,249 @@
#!/bin/sh
#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
if ! command -v java >/dev/null 2>&1
then
die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Collect all arguments for the java command:
# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# and any embedded shellness will be escaped.
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
# treated as '${Hostname}' itself on the command line.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \
org.gradle.wrapper.GradleWrapperMain \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"

92
gradlew.bat vendored Normal file
View File

@@ -0,0 +1,92 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 0 goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

4
settings.gradle.kts Normal file
View File

@@ -0,0 +1,4 @@
rootProject.name = "Configuration"
include("de.srsoftware.configuration.api")
include("de.srsoftware.configuration.json")