Skip to content

The Unified and Autonomous Development Platform

Migration from existing xml based build spec

Robin Shen80ca2015f5a6
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java b/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java
index fd4ffca3b3..e08f7f332d 100644
--- a/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java
+++ b/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java
@@ -24,6 +24,7 @@ import io.onedev.server.buildspec.job.paramsupply.ParamSupply;
import io.onedev.server.buildspec.job.retrycondition.RetryCondition;
import io.onedev.server.buildspec.job.trigger.JobTrigger;
import io.onedev.server.migration.VersionedYamlDoc;
+import io.onedev.server.migration.XmlBuildSpecMigrator;
import io.onedev.server.util.validation.Validatable;
import io.onedev.server.util.validation.annotation.ClassValidating;
import io.onedev.server.web.editable.annotation.Editable;
@@ -206,6 +207,8 @@ public class BuildSpec implements Serializable, Validatable {
public static BuildSpec parse(byte[] bytes) {
String buildSpecString = new String(bytes, StandardCharsets.UTF_8);
if (StringUtils.isNotBlank(buildSpecString)) {
+ if (buildSpecString.trim().startsWith("<?xml"))
+ buildSpecString = XmlBuildSpecMigrator.migrate(buildSpecString);
try {
return VersionedYamlDoc.fromYaml(buildSpecString).toBean(BuildSpec.class);
} catch (Exception e) {
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java
index fb176975b7..dbff87e7d9 100644
--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java
+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java
@@ -7,7 +7,7 @@ import org.apache.commons.lang3.builder.HashCodeBuilder;
import io.onedev.server.web.editable.annotation.Editable;
-@Editable
+@Editable(name="Ignore")
public class Ignore implements ValuesProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java
index 61a225a5b6..97ea0c792b 100644
--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java
+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java
@@ -49,6 +49,7 @@ public class ParamSupply implements Serializable {
private ValuesProvider valuesProvider = new SpecifiedValues();
+ @Editable
@NotEmpty
public String getName() {
return name;
@@ -58,6 +59,7 @@ public class ParamSupply implements Serializable {
this.name = name;
}
+ @Editable
@NotNull
@Valid
public ValuesProvider getValuesProvider() {
@@ -68,6 +70,7 @@ public class ParamSupply implements Serializable {
this.valuesProvider = valuesProvider;
}
+ @Editable
public boolean isSecret() {
return secret;
}
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java
index 7b444a1033..8952c1d55a 100644
--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java
+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java
@@ -15,7 +15,7 @@ import io.onedev.server.util.GroovyUtils;
import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.editable.annotation.ScriptChoice;
-@Editable
+@Editable(name="Evaluate script to get values or secrets")
public class ScriptingValues implements ValuesProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java
index 0f5b6de541..808ca93964 100644
--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java
+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java
@@ -8,7 +8,7 @@ import org.apache.commons.lang3.builder.HashCodeBuilder;
import io.onedev.server.web.editable.annotation.Editable;
-@Editable
+@Editable(name="Use specified values or job secrets")
public class SpecifiedValues implements ValuesProvider {
private static final long serialVersionUID = 1L;
@@ -19,6 +19,7 @@ public class SpecifiedValues implements ValuesProvider {
private List<List<String>> values = new ArrayList<>();
+ @Editable
@Override
public List<List<String>> getValues() {
return values;
diff --git a/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java b/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java
index 20fc05d708..0582a75602 100644
--- a/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java
+++ b/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java
@@ -452,7 +452,8 @@ public final class VersionedXmlDoc implements Document, Externalizable {
* to reflect current migration result.
* @return
*/
- public Object toBean(Class<?> beanClass) {
+ @SuppressWarnings("unchecked")
+ public <T> T toBean(@Nullable Class<T> beanClass) {
XStream xstream = AppLoader.getInstance(XStream.class);
Dom4JReader domReader = new Dom4JReader(this);
Class<?> origBeanClass;
@@ -468,10 +469,10 @@ public final class VersionedXmlDoc implements Document, Externalizable {
if (origBeanClass == null)
return null;
else if (origBeanClass == Null.class)
- return ObjectUtils.NULL;
+ return (T) ObjectUtils.NULL;
if (beanClass == null)
- beanClass = origBeanClass;
+ beanClass = (Class<T>) origBeanClass;
else
getRootElement().setName(xstream.getMapper().serializedClass(beanClass));
if (getVersion() != null) {
@@ -480,15 +481,15 @@ public final class VersionedXmlDoc implements Document, Externalizable {
if (MigrationHelper.migrate(getVersion(), migrator, this)) {
setVersion(MigrationHelper.getVersion(migrator.getClass()));
Object bean = xstream.unmarshal(domReader);
- return bean;
+ return (T) bean;
} else {
- return xstream.unmarshal(domReader);
+ return (T) xstream.unmarshal(domReader);
}
} catch (InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
} else {
- return xstream.unmarshal(domReader);
+ return (T) xstream.unmarshal(domReader);
}
}
diff --git a/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java b/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java
index 9b49172297..370d428d79 100644
--- a/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java
+++ b/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java
@@ -1,5 +1,7 @@
package io.onedev.server.migration;
+import java.beans.IntrospectionException;
+import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
@@ -21,6 +23,7 @@ import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.Constructor;
import org.yaml.snakeyaml.emitter.Emitter;
import org.yaml.snakeyaml.introspector.BeanAccess;
+import org.yaml.snakeyaml.introspector.MethodProperty;
import org.yaml.snakeyaml.introspector.Property;
import org.yaml.snakeyaml.introspector.PropertyUtils;
import org.yaml.snakeyaml.nodes.MappingNode;
@@ -35,11 +38,9 @@ import org.yaml.snakeyaml.serializer.Serializer;
import edu.emory.mathcs.backport.java.util.Collections;
import io.onedev.commons.launcher.loader.ImplementationRegistry;
import io.onedev.commons.utils.ClassUtils;
-import io.onedev.commons.utils.StringUtils;
import io.onedev.server.OneDev;
import io.onedev.server.OneException;
import io.onedev.server.util.BeanUtils;
-import io.onedev.server.web.editable.EditableUtils;
import io.onedev.server.web.editable.annotation.Editable;
public class VersionedYamlDoc extends MappingNode {
@@ -134,7 +135,7 @@ public class VersionedYamlDoc extends MappingNode {
if (type.getAnnotation(Editable.class) != null && !ClassUtils.isConcrete(type)) {
ImplementationRegistry registry = OneDev.getInstance(ImplementationRegistry.class);
for (Class<?> implementationClass: registry.getImplementations(node.getType())) {
- String implementationTag = new Tag(getTagValue(implementationClass)).getValue();
+ String implementationTag = new Tag("!" + implementationClass.getSimpleName()).getValue();
if (implementationTag.equals(node.getTag().getValue()))
return implementationClass;
}
@@ -145,16 +146,16 @@ public class VersionedYamlDoc extends MappingNode {
}
- private static String getTagValue(Class<?> type) {
- String displayName = EditableUtils.getDisplayName(type).toLowerCase();
- return "!" + StringUtils.replace(displayName, " ", "-");
- }
-
private static class OneYaml extends Yaml {
OneYaml() {
super(newConstructor(), newRepresenter());
- setBeanAccess(BeanAccess.FIELD);
+
+ /*
+ * Use property here as yaml will be read by human and we want to make
+ * it consistent with presented in UI
+ */
+ setBeanAccess(BeanAccess.PROPERTY);
}
private static Representer newRepresenter() {
@@ -173,50 +174,38 @@ public class VersionedYamlDoc extends MappingNode {
}
}
- @Override
- protected Tag getTag(Class<?> clazz, Tag defaultTag) {
- return super.getTag(clazz, defaultTag);
- }
-
- @Override
- protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {
- if (javaBean.getClass().getAnnotation(Editable.class) != null)
- classTags.put(javaBean.getClass(), new Tag(getTagValue(javaBean.getClass())));
- return super.representJavaBean(properties, javaBean);
- }
-
};
representer.setDefaultFlowStyle(FlowStyle.BLOCK);
representer.setPropertyUtils(new PropertyUtils() {
@Override
protected Set<Property> createPropertySet(Class<? extends Object> type, BeanAccess bAccess) {
+ List<Property> properties = new ArrayList<>();
Map<String, Integer> orders = new HashMap<>();
if (type.getAnnotation(Editable.class) != null) {
for (Method getter: BeanUtils.findGetters(type)) {
Editable editable = getter.getAnnotation(Editable.class);
- if (editable != null)
- orders.put(BeanUtils.getPropertyName(getter), editable.order());
+ Method setter = BeanUtils.findSetter(getter);
+ if (editable != null && setter != null) {
+ String propertyName = BeanUtils.getPropertyName(getter);
+ try {
+ properties.add(new MethodProperty(new PropertyDescriptor(propertyName, getter, setter)));
+ } catch (IntrospectionException e) {
+ throw new RuntimeException(e);
+ }
+ orders.put(propertyName, editable.order());
+ }
}
}
- Set<Property> properties = super.createPropertySet(type, bAccess);
- List<Property> listOfProperties = new ArrayList<>(properties);
- Collections.sort(listOfProperties, new Comparator<Property>() {
+ Collections.sort(properties, new Comparator<Property>() {
- private int getOrder(Property property) {
- Integer order = orders.get(property.getName());
- if (order == null)
- order = Integer.MAX_VALUE;
- return order;
- }
-
@Override
public int compare(Property o1, Property o2) {
- return getOrder(o1) - getOrder(o2);
+ return orders.get(o1.getName()) - orders.get(o2.getName());
}
});
- return new LinkedHashSet<>(listOfProperties);
+ return new LinkedHashSet<>(properties);
}
});
diff --git a/server-core/src/main/java/io/onedev/server/migration/XmlBuildSpecMigrator.java b/server-core/src/main/java/io/onedev/server/migration/XmlBuildSpecMigrator.java
new file mode 100644
index 0000000000..5fecc3ed5c
--- /dev/null
+++ b/server-core/src/main/java/io/onedev/server/migration/XmlBuildSpecMigrator.java
@@ -0,0 +1,716 @@
+package io.onedev.server.migration;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.dom4j.Document;
+import org.dom4j.DocumentException;
+import org.dom4j.Element;
+import org.dom4j.io.SAXReader;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.FlowStyle;
+import org.yaml.snakeyaml.emitter.Emitter;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+import org.yaml.snakeyaml.nodes.Tag;
+import org.yaml.snakeyaml.resolver.Resolver;
+import org.yaml.snakeyaml.serializer.Serializer;
+
+import com.google.common.collect.Lists;
+
+import io.onedev.commons.utils.StringUtils;
+
+public class XmlBuildSpecMigrator {
+
+ private static Node migrateParamSpec(Element paramSpecElement) {
+ String classTag = getClassTag(paramSpecElement.getName());
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "name"),
+ new ScalarNode(Tag.STR, paramSpecElement.elementText("name").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "allowEmpty"),
+ new ScalarNode(Tag.STR, paramSpecElement.elementText("allowEmpty").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "allowMultiple"),
+ new ScalarNode(Tag.STR, paramSpecElement.elementText("allowMultiple").trim())));
+ Element patternElement = paramSpecElement.element("pattern");
+ if (patternElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "pattern"),
+ new ScalarNode(Tag.STR, patternElement.getText().trim())));
+ }
+ Element descriptionElement = paramSpecElement.element("description");
+ if (descriptionElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "description"),
+ new ScalarNode(Tag.STR, descriptionElement.getText().trim())));
+ }
+ Element minValueElement = paramSpecElement.element("minValue");
+ if (minValueElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "minValue"),
+ new ScalarNode(Tag.STR, minValueElement.getText().trim())));
+ }
+ Element maxValueElement = paramSpecElement.element("maxValue");
+ if (maxValueElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "maxValue"),
+ new ScalarNode(Tag.STR, maxValueElement.getText().trim())));
+ }
+ Element showConditionElement = paramSpecElement.element("showCondition");
+ if (showConditionElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "showCondition"),
+ migrateShowCondition(showConditionElement)));
+ }
+ Element defaultValueProviderElement = paramSpecElement.element("defaultValueProvider");
+ if (defaultValueProviderElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "defaultValueProvider"),
+ migrateDefaultValueProvider(defaultValueProviderElement)));
+ }
+ Element defaultMultiValueProviderElement = paramSpecElement.element("defaultMultiValueProvider");
+ if (defaultMultiValueProviderElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "defaultMultiValueProvider"),
+ migrateDefaultMultiValueProvider(defaultMultiValueProviderElement)));
+ }
+ Element choiceProviderElement = paramSpecElement.element("choiceProvider");
+ if (choiceProviderElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "choiceProvider"),
+ migrateChoiceProvider(choiceProviderElement)));
+ }
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static String getClassTag(String className) {
+ return "!" + StringUtils.substringAfterLast(className, ".");
+ }
+
+ private static Node migrateChoiceProvider(Element choiceProviderElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(choiceProviderElement.attributeValue("class"));
+
+ Element scriptNameElement = choiceProviderElement.element("scriptName");
+ if (scriptNameElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "scriptName"),
+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));
+ }
+ Element choicesElement = choiceProviderElement.element("choices");
+ if (choicesElement != null) {
+ List<Node> choiceNodes = new ArrayList<>();
+ for (Element choiceElement: choicesElement.elements()) {
+ List<NodeTuple> choiceTuples = new ArrayList<>();
+ choiceTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "value"),
+ new ScalarNode(Tag.STR, choiceElement.elementText("value").trim())));
+ choiceTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "color"),
+ new ScalarNode(Tag.STR, choiceElement.elementText("color").trim())));
+ choiceNodes.add(new MappingNode(Tag.MAP, choiceTuples, FlowStyle.BLOCK));
+ }
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "choices"),
+ new SequenceNode(Tag.SEQ, choiceNodes, FlowStyle.BLOCK)));
+ }
+
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateDefaultMultiValueProvider(Element defaultMultiValueProviderElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(defaultMultiValueProviderElement.attributeValue("class"));
+ Element scriptNameElement = defaultMultiValueProviderElement.element("scriptName");
+ if (scriptNameElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "scriptName"),
+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));
+ }
+ Element valueElement = defaultMultiValueProviderElement.element("value");
+ if (valueElement != null) {
+ List<Node> valueItemNodes = new ArrayList<>();
+ for (Element valueItemElement: valueElement.elements())
+ valueItemNodes.add(new ScalarNode(Tag.STR, valueItemElement.getText().trim()));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "value"),
+ new SequenceNode(Tag.SEQ, valueItemNodes, FlowStyle.BLOCK)));
+ }
+
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateDefaultValueProvider(Element defaultValueProviderElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(defaultValueProviderElement.attributeValue("class"));
+ Element scriptNameElement = defaultValueProviderElement.element("scriptName");
+ if (scriptNameElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "scriptName"),
+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));
+ }
+ Element valueElement = defaultValueProviderElement.element("value");
+ if (valueElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "value"),
+ new ScalarNode(Tag.STR, valueElement.getText().trim())));
+ }
+
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateShowCondition(Element showConditionElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "inputName"),
+ new ScalarNode(Tag.STR, showConditionElement.elementText("inputName").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "valueMatcher"),
+ migrateValueMatcher(showConditionElement.element("valueMatcher"))));
+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateValueMatcher(Element valueMatcherElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(valueMatcherElement.attributeValue("class"));
+ Element valuesElement = valueMatcherElement.element("values");
+ if (valuesElement != null) {
+ List<Node> valueNodes = new ArrayList<>();
+ for (Element valueElement: valuesElement.elements())
+ valueNodes.add(new ScalarNode(Tag.STR, valueElement.getText().trim()));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "values"),
+ new SequenceNode(Tag.SEQ, valueNodes, FlowStyle.BLOCK)));
+ }
+
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateJob(Element jobElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "name"),
+ new ScalarNode(Tag.STR, jobElement.elementText("name").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "image"),
+ new ScalarNode(Tag.STR, jobElement.elementText("image").trim())));
+ List<Node> commandNodes = new ArrayList<>();
+ for (Element commandElement: jobElement.element("commands").elements())
+ commandNodes.add(new ScalarNode(Tag.STR, commandElement.getText().trim()));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "commands"),
+ new SequenceNode(Tag.SEQ, commandNodes, FlowStyle.BLOCK)));
+
+ List<Node> paramSpecNodes = new ArrayList<>();
+ for (Element paramSpecElement: jobElement.element("paramSpecs").elements())
+ paramSpecNodes.add(migrateParamSpec(paramSpecElement));
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "paramSpecs"),
+ new SequenceNode(Tag.SEQ, paramSpecNodes, FlowStyle.BLOCK)));
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "retrieveSource"),
+ new ScalarNode(Tag.STR, jobElement.elementText("retrieveSource").trim())));
+ Element cloneDepthElement = jobElement.element("cloneDepth");
+ if (cloneDepthElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "cloneDepth"),
+ new ScalarNode(Tag.STR, cloneDepthElement.getText().trim())));
+ }
+
+ List<Node> submoduleCredentialNodes = new ArrayList<>();
+ for (Element submoduleCredentialElement: jobElement.element("submoduleCredentials").elements()) {
+ List<NodeTuple> submoduleCredentialTuples = new ArrayList<>();
+ submoduleCredentialTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "url"),
+ new ScalarNode(Tag.STR, submoduleCredentialElement.elementText("url").trim())));
+ submoduleCredentialTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "userName"),
+ new ScalarNode(Tag.STR, submoduleCredentialElement.elementText("userName").trim())));
+ submoduleCredentialTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "passwordSecret"),
+ new ScalarNode(Tag.STR, submoduleCredentialElement.elementText("passwordSecret").trim())));
+ submoduleCredentialNodes.add(new MappingNode(Tag.MAP, submoduleCredentialTuples, FlowStyle.BLOCK));
+ }
+ if (!submoduleCredentialNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "submoduleCredentials"),
+ new SequenceNode(Tag.SEQ, submoduleCredentialNodes, FlowStyle.BLOCK)));
+ }
+
+ List<Node> jobDependencyNodes = new ArrayList<>();
+ for (Element jobDependencyElement: jobElement.element("jobDependencies").elements())
+ jobDependencyNodes.add(migrateJobDependency(jobDependencyElement));
+ if (!jobDependencyNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "jobDependencies"),
+ new SequenceNode(Tag.SEQ, jobDependencyNodes, FlowStyle.BLOCK)));
+ }
+
+ List<Node> projectDependencyNodes = new ArrayList<>();
+ for (Element projectDependencyElement: jobElement.element("projectDependencies").elements())
+ projectDependencyNodes.add(migrateProjectDependency(projectDependencyElement));
+ if (!projectDependencyNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "projectDependencies"),
+ new SequenceNode(Tag.SEQ, projectDependencyNodes, FlowStyle.BLOCK)));
+ }
+
+ List<Node> serviceNodes = new ArrayList<>();
+ for (Element serviceElement: jobElement.element("services").elements())
+ serviceNodes.add(migrateService(serviceElement));
+ if (!serviceNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "services"),
+ new SequenceNode(Tag.SEQ, serviceNodes, FlowStyle.BLOCK)));
+ }
+
+ Element artifactsElement = jobElement.element("artifacts");
+ if (artifactsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "artifacts"),
+ new ScalarNode(Tag.STR, artifactsElement.getText().trim())));
+ }
+
+ List<Node> reportNodes = new ArrayList<>();
+ for (Element reportElement: jobElement.element("reports").elements())
+ reportNodes.add(migrateReport(reportElement));
+ if (!reportNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "reports"),
+ new SequenceNode(Tag.SEQ, reportNodes, FlowStyle.BLOCK)));
+ }
+
+ List<Node> triggerNodes = new ArrayList<>();
+ for (Element triggerElement: jobElement.element("triggers").elements())
+ triggerNodes.add(migrateTrigger(triggerElement));
+ if (!triggerNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "triggers"),
+ new SequenceNode(Tag.SEQ, triggerNodes, FlowStyle.BLOCK)));
+ }
+
+ List<Node> cacheNodes = new ArrayList<>();
+ for (Element cacheElement: jobElement.element("caches").elements())
+ cacheNodes.add(migrateCache(cacheElement));
+ if (!cacheNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "caches"),
+ new SequenceNode(Tag.SEQ, cacheNodes, FlowStyle.BLOCK)));
+ }
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "cpuRequirement"),
+ new ScalarNode(Tag.STR, jobElement.elementText("cpuRequirement").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "memoryRequirement"),
+ new ScalarNode(Tag.STR, jobElement.elementText("memoryRequirement").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "timeout"),
+ new ScalarNode(Tag.STR, jobElement.elementText("timeout").trim())));
+
+ List<Node> postBuildActionNodes = new ArrayList<>();
+ for (Element postBuildActionElement: jobElement.element("postBuildActions").elements())
+ postBuildActionNodes.add(migratePostBuildAction(postBuildActionElement));
+ if (!postBuildActionNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "postBuildActions"),
+ new SequenceNode(Tag.SEQ, postBuildActionNodes, FlowStyle.BLOCK)));
+ }
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "retryCondition"),
+ new ScalarNode(Tag.STR, jobElement.elementText("retryCondition").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "maxRetries"),
+ new ScalarNode(Tag.STR, jobElement.elementText("maxRetries").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "retryDelay"),
+ new ScalarNode(Tag.STR, jobElement.elementText("retryDelay").trim())));
+
+ Element defaultFixedIssuesFilterElement = jobElement.element("defaultFixedIssuesFilter");
+ if (defaultFixedIssuesFilterElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "defaultFixedIssuesFilter"),
+ new ScalarNode(Tag.STR, defaultFixedIssuesFilterElement.getText().trim())));
+ }
+
+ MappingNode jobNode = new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ return jobNode;
+ }
+
+ private static Node migratePostBuildAction(Element postBuildActionElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(postBuildActionElement.getName());
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "condition"),
+ new ScalarNode(Tag.STR, postBuildActionElement.elementText("condition").trim())));
+
+ Element milestoneNameElement = postBuildActionElement.element("milestoneName");
+ if (milestoneNameElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "milestoneName"),
+ new ScalarNode(Tag.STR, milestoneNameElement.getText().trim())));
+ }
+
+ Element issueTitleElement = postBuildActionElement.element("issueTitle");
+ if (issueTitleElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "issueTitle"),
+ new ScalarNode(Tag.STR, issueTitleElement.getText().trim())));
+ }
+
+ Element issueDescriptionElement = postBuildActionElement.element("issueDescription");
+ if (issueDescriptionElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "issueDescription"),
+ new ScalarNode(Tag.STR, issueDescriptionElement.getText().trim())));
+ }
+
+ Element issueFieldsElement = postBuildActionElement.element("issueFields");
+ if (issueFieldsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "issueFields"),
+ new SequenceNode(Tag.SEQ, migrateFieldSupplies(issueFieldsElement.elements()), FlowStyle.BLOCK)));
+ }
+
+ Element tagNameElement = postBuildActionElement.element("tagName");
+ if (tagNameElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "tagName"),
+ new ScalarNode(Tag.STR, tagNameElement.getText().trim())));
+ }
+
+ Element tagMessageElement = postBuildActionElement.element("tagMessage");
+ if (tagMessageElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "tagMessage"),
+ new ScalarNode(Tag.STR, tagMessageElement.getText().trim())));
+ }
+
+ Element jobNameElement = postBuildActionElement.element("jobName");
+ if (jobNameElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "jobName"),
+ new ScalarNode(Tag.STR, jobNameElement.getText().trim())));
+ }
+
+ Element jobParamsElement = postBuildActionElement.element("jobParams");
+ if (jobParamsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "jobParams"),
+ new SequenceNode(Tag.SEQ, migrateParamSupplies(jobParamsElement.elements()), FlowStyle.BLOCK)));
+ }
+
+ Element receiversElement = postBuildActionElement.element("receivers");
+ if (receiversElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "receivers"),
+ new ScalarNode(Tag.STR, receiversElement.getText().trim())));
+ }
+
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateCache(Element cacheElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "key"),
+ new ScalarNode(Tag.STR, cacheElement.elementText("key").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "path"),
+ new ScalarNode(Tag.STR, cacheElement.elementText("path").trim())));
+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateTrigger(Element triggerElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(triggerElement.getName());
+
+ List<Node> paramSupplyNodes = migrateParamSupplies(triggerElement.element("params").elements());
+ if (!paramSupplyNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "params"),
+ new SequenceNode(Tag.SEQ, paramSupplyNodes, FlowStyle.BLOCK)));
+ }
+
+ Element branchesElement = triggerElement.element("branches");
+ if (branchesElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "branches"),
+ new ScalarNode(Tag.STR, branchesElement.getText().trim())));
+ }
+
+ Element pathsElement = triggerElement.element("paths");
+ if (pathsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "paths"),
+ new ScalarNode(Tag.STR, pathsElement.getText().trim())));
+ }
+
+ Element tagsElement = triggerElement.element("tags");
+ if (tagsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "tags"),
+ new ScalarNode(Tag.STR, tagsElement.getText().trim())));
+ }
+
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateReport(Element reportElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ String classTag = getClassTag(reportElement.getName());
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "filePatterns"),
+ new ScalarNode(Tag.STR, reportElement.elementText("filePatterns").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "reportName"),
+ new ScalarNode(Tag.STR, reportElement.elementText("reportName").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "startPage"),
+ new ScalarNode(Tag.STR, reportElement.elementText("startPage").trim())));
+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateService(Element serviceElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "name"),
+ new ScalarNode(Tag.STR, serviceElement.elementText("name").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "image"),
+ new ScalarNode(Tag.STR, serviceElement.elementText("image").trim())));
+ Element argumentsElement = serviceElement.element("arguments");
+ if (argumentsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "arguments"),
+ new ScalarNode(Tag.STR, argumentsElement.getText().trim())));
+ }
+ List<Node> envVarNodes = new ArrayList<>();
+ for (Element envVarElement: serviceElement.element("envVars").elements()) {
+ List<NodeTuple> envVarTuples = new ArrayList<>();
+ envVarTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "name"),
+ new ScalarNode(Tag.STR, envVarElement.elementText("name").trim())));
+ envVarTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "value"),
+ new ScalarNode(Tag.STR, envVarElement.elementText("value").trim())));
+ envVarNodes.add(new MappingNode(Tag.MAP, envVarTuples, FlowStyle.BLOCK));
+ }
+ if (!envVarNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "envVars"),
+ new SequenceNode(Tag.SEQ, envVarNodes, FlowStyle.BLOCK)));
+ }
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "readinessCheckCommand"),
+ new ScalarNode(Tag.STR, serviceElement.elementText("readinessCheckCommand").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "cpuRequirement"),
+ new ScalarNode(Tag.STR, serviceElement.elementText("cpuRequirement").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "memoryRequirement"),
+ new ScalarNode(Tag.STR, serviceElement.elementText("memoryRequirement").trim())));
+
+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateProjectDependency(Element projectDependencyElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "projectName"),
+ new ScalarNode(Tag.STR, projectDependencyElement.elementText("projectName").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "buildNumber"),
+ new ScalarNode(Tag.STR, projectDependencyElement.elementText("buildNumber").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "artifacts"),
+ new ScalarNode(Tag.STR, projectDependencyElement.elementText("artifacts").trim())));
+
+ Element authenticationElement = projectDependencyElement.element("authentication");
+ if (authenticationElement != null) {
+ List<NodeTuple> authenticationTuples = new ArrayList<>();
+ authenticationTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "userName"),
+ new ScalarNode(Tag.STR, authenticationElement.elementText("userName").trim())));
+ authenticationTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "passwordSecret"),
+ new ScalarNode(Tag.STR, authenticationElement.elementText("passwordSecret").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "authentication"),
+ new MappingNode(Tag.MAP, authenticationTuples, FlowStyle.BLOCK)));
+ }
+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ }
+
+ private static Node migrateJobDependency(Element jobDependencyElement) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "jobName"),
+ new ScalarNode(Tag.STR, jobDependencyElement.elementText("jobName").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "requireSuccessful"),
+ new ScalarNode(Tag.STR, jobDependencyElement.elementText("requireSuccessful").trim())));
+ Element artifactsElement = jobDependencyElement.element("artifacts");
+ if (artifactsElement != null) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "artifacts"),
+ new ScalarNode(Tag.STR, artifactsElement.getText().trim())));
+ }
+
+ List<Node> paramSupplyNodes = migrateParamSupplies(jobDependencyElement.element("jobParams").elements());
+ if (!paramSupplyNodes.isEmpty()) {
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "jobParams"),
+ new SequenceNode(Tag.SEQ, paramSupplyNodes, FlowStyle.BLOCK)));
+ }
+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ }
+
+ private static List<Node> migrateParamSupplies(List<Element> paramSupplyElements) {
+ List<Node> paramSupplyNodes = new ArrayList<>();
+ for (Element paramSupplyElement: paramSupplyElements) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "name"),
+ new ScalarNode(Tag.STR, paramSupplyElement.elementText("name").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "secret"),
+ new ScalarNode(Tag.STR, paramSupplyElement.elementText("secret").trim())));
+
+ Element valuesProviderElement = paramSupplyElement.element("valuesProvider");
+ String classTag = getClassTag(valuesProviderElement.attributeValue("class"));
+ List<NodeTuple> valuesProviderTuples = new ArrayList<>();
+ Element scriptNameElement = valuesProviderElement.element("scriptName");
+ if (scriptNameElement != null) {
+ valuesProviderTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "scriptName"),
+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));
+ }
+ Element valuesElement = valuesProviderElement.element("values");
+ if (valuesElement != null) {
+ List<Node> listNodes = new ArrayList<>();
+ for (Element listElement: valuesElement.elements()) {
+ List<Node> listItemNodes = new ArrayList<>();
+ for (Element listItemElement: listElement.elements())
+ listItemNodes.add(new ScalarNode(Tag.STR, listItemElement.getText().trim()));
+ listNodes.add(new SequenceNode(Tag.SEQ, listItemNodes, FlowStyle.BLOCK));
+ }
+ valuesProviderTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "values"),
+ new SequenceNode(Tag.SEQ, listNodes, FlowStyle.BLOCK)));
+ }
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "valuesProvider"),
+ new MappingNode(new Tag(classTag), valuesProviderTuples, FlowStyle.BLOCK)));
+ paramSupplyNodes.add(new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK));
+ }
+ return paramSupplyNodes;
+ }
+
+ private static List<Node> migrateFieldSupplies(List<Element> fieldSupplyElements) {
+ List<Node> fieldSupplyNodes = new ArrayList<>();
+ for (Element fieldSupplyElement: fieldSupplyElements) {
+ List<NodeTuple> tuples = new ArrayList<>();
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "name"),
+ new ScalarNode(Tag.STR, fieldSupplyElement.elementText("name").trim())));
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "secret"),
+ new ScalarNode(Tag.STR, fieldSupplyElement.elementText("secret").trim())));
+
+ Element valueProviderElement = fieldSupplyElement.element("valueProvider");
+ String classTag = getClassTag(valueProviderElement.attributeValue("class"));
+ List<NodeTuple> valueProviderTuples = new ArrayList<>();
+ Element scriptNameElement = valueProviderElement.element("scriptName");
+ if (scriptNameElement != null) {
+ valueProviderTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "scriptName"),
+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));
+ }
+ Element valueElement = valueProviderElement.element("value");
+ if (valueElement != null) {
+ List<Node> valueItemNodes = new ArrayList<>();
+ for (Element valueItemElement: valueElement.elements())
+ valueItemNodes.add(new ScalarNode(Tag.STR, valueItemElement.getText().trim()));
+ valueProviderTuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "value"),
+ new SequenceNode(Tag.SEQ, valueItemNodes, FlowStyle.BLOCK)));
+ }
+
+ tuples.add(new NodeTuple(
+ new ScalarNode(Tag.STR, "valueProvider"),
+ new MappingNode(new Tag(classTag), valueProviderTuples, FlowStyle.BLOCK)));
+ fieldSupplyNodes.add(new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK));
+ }
+ return fieldSupplyNodes;
+ }
+
+ public static String migrate(String xml) {
+ Document xmlDoc;
+ try {
+ xmlDoc = new SAXReader().read(new StringReader(xml));
+ } catch (DocumentException e) {
+ throw new RuntimeException(e);
+ }
+
+ List<NodeTuple> tuples = new ArrayList<>();
+ Node keyNode = new ScalarNode(Tag.STR, "version");
+ Node valueNode = new ScalarNode(Tag.INT, "0");
+ tuples.add(new NodeTuple(keyNode, valueNode));
+
+ List<Node> jobNodes = new ArrayList<>();
+ for (Element jobElement: xmlDoc.getRootElement().element("jobs").elements())
+ jobNodes.add(migrateJob(jobElement));
+
+ if (!jobNodes.isEmpty()) {
+ keyNode = new ScalarNode(Tag.STR, "jobs");
+ tuples.add(new NodeTuple(keyNode, new SequenceNode(Tag.SEQ, jobNodes, FlowStyle.BLOCK)));
+ }
+
+ List<Node> propertyNodes = new ArrayList<>();
+ Element propertiesElement = xmlDoc.getRootElement().element("properties");
+ if (propertiesElement != null) {
+ for (Element propertyElement: propertiesElement.elements()) {
+ Node nameNode = new ScalarNode(Tag.STR, propertyElement.elementText("name").trim());
+ valueNode = new ScalarNode(Tag.STR, propertyElement.elementText("value").trim());
+ List<NodeTuple> propertyTuples = Lists.newArrayList(
+ new NodeTuple(new ScalarNode(Tag.STR, "name"), nameNode),
+ new NodeTuple(new ScalarNode(Tag.STR, "value"), valueNode));
+ propertyNodes.add(new MappingNode(Tag.MAP, propertyTuples, FlowStyle.BLOCK));
+ }
+ }
+ if(!propertyNodes.isEmpty()) {
+ keyNode = new ScalarNode(Tag.STR, "properties");
+ tuples.add(new NodeTuple(keyNode, new SequenceNode(Tag.SEQ, propertyNodes, FlowStyle.BLOCK)));
+ }
+
+ MappingNode rootNode = new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);
+ StringWriter writer = new StringWriter();
+ DumperOptions dumperOptions = new DumperOptions();
+ Serializer serializer = new Serializer(new Emitter(writer, dumperOptions),
+ new Resolver(), dumperOptions, Tag.MAP);
+ try {
+ serializer.open();
+ serializer.serialize(rootNode);
+ serializer.close();
+ return writer.toString();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+
+ }
+}
diff --git a/server-core/src/main/java/io/onedev/server/model/Project.java b/server-core/src/main/java/io/onedev/server/model/Project.java
index 69a282fa85..aab8ecfa94 100644
--- a/server-core/src/main/java/io/onedev/server/model/Project.java
+++ b/server-core/src/main/java/io/onedev/server/model/Project.java
@@ -695,10 +695,15 @@ public class Project extends AbstractEntity {
Optional<BuildSpec> buildSpec = buildSpecCache.get(commitId);
if (buildSpec == null) {
Blob blob = getBlob(new BlobIdent(commitId.name(), BuildSpec.BLOB_PATH, FileMode.TYPE_FILE), false);
- if (blob != null)
+ if (blob != null) {
buildSpec = Optional.fromNullable(BuildSpec.parse(blob.getBytes()));
- else
- buildSpec = Optional.absent();
+ } else {
+ Blob oldBlob = getBlob(new BlobIdent(commitId.name(), ".onedev-buildspec", FileMode.TYPE_FILE), false);
+ if (oldBlob != null)
+ buildSpec = Optional.fromNullable(BuildSpec.parse(oldBlob.getBytes()));
+ else
+ buildSpec = Optional.absent();
+ }
buildSpecCache.put(commitId, buildSpec);
}
return buildSpec.orNull();
diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java
index df349eb67b..9093cdf02b 100755
--- a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java
+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java
@@ -15,7 +15,7 @@ import io.onedev.server.util.inputspec.choiceinput.choiceprovider.ChoiceProvider
import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.editable.annotation.OmitName;
-@Editable(order=100, name="Specified default value")
+@Editable(order=100, name="Use specified default value")
public class SpecifiedDefaultMultiValue implements DefaultMultiValueProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
index ddf6a2a9bd..eb8ea02e1b 100755
--- a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
@@ -13,7 +13,7 @@ import io.onedev.server.util.inputspec.choiceinput.choiceprovider.ChoiceProvider
import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.editable.annotation.OmitName;
-@Editable(order=100, name="Specified default value")
+@Editable(order=100, name="Use specified default value")
public class SpecifiedDefaultValue implements DefaultValueProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
index 078a6cc9c7..d348348546 100755
--- a/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
@@ -16,7 +16,7 @@ import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.editable.annotation.GroupChoice;
import io.onedev.server.web.editable.annotation.OmitName;
-@Editable(order=100, name="Specified default value")
+@Editable(order=100, name="Use specified default value")
public class SpecifiedDefaultValue implements DefaultValueProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java
index 906d5355f5..f536f86bb5 100755
--- a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java
+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java
@@ -12,7 +12,7 @@ import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.page.project.issues.detail.IssueDetailPage;
import io.onedev.server.web.util.WicketUtils;
-@Editable(order=130, name="All users in system")
+@Editable(order=130, name="All users")
public class AllUsers implements ChoiceProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java
index ebd91e1708..51625dc571 100755
--- a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java
+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java
@@ -15,7 +15,7 @@ import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.editable.annotation.OmitName;
import io.onedev.server.web.editable.annotation.UserChoice;
-@Editable(order=100, name="Specified default value")
+@Editable(order=100, name="Use specified default value")
public class SpecifiedDefaultMultiValue implements DefaultMultiValueProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
index 9949880684..93ea784b9a 100755
--- a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java
@@ -11,7 +11,7 @@ import io.onedev.server.web.editable.annotation.Editable;
import io.onedev.server.web.editable.annotation.OmitName;
import io.onedev.server.web.editable.annotation.UserChoice;
-@Editable(order=100, name="Specified default value")
+@Editable(order=100, name="Use specified default value")
public class SpecifiedDefaultValue implements DefaultValueProvider {
private static final long serialVersionUID = 1L;
diff --git a/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java b/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java
index a7de223fac..8224c40a2a 100644
--- a/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java
+++ b/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java
@@ -46,6 +46,8 @@ public abstract class JobDefLink extends BookmarkablePageLink<Void> {
public PageParameters getPageParameters() {
ProjectBlobPage.State state = new ProjectBlobPage.State();
state.blobIdent = new BlobIdent(commitId.name(), BuildSpec.BLOB_PATH, FileMode.REGULAR_FILE.getBits());
+ if (getProject().getBlob(state.blobIdent, false) == null)
+ state.blobIdent = new BlobIdent(commitId.name(), ".onedev-buildspec", FileMode.REGULAR_FILE.getBits());
state.position = BuildSpecRendererProvider.getPosition(Job.SELECTION_PREFIX + jobName);
return ProjectBlobPage.paramsOf(getProject(), state);
}
diff --git a/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java b/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java
index e04f7486dd..dc15aefe00 100644
--- a/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java
+++ b/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java
@@ -6,6 +6,7 @@ import org.apache.wicket.Component;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.model.IModel;
+import io.onedev.server.util.DateUtils;
import io.onedev.server.web.editable.EditSupport;
import io.onedev.server.web.editable.EmptyValueLabel;
import io.onedev.server.web.editable.PropertyContext;
@@ -32,7 +33,7 @@ public class DateEditSupport implements EditSupport {
@Override
protected Component newContent(String id, PropertyDescriptor propertyDescriptor) {
if (model.getObject() != null) {
- return new Label(id, model.getObject());
+ return new Label(id, DateUtils.formatDate(model.getObject()));
} else {
NameOfEmptyValue nameOfEmptyValue = propertyDescriptor.getPropertyGetter().getAnnotation(NameOfEmptyValue.class);
if (nameOfEmptyValue != null)
diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java
index 16305535b2..b5d4f1256a 100644
--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java
+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java
@@ -784,8 +784,9 @@ public class ProjectBlobPage extends ProjectPage implements BlobRenderContext, S
protected void onConfigure() {
super.onConfigure();
if (resolvedRevision != null && isOnBranch() && state.blobIdent.path == null && state.mode == Mode.VIEW) {
+ BlobIdent oldBlobIdent = new BlobIdent(resolvedRevision.name(), ".onedev-buildspec", FileMode.TYPE_FILE);
BlobIdent blobIdent = new BlobIdent(resolvedRevision.name(), BuildSpec.BLOB_PATH, FileMode.TYPE_FILE);
- setVisible(getProject().getBlob(blobIdent, false) == null);
+ setVisible(getProject().getBlob(blobIdent, false) == null && getProject().getBlob(oldBlobIdent, false) == null);
} else {
setVisible(false);
}
diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java
index 8d8a9ceb93..8392ff5a19 100644
--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java
+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java
@@ -39,6 +39,7 @@ import org.eclipse.jgit.lib.FileMode;
import com.google.common.base.Splitter;
import io.onedev.commons.utils.StringUtils;
+import io.onedev.server.buildspec.BuildSpec;
import io.onedev.server.git.BlobIdent;
import io.onedev.server.git.BlobIdentFilter;
import io.onedev.server.git.GitUtils;
@@ -254,6 +255,8 @@ public class BlobNavigator extends Panel {
name = context.getInitialNewPath();
else if (file.path.contains("/"))
name = StringUtils.substringAfterLast(file.path, "/");
+ else if (file.path.equals(".onedev-buildspec"))
+ name = BuildSpec.BLOB_PATH;
else
name = file.path;
diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js
index cacb9e7816..1a50f72295 100644
--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js
+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js
@@ -6,11 +6,10 @@ onedev.server.plainEdit = {
var cm = CodeMirror($source[0], {
value: $plainEdit.children(".input").val(),
theme: "eclipse",
- indentWithTabs: true,
+ indentWithTabs: false,
indentUnit: 4,
lineNumbers: true,
lineWrapping: true,
- tabSize: 4,
styleActiveLine: true,
styleSelectedText: true,
foldGutter: true,
diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java
index bf6b736bb0..dfefb702ea 100644
--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java
+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java
@@ -20,7 +20,7 @@ public class BuildSpecRendererProvider implements BlobRendererContribution {
private static final String POSITION_PREFIX = "buildspec-";
private boolean isBuildSpec(@Nullable String blobPath) {
- return BuildSpec.BLOB_PATH.equals(blobPath);
+ return BuildSpec.BLOB_PATH.equals(blobPath) || ".onedev-buildspec".equals(blobPath);
}
@Nullable
diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java
index 10885d3858..427590d3df 100644
--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java
+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java
@@ -99,8 +99,14 @@ public class FolderViewPanel extends Panel {
Collections.sort(children);
+ BlobIdent oldBuildSpecIdent = new BlobIdent(context.getBlobIdent().revision,
+ ".onedev-buildspec", FileMode.REGULAR_FILE.getBits());
BlobIdent buildSpecIdent = new BlobIdent(context.getBlobIdent().revision,
BuildSpec.BLOB_PATH, FileMode.REGULAR_FILE.getBits());
+ if (children.contains(oldBuildSpecIdent)) {
+ children.remove(oldBuildSpecIdent);
+ children.add(0, oldBuildSpecIdent);
+ }
if (children.contains(buildSpecIdent)) {
children.remove(buildSpecIdent);
children.add(0, buildSpecIdent);
@@ -210,7 +216,7 @@ public class FolderViewPanel extends Panel {
iconClass = "fa fa-ext fa-folder-submodule-o";
else if (blobIdent.isSymbolLink())
iconClass = "fa fa-ext fa-folder-symbol-link-o";
- else if (blobIdent.path.equals(BuildSpec.BLOB_PATH))
+ else if (blobIdent.path.equals(BuildSpec.BLOB_PATH) || blobIdent.path.equals(".onedev-buildspec"))
iconClass = "fa fa-cog";
else
iconClass = "fa fa-file-text-o";
@@ -220,7 +226,7 @@ public class FolderViewPanel extends Panel {
if (context.getBlobIdent().path != null)
pathLink.add(new Label("label", blobIdent.path.substring(context.getBlobIdent().path.length()+1)));
- else if (blobIdent.path.equals(BuildSpec.BLOB_PATH))
+ else if (blobIdent.path.equals(BuildSpec.BLOB_PATH) || blobIdent.path.equals(".onedev-buildspec"))
pathLink.add(new Label("label", "<b>" + HtmlEscape.escapeHtml5(blobIdent.path) + "</b>").setEscapeModelStrings(false));
else
pathLink.add(new Label("label", blobIdent.path));
diff --git a/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java b/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java
index def47f7a0a..40cc1a127a 100644
--- a/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java
+++ b/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java
@@ -33,6 +33,5 @@ public class TestPage extends BasePage {
super.renderHead(response);
response.render(JavaScriptHeaderItem.forReference(new TestResourceReference()));
response.render(OnDomReadyHeaderItem.forScript("onedev.server.test.onDomReady();"));
- }
-
+ }
}
diff --git a/server-core/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java b/server-core/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java
new file mode 100644
index 0000000000..8e00a0e33f
--- /dev/null
+++ b/server-core/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java
@@ -0,0 +1,595 @@
+/**
+ * Copyright (c) 2008, http://www.snakeyaml.org
+ *
+ * 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
+ *
+ * http://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.
+ */
+package org.yaml.snakeyaml.constructor;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import org.yaml.snakeyaml.TypeDescription;
+import org.yaml.snakeyaml.composer.Composer;
+import org.yaml.snakeyaml.composer.ComposerException;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.introspector.PropertyUtils;
+import org.yaml.snakeyaml.nodes.CollectionNode;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeId;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+import org.yaml.snakeyaml.nodes.Tag;
+
+import io.onedev.server.util.BeanUtils;
+import io.onedev.server.web.editable.annotation.Editable;
+
+public abstract class BaseConstructor {
+ /**
+ * It maps the node kind to the the Construct implementation. When the
+ * runtime class is known then the implicit tag is ignored.
+ */
+ protected final Map<NodeId, Construct> yamlClassConstructors = new EnumMap<NodeId, Construct>(
+ NodeId.class);
+ /**
+ * It maps the (explicit or implicit) tag to the Construct implementation.
+ * It is used:
+ * 1) explicit tag - if present.
+ * 2) implicit tag - when the runtime class of the instance is unknown (the
+ * node has the Object.class)
+ */
+ protected final Map<Tag, Construct> yamlConstructors = new HashMap<Tag, Construct>();
+ /**
+ * It maps the (explicit or implicit) tag to the Construct implementation.
+ * It is used when no exact match found.
+ */
+ protected final Map<String, Construct> yamlMultiConstructors = new HashMap<String, Construct>();
+
+ protected Composer composer;
+ final Map<Node, Object> constructedObjects;
+ private final Set<Node> recursiveObjects;
+ private final ArrayList<RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>>> maps2fill;
+ private final ArrayList<RecursiveTuple<Set<Object>, Object>> sets2fill;
+
+ protected Tag rootTag;
+ private PropertyUtils propertyUtils;
+ private boolean explicitPropertyUtils;
+ private boolean allowDuplicateKeys = true;
+
+ protected final Map<Class<? extends Object>, TypeDescription> typeDefinitions;
+ protected final Map<Tag, Class<? extends Object>> typeTags;
+
+ public BaseConstructor() {
+ constructedObjects = new HashMap<Node, Object>();
+ recursiveObjects = new HashSet<Node>();
+ maps2fill = new ArrayList<RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>>>();
+ sets2fill = new ArrayList<RecursiveTuple<Set<Object>, Object>>();
+ typeDefinitions = new HashMap<Class<? extends Object>, TypeDescription>();
+ typeTags = new HashMap<Tag, Class<? extends Object>>();
+
+ rootTag = null;
+ explicitPropertyUtils = false;
+
+ typeDefinitions.put(SortedMap.class, new TypeDescription(SortedMap.class, Tag.OMAP,
+ TreeMap.class));
+ typeDefinitions.put(SortedSet.class, new TypeDescription(SortedSet.class, Tag.SET,
+ TreeSet.class));
+ }
+
+ public void setComposer(Composer composer) {
+ this.composer = composer;
+ }
+
+ /**
+ * Check if more documents available
+ *
+ * @return true when there are more YAML documents in the stream
+ */
+ public boolean checkData() {
+ // If there are more documents available?
+ return composer.checkNode();
+ }
+
+ /**
+ * Construct and return the next document
+ *
+ * @return constructed instance
+ */
+ public Object getData() {
+ // Construct and return the next document.
+ composer.checkNode();
+ Node node = composer.getNode();
+ if (rootTag != null) {
+ node.setTag(rootTag);
+ }
+ return constructDocument(node);
+ }
+
+ /**
+ * Ensure that the stream contains a single document and construct it
+ *
+ * @param type the class of the instance being created
+ * @return constructed instance
+ * @throws ComposerException in case there are more documents in the stream
+ */
+ public Object getSingleData(Class<?> type) {
+ // Ensure that the stream contains a single document and construct it
+ Node node = composer.getSingleNode();
+ if (node != null && !Tag.NULL.equals(node.getTag())) {
+ if (Object.class != type) {
+ node.setTag(new Tag(type));
+ } else if (rootTag != null) {
+ node.setTag(rootTag);
+ }
+ return constructDocument(node);
+ }
+ return null;
+ }
+
+ /**
+ * Construct complete YAML document. Call the second step in case of
+ * recursive structures. At the end cleans all the state.
+ *
+ * @param node root Node
+ * @return Java instance
+ */
+ protected final Object constructDocument(Node node) {
+ Object data = constructObject(node);
+ fillRecursive();
+ constructedObjects.clear();
+ recursiveObjects.clear();
+ return data;
+ }
+
+ private void fillRecursive() {
+ if (!maps2fill.isEmpty()) {
+ for (RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>> entry : maps2fill) {
+ RecursiveTuple<Object, Object> key_value = entry._2();
+ entry._1().put(key_value._1(), key_value._2());
+ }
+ maps2fill.clear();
+ }
+ if (!sets2fill.isEmpty()) {
+ for (RecursiveTuple<Set<Object>, Object> value : sets2fill) {
+ value._1().add(value._2());
+ }
+ sets2fill.clear();
+ }
+ }
+
+ /**
+ * Construct object from the specified Node. Return existing instance if the
+ * node is already constructed.
+ *
+ * @param node Node to be constructed
+ * @return Java instance
+ */
+ protected Object constructObject(Node node) {
+ if (constructedObjects.containsKey(node)) {
+ return constructedObjects.get(node);
+ }
+ return constructObjectNoCheck(node);
+ }
+
+ protected Object constructObjectNoCheck(Node node) {
+ if (recursiveObjects.contains(node)) {
+ throw new ConstructorException(null, null, "found unconstructable recursive node",
+ node.getStartMark());
+ }
+ recursiveObjects.add(node);
+ Construct constructor = getConstructor(node);
+ Object data = (constructedObjects.containsKey(node)) ? constructedObjects.get(node)
+ : constructor.construct(node);
+
+ finalizeConstruction(node, data);
+ constructedObjects.put(node, data);
+ recursiveObjects.remove(node);
+ if (node.isTwoStepsConstruction()) {
+ constructor.construct2ndStep(node, data);
+ }
+ return data;
+ }
+
+ /**
+ * Get the constructor to construct the Node. For implicit tags if the
+ * runtime class is known a dedicated Construct implementation is used.
+ * Otherwise the constructor is chosen by the tag.
+ *
+ * @param node {@link Node} to construct an instance from
+ * @return {@link Construct} implementation for the specified node
+ */
+ protected Construct getConstructor(Node node) {
+ if (node.useClassConstructor()) {
+ return yamlClassConstructors.get(node.getNodeId());
+ } else {
+ Construct constructor = yamlConstructors.get(node.getTag());
+ if (constructor == null) {
+ for (String prefix : yamlMultiConstructors.keySet()) {
+ if (node.getTag().startsWith(prefix)) {
+ return yamlMultiConstructors.get(prefix);
+ }
+ }
+ return yamlConstructors.get(null);
+ }
+ return constructor;
+ }
+ }
+
+ protected String constructScalar(ScalarNode node) {
+ return node.getValue();
+ }
+
+ // >>>> DEFAULTS >>>>
+ protected List<Object> createDefaultList(int initSize) {
+ return new ArrayList<Object>(initSize);
+ }
+
+ protected Set<Object> createDefaultSet(int initSize) {
+ return new LinkedHashSet<Object>(initSize);
+ }
+
+ protected Map<Object, Object> createDefaultMap(int initSize) {
+ // respect order from YAML document
+ return new LinkedHashMap<Object, Object>(initSize);
+ }
+
+ protected Object createArray(Class<?> type, int size) {
+ return Array.newInstance(type.getComponentType(), size);
+ }
+
+ // <<<< DEFAULTS <<<<
+
+ protected Object finalizeConstruction(Node node, Object data) {
+ final Class<? extends Object> type = node.getType();
+ if (typeDefinitions.containsKey(type)) {
+ return typeDefinitions.get(type).finalizeConstruction(data);
+ }
+ return data;
+ }
+
+ // >>>> NEW instance
+ protected Object newInstance(Node node) {
+ try {
+ return newInstance(Object.class, node);
+ } catch (InstantiationException e) {
+ throw new YAMLException(e);
+ }
+ }
+
+ final protected Object newInstance(Class<?> ancestor, Node node) throws InstantiationException {
+ return newInstance(ancestor, node, true);
+ }
+
+ protected Object newInstance(Class<?> ancestor, Node node, boolean tryDefault)
+ throws InstantiationException {
+ final Class<? extends Object> type = node.getType();
+ if (typeDefinitions.containsKey(type)) {
+ TypeDescription td = typeDefinitions.get(type);
+ final Object instance = td.newInstance(node);
+ if (instance != null) {
+ return instance;
+ }
+ }
+ if (tryDefault) {
+ /*
+ * Removed <code> have InstantiationException in case of abstract
+ * type
+ */
+ if (ancestor.isAssignableFrom(type) && !Modifier.isAbstract(type.getModifiers())) {
+ try {
+ java.lang.reflect.Constructor<?> c = type.getDeclaredConstructor();
+ c.setAccessible(true);
+ Object instance = c.newInstance();
+ if (type.getAnnotation(Editable.class) != null) {
+ for (Method getter: BeanUtils.findGetters(type)) {
+ if (getter.getAnnotation(Editable.class) != null) {
+ Method setter = BeanUtils.findSetter(getter);
+ if (setter != null) {
+ if (Collection.class.isAssignableFrom(getter.getReturnType()))
+ setter.invoke(instance, new Object[] {new ArrayList<>()});
+ else if (Map.class.isAssignableFrom(getter.getReturnType()))
+ setter.invoke(instance, new Object[] {new LinkedHashMap<>()});
+ else if (Object.class.isAssignableFrom(getter.getReturnType()))
+ setter.invoke(instance, new Object[] {null});
+ }
+ }
+ }
+ }
+ return instance;
+ } catch (NoSuchMethodException e) {
+ throw new InstantiationException("NoSuchMethodException:"
+ + e.getLocalizedMessage());
+ } catch (Exception e) {
+ throw new YAMLException(e);
+ }
+ }
+ }
+ throw new InstantiationException();
+ }
+
+ @SuppressWarnings("unchecked")
+ protected Set<Object> newSet(CollectionNode<?> node) {
+ try {
+ return (Set<Object>) newInstance(Set.class, node);
+ } catch (InstantiationException e) {
+ return createDefaultSet(node.getValue().size());
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ protected List<Object> newList(SequenceNode node) {
+ try {
+ return (List<Object>) newInstance(List.class, node);
+ } catch (InstantiationException e) {
+ return createDefaultList(node.getValue().size());
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ protected Map<Object, Object> newMap(MappingNode node) {
+ try {
+ return (Map<Object, Object>) newInstance(Map.class, node);
+ } catch (InstantiationException e) {
+ return createDefaultMap(node.getValue().size());
+ }
+ }
+
+ // <<<< NEW instance
+
+ // >>>> Construct => NEW, 2ndStep(filling)
+ protected List<? extends Object> constructSequence(SequenceNode node) {
+ List<Object> result = newList(node);
+ constructSequenceStep2(node, result);
+ return result;
+ }
+
+ protected Set<? extends Object> constructSet(SequenceNode node) {
+ Set<Object> result = newSet(node);
+ constructSequenceStep2(node, result);
+ return result;
+ }
+
+ protected Object constructArray(SequenceNode node) {
+ return constructArrayStep2(node, createArray(node.getType(), node.getValue().size()));
+ }
+
+ protected void constructSequenceStep2(SequenceNode node, Collection<Object> collection) {
+ for (Node child : node.getValue()) {
+ collection.add(constructObject(child));
+ }
+ }
+
+ protected Object constructArrayStep2(SequenceNode node, Object array) {
+ final Class<?> componentType = node.getType().getComponentType();
+
+ int index = 0;
+ for (Node child : node.getValue()) {
+ // Handle multi-dimensional arrays...
+ if (child.getType() == Object.class) {
+ child.setType(componentType);
+ }
+
+ final Object value = constructObject(child);
+
+ if (componentType.isPrimitive()) {
+ // Null values are disallowed for primitives
+ if (value == null) {
+ throw new NullPointerException(
+ "Unable to construct element value for " + child);
+ }
+
+ // Primitive arrays require quite a lot of work.
+ if (byte.class.equals(componentType)) {
+ Array.setByte(array, index, ((Number) value).byteValue());
+
+ } else if (short.class.equals(componentType)) {
+ Array.setShort(array, index, ((Number) value).shortValue());
+
+ } else if (int.class.equals(componentType)) {
+ Array.setInt(array, index, ((Number) value).intValue());
+
+ } else if (long.class.equals(componentType)) {
+ Array.setLong(array, index, ((Number) value).longValue());
+
+ } else if (float.class.equals(componentType)) {
+ Array.setFloat(array, index, ((Number) value).floatValue());
+
+ } else if (double.class.equals(componentType)) {
+ Array.setDouble(array, index, ((Number) value).doubleValue());
+
+ } else if (char.class.equals(componentType)) {
+ Array.setChar(array, index, ((Character) value).charValue());
+
+ } else if (boolean.class.equals(componentType)) {
+ Array.setBoolean(array, index, ((Boolean) value).booleanValue());
+
+ } else {
+ throw new YAMLException("unexpected primitive type");
+ }
+
+ } else {
+ // Non-primitive arrays can simply be assigned:
+ Array.set(array, index, value);
+ }
+
+ ++index;
+ }
+ return array;
+ }
+
+ protected Set<Object> constructSet(MappingNode node) {
+ final Set<Object> set = newSet(node);
+ constructSet2ndStep(node, set);
+ return set;
+ }
+
+ protected Map<Object, Object> constructMapping(MappingNode node) {
+ final Map<Object, Object> mapping = newMap(node);
+ constructMapping2ndStep(node, mapping);
+ return mapping;
+ }
+
+ protected void constructMapping2ndStep(MappingNode node, Map<Object, Object> mapping) {
+ List<NodeTuple> nodeValue = node.getValue();
+ for (NodeTuple tuple : nodeValue) {
+ Node keyNode = tuple.getKeyNode();
+ Node valueNode = tuple.getValueNode();
+ Object key = constructObject(keyNode);
+ if (key != null) {
+ try {
+ key.hashCode();// check circular dependencies
+ } catch (Exception e) {
+ throw new ConstructorException("while constructing a mapping",
+ node.getStartMark(), "found unacceptable key " + key,
+ tuple.getKeyNode().getStartMark(), e);
+ }
+ }
+ Object value = constructObject(valueNode);
+ if (keyNode.isTwoStepsConstruction()) {
+ /*
+ * if keyObject is created it 2 steps we should postpone putting
+ * it in map because it may have different hash after
+ * initialization compared to clean just created one. And map of
+ * course does not observe key hashCode changes.
+ */
+ maps2fill.add(0,
+ new RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>>(
+ mapping, new RecursiveTuple<Object, Object>(key, value)));
+ } else {
+ mapping.put(key, value);
+ }
+ }
+ }
+
+ protected void constructSet2ndStep(MappingNode node, Set<Object> set) {
+ List<NodeTuple> nodeValue = node.getValue();
+ for (NodeTuple tuple : nodeValue) {
+ Node keyNode = tuple.getKeyNode();
+ Object key = constructObject(keyNode);
+ if (key != null) {
+ try {
+ key.hashCode();// check circular dependencies
+ } catch (Exception e) {
+ throw new ConstructorException("while constructing a Set", node.getStartMark(),
+ "found unacceptable key " + key, tuple.getKeyNode().getStartMark(), e);
+ }
+ }
+ if (keyNode.isTwoStepsConstruction()) {
+ /*
+ * if keyObject is created it 2 steps we should postpone putting
+ * it into the set because it may have different hash after
+ * initialization compared to clean just created one. And set of
+ * course does not observe value hashCode changes.
+ */
+ sets2fill.add(0, new RecursiveTuple<Set<Object>, Object>(set, key));
+ } else {
+ set.add(key);
+ }
+ }
+ }
+
+ // <<<< Costruct => NEW, 2ndStep(filling)
+
+ // TODO protected List<Object[]> constructPairs(MappingNode node) {
+ // List<Object[]> pairs = new LinkedList<Object[]>();
+ // List<Node[]> nodeValue = (List<Node[]>) node.getValue();
+ // for (Iterator<Node[]> iter = nodeValue.iterator(); iter.hasNext();) {
+ // Node[] tuple = iter.next();
+ // Object key = constructObject(Object.class, tuple[0]);
+ // Object value = constructObject(Object.class, tuple[1]);
+ // pairs.add(new Object[] { key, value });
+ // }
+ // return pairs;
+ // }
+
+ public void setPropertyUtils(PropertyUtils propertyUtils) {
+ this.propertyUtils = propertyUtils;
+ explicitPropertyUtils = true;
+ Collection<TypeDescription> tds = typeDefinitions.values();
+ for (TypeDescription typeDescription : tds) {
+ typeDescription.setPropertyUtils(propertyUtils);
+ }
+ }
+
+ public final PropertyUtils getPropertyUtils() {
+ if (propertyUtils == null) {
+ propertyUtils = new PropertyUtils();
+ }
+ return propertyUtils;
+ }
+
+ /**
+ * Make YAML aware how to parse a custom Class. If there is no root Class
+ * assigned in constructor then the 'root' property of this definition is
+ * respected.
+ *
+ * @param definition to be added to the Constructor
+ * @return the previous value associated with <tt>definition</tt>, or
+ * <tt>null</tt> if there was no mapping for <tt>definition</tt>.
+ */
+ public TypeDescription addTypeDescription(TypeDescription definition) {
+ if (definition == null) {
+ throw new NullPointerException("TypeDescription is required.");
+ }
+ Tag tag = definition.getTag();
+ typeTags.put(tag, definition.getType());
+ definition.setPropertyUtils(getPropertyUtils());
+ return typeDefinitions.put(definition.getType(), definition);
+ }
+
+ private static class RecursiveTuple<T, K> {
+ private final T _1;
+ private final K _2;
+
+ public RecursiveTuple(T _1, K _2) {
+ this._1 = _1;
+ this._2 = _2;
+ }
+
+ public K _2() {
+ return _2;
+ }
+
+ public T _1() {
+ return _1;
+ }
+ }
+
+ public final boolean isExplicitPropertyUtils() {
+ return explicitPropertyUtils;
+ }
+
+ public boolean isAllowDuplicateKeys() {
+ return allowDuplicateKeys;
+ }
+
+ public void setAllowDuplicateKeys(boolean allowDuplicateKeys) {
+ this.allowDuplicateKeys = allowDuplicateKeys;
+ }
+}
diff --git a/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java b/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java
index f38faa695b..2dc1de1318 100644
--- a/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java
+++ b/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java
@@ -16,6 +16,7 @@
package org.yaml.snakeyaml.nodes;
import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.ScalarStyle;
import org.yaml.snakeyaml.error.Mark;
/**
@@ -28,6 +29,10 @@ public class ScalarNode extends Node {
private DumperOptions.ScalarStyle style;
private String value;
+ public ScalarNode(Tag tag, String value) {
+ this(tag, value, null, null, ScalarStyle.PLAIN);
+ }
+
public ScalarNode(Tag tag, String value, Mark startMark, Mark endMark, DumperOptions.ScalarStyle style) {
this(tag, true, value, startMark, endMark, style);
}
diff --git a/server-core/src/main/java/org/yaml/snakeyaml/representer/Representer.java b/server-core/src/main/java/org/yaml/snakeyaml/representer/Representer.java
new file mode 100644
index 0000000000..42eb415642
--- /dev/null
+++ b/server-core/src/main/java/org/yaml/snakeyaml/representer/Representer.java
@@ -0,0 +1,274 @@
+/**
+ * Copyright (c) 2008, http://www.snakeyaml.org
+ *
+ * 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
+ *
+ * http://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.
+ */
+package org.yaml.snakeyaml.representer;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.FlowStyle;
+import org.yaml.snakeyaml.TypeDescription;
+import org.yaml.snakeyaml.introspector.Property;
+import org.yaml.snakeyaml.introspector.PropertyUtils;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.NodeId;
+import org.yaml.snakeyaml.nodes.NodeTuple;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+import org.yaml.snakeyaml.nodes.Tag;
+
+/**
+ * Represent JavaBeans
+ */
+public class Representer extends SafeRepresenter {
+
+ protected Map<Class<? extends Object>, TypeDescription> typeDefinitions = Collections
+ .emptyMap();
+
+ public Representer() {
+ this.representers.put(null, new RepresentJavaBean());
+ }
+
+ public TypeDescription addTypeDescription(TypeDescription td) {
+ if (Collections.EMPTY_MAP == typeDefinitions) {
+ typeDefinitions = new HashMap<Class<? extends Object>, TypeDescription>();
+ }
+ if (td.getTag() != null) {
+ addClassTag(td.getType(), td.getTag());
+ }
+ td.setPropertyUtils(getPropertyUtils());
+ return typeDefinitions.put(td.getType(), td);
+ }
+
+ @Override
+ public void setPropertyUtils(PropertyUtils propertyUtils) {
+ super.setPropertyUtils(propertyUtils);
+ Collection<TypeDescription> tds = typeDefinitions.values();
+ for (TypeDescription typeDescription : tds) {
+ typeDescription.setPropertyUtils(propertyUtils);
+ }
+ }
+
+ protected class RepresentJavaBean implements Represent {
+ public Node representData(Object data) {
+ return representJavaBean(getProperties(data.getClass()), data);
+ }
+ }
+
+ /**
+ * Tag logic:
+ * - explicit root tag is set in serializer
+ * - if there is a predefined class tag it is used
+ * - a global tag with class name is always used as tag. The JavaBean parent
+ * of the specified JavaBean may set another tag (tag:yaml.org,2002:map)
+ * when the property class is the same as runtime class
+ *
+ * @param properties
+ * JavaBean getters
+ * @param javaBean
+ * instance for Node
+ * @return Node to get serialized
+ */
+ protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {
+ List<NodeTuple> value = new ArrayList<NodeTuple>(properties.size());
+ Tag tag;
+ Tag customTag = classTags.get(javaBean.getClass());
+ tag = customTag != null ? customTag : new Tag("!" + javaBean.getClass().getSimpleName());
+ // flow style will be chosen by BaseRepresenter
+ MappingNode node = new MappingNode(tag, value, FlowStyle.AUTO);
+ representedObjects.put(javaBean, node);
+ DumperOptions.FlowStyle bestStyle = FlowStyle.FLOW;
+ for (Property property : properties) {
+ Object memberValue = property.get(javaBean);
+ Tag customPropertyTag = memberValue == null ? null
+ : classTags.get(memberValue.getClass());
+ NodeTuple tuple = representJavaBeanProperty(javaBean, property, memberValue,
+ customPropertyTag);
+ if (tuple == null) {
+ continue;
+ }
+ if (!((ScalarNode) tuple.getKeyNode()).isPlain()) {
+ bestStyle = FlowStyle.BLOCK;
+ }
+ Node nodeValue = tuple.getValueNode();
+ if (!(nodeValue instanceof ScalarNode && ((ScalarNode) nodeValue).isPlain())) {
+ bestStyle = FlowStyle.BLOCK;
+ }
+ value.add(tuple);
+ }
+ if (defaultFlowStyle != FlowStyle.AUTO) {
+ node.setFlowStyle(defaultFlowStyle);
+ } else {
+ node.setFlowStyle(bestStyle);
+ }
+ return node;
+ }
+
+ /**
+ * Represent one JavaBean property.
+ *
+ * @param javaBean
+ * - the instance to be represented
+ * @param property
+ * - the property of the instance
+ * @param propertyValue
+ * - value to be represented
+ * @param customTag
+ * - user defined Tag
+ * @return NodeTuple to be used in a MappingNode. Return null to skip the
+ * property
+ */
+ protected NodeTuple representJavaBeanProperty(Object javaBean, Property property,
+ Object propertyValue, Tag customTag) {
+ ScalarNode nodeKey = (ScalarNode) representData(property.getName());
+ // the first occurrence of the node must keep the tag
+ boolean hasAlias = this.representedObjects.containsKey(propertyValue);
+
+ Node nodeValue = representData(propertyValue);
+
+ if (propertyValue != null && !hasAlias) {
+ NodeId nodeId = nodeValue.getNodeId();
+ if (customTag == null) {
+ if (nodeId == NodeId.scalar) {
+ if (property.getType() == propertyValue.getClass()) {
+ if (propertyValue instanceof Enum<?>) {
+ nodeValue.setTag(Tag.STR);
+ }
+ }
+ } else {
+ if (nodeId == NodeId.mapping) {
+ if (property.getType() == propertyValue.getClass()) {
+ if (!(propertyValue instanceof Map<?, ?>)) {
+ if (!nodeValue.getTag().equals(Tag.SET)) {
+ nodeValue.setTag(Tag.MAP);
+ }
+ }
+ }
+ }
+ checkGlobalTag(property, nodeValue, propertyValue);
+ }
+ }
+ }
+
+ return new NodeTuple(nodeKey, nodeValue);
+ }
+
+ /**
+ * Remove redundant global tag for a type safe (generic) collection if it is
+ * the same as defined by the JavaBean property
+ *
+ * @param property
+ * - JavaBean property
+ * @param node
+ * - representation of the property
+ * @param object
+ * - instance represented by the node
+ */
+ @SuppressWarnings("unchecked")
+ protected void checkGlobalTag(Property property, Node node, Object object) {
+ // Skip primitive arrays.
+ if (object.getClass().isArray() && object.getClass().getComponentType().isPrimitive()) {
+ return;
+ }
+
+ Class<?>[] arguments = property.getActualTypeArguments();
+ if (arguments != null) {
+ if (node.getNodeId() == NodeId.sequence) {
+ // apply map tag where class is the same
+ Class<? extends Object> t = arguments[0];
+ SequenceNode snode = (SequenceNode) node;
+ Iterable<Object> memberList = Collections.EMPTY_LIST;
+ if (object.getClass().isArray()) {
+ memberList = Arrays.asList((Object[]) object);
+ } else if (object instanceof Iterable<?>) {
+ // list
+ memberList = (Iterable<Object>) object;
+ }
+ Iterator<Object> iter = memberList.iterator();
+ if (iter.hasNext()) {
+ for (Node childNode : snode.getValue()) {
+ Object member = iter.next();
+ if (member != null) {
+ if (t.equals(member.getClass()))
+ if (childNode.getNodeId() == NodeId.mapping) {
+ childNode.setTag(Tag.MAP);
+ }
+ }
+ }
+ }
+ } else if (object instanceof Set) {
+ Class<?> t = arguments[0];
+ MappingNode mnode = (MappingNode) node;
+ Iterator<NodeTuple> iter = mnode.getValue().iterator();
+ Set<?> set = (Set<?>) object;
+ for (Object member : set) {
+ NodeTuple tuple = iter.next();
+ Node keyNode = tuple.getKeyNode();
+ if (t.equals(member.getClass())) {
+ if (keyNode.getNodeId() == NodeId.mapping) {
+ keyNode.setTag(Tag.MAP);
+ }
+ }
+ }
+ } else if (object instanceof Map) { // NodeId.mapping ends-up here
+ Class<?> keyType = arguments[0];
+ Class<?> valueType = arguments[1];
+ MappingNode mnode = (MappingNode) node;
+ for (NodeTuple tuple : mnode.getValue()) {
+ resetTag(keyType, tuple.getKeyNode());
+ resetTag(valueType, tuple.getValueNode());
+ }
+ } else {
+ // the type for collection entries cannot be
+ // detected
+ }
+ }
+ }
+
+ private void resetTag(Class<? extends Object> type, Node node) {
+ Tag tag = node.getTag();
+ if (tag.matches(type)) {
+ if (Enum.class.isAssignableFrom(type)) {
+ node.setTag(Tag.STR);
+ } else {
+ node.setTag(Tag.MAP);
+ }
+ }
+ }
+
+ /**
+ * Get JavaBean properties to be serialised. The order is respected. This
+ * method may be overridden to provide custom property selection or order.
+ *
+ * @param type
+ * - JavaBean to inspect the properties
+ * @return properties to serialise
+ */
+ protected Set<Property> getProperties(Class<? extends Object> type) {
+ if (typeDefinitions.containsKey(type)) {
+ return typeDefinitions.get(type).getProperties();
+ }
+ return getPropertyUtils().getProperties(type);
+ }
+}