org.codehaus.plexus.configuration.PlexusConfiguration Java Examples

private void write(PlexusConfiguration c, XMLWriter w, int depth) throws IOException {
  int count = c.getChildCount();

  if (count == 0) {
    writeTag(c, w, depth);
  } else {
    w.startElement(c.getName());
    writeAttributes(c, w);

    for (int i = 0; i < count; i++) {
      PlexusConfiguration child = c.getChild(i);

      write(child, w, depth + 1);
    }

    w.endElement();
  }
}
 

@Test
public void testNestedSchemasConverted() throws Exception {
    ModelNode topSchema = json("{\"type\": \"object\", \"properties\": {\"a\": {\"type\": \"string\"}}}");
    ModelNode nestedSchema = json("{\"type\": \"boolean\"}");

    Map<String, ModelNode> extensionSchemas = new HashMap<>();
    extensionSchemas.put("top", topSchema);
    extensionSchemas.put("top.nested", nestedSchema);

    ModelNode config = json("{\"top\": {\"a\": \"kachny\", \"nested\": true}}");

    PlexusConfiguration xml = SchemaDrivenJSONToXmlConverter.convertToXml(extensionSchemas, config);
    assertEquals(2, xml.getChildCount());

    PlexusConfiguration topXml = xml.getChild("top");
    assertNotNull(topXml);
    assertEquals("top", topXml.getName());
    assertEquals(1, topXml.getChildCount());
    assertEquals("a", topXml.getChild(0).getName());
    assertEquals("kachny", topXml.getChild("a").getValue());

    PlexusConfiguration nested = xml.getChild("top.nested");
    assertNotNull(nested);
    assertEquals(0, nested.getChildCount());
    assertEquals("true", nested.getValue());
}
 

@Test
public void testOneOf() throws Exception {
    ModelNode schema = json("{\"oneOf\": [{\"type\": \"integer\"}, {\"type\": \"number\"}, {\"type\": \"boolean\"}]}");
    ModelNode json1 = json("1");
    ModelNode json2 = json("1.1");

    try {
        SchemaDrivenJSONToXmlConverter.convert(json1, schema, "ext", null);
        fail("Should not have been possible to convert using ambiguous oneOf.");
    } catch (IllegalArgumentException __) {
        //good
    }

    PlexusConfiguration xml = SchemaDrivenJSONToXmlConverter.convert(json2, schema, "ext", null);
    assertNotNull(xml);
    assertEquals("ext", xml.getName());
    assertEquals(0, xml.getChildCount());
    assertEquals("1.1", xml.getValue());
}
 

@Test
public void testDuplicateKeyConfiguration() throws Exception {
    PlexusConfiguration config = new DefaultPlexusConfiguration(OptionallyConfigurableMojoComponent.ELEMENT_CONFIGURATION)
            .addChild("key1", "value1")
            .addChild("key2", "value2a")
            .addChild("key2", "value2b")
            .addChild("key2", "value2c")
            .addChild("key3", "value3");

    PlexusConfiguration configuration = generateComponentConfiguration("componentName", ELEMENT_NAME, config);
    OptionallyConfigurableMojoComponent component = parseConfiguration(configuration, DMNTransformerComponent.class);

    assertEquivalentConfiguration(component, "{\n" +
            "  \"key1\": \"value1\",\n" +
            "  \"key2\": [ \"value2a\", \"value2b\", \"value2c\" ],\n" +
            "  \"key3\": \"value3\"\n" +
            "}");
}
 

@Test
public void testNestedConfiguration() throws Exception {
    PlexusConfiguration inner = new DefaultPlexusConfiguration("innerConfig");
    inner.addChild("innerKey1", "innerValue1");

    PlexusConfiguration intermediate = new DefaultPlexusConfiguration("intermediateConfig");
    intermediate.addChild("intermediateKey1", "intermediateValue1");
    intermediate.addChild(inner);

    PlexusConfiguration config = new DefaultPlexusConfiguration(OptionallyConfigurableMojoComponent.ELEMENT_CONFIGURATION);
    config.addChild("key1", "value1");
    config.addChild(intermediate);

    PlexusConfiguration configuration = generateComponentConfiguration("componentName", ELEMENT_NAME, config);
    OptionallyConfigurableMojoComponent component = parseConfiguration(configuration, DMNTransformerComponent.class);

    assertEquivalentConfiguration(component, "{\n" +
            "  \"key1\": \"value1\",\n" +
            "  \"intermediateConfig\": {\n" +
            "    \"intermediateKey1\": \"intermediateValue1\",\n" +
            "    \"innerConfig\": {\n" +
            "      \"innerKey1\": \"innerValue1\" \n" +
            "    }\n" +
            "  }\n" +
            "}");
}
 

protected void configurePitMojo(final AbstractPitMojo pitMojo, final String config)
    throws Exception {
  final Xpp3Dom xpp3dom = Xpp3DomBuilder.build(new StringReader(config));
  final PlexusConfiguration pluginConfiguration = extractPluginConfiguration(
      "pitest-maven", xpp3dom);

  // default the report dir to something
  setVariableValueToObject(pitMojo, "reportsDirectory", new File("."));

  configureMojo(pitMojo, pluginConfiguration);

  final Map<String, Artifact> pluginArtifacts = new HashMap<>();
  setVariableValueToObject(pitMojo, "pluginArtifactMap", pluginArtifacts);

  setVariableValueToObject(pitMojo, "project", this.project);

  if (pitMojo.getAdditionalClasspathElements() == null) {
    ArrayList<String> elements = new ArrayList<>();
    setVariableValueToObject(pitMojo, "additionalClasspathElements", elements);
  }

}
 

@SuppressWarnings("unchecked")
private Map<String, Object> generateConfigurationMap(PlexusConfiguration configuration) {
    Map<String, Object> node = new HashMap<>();

    for (PlexusConfiguration child : configuration.getChildren()) {

        // Expand node to a list where duplicate keys exist
        Object existingNode = node.get(child.getName());
        if (existingNode != null) {
            if (!(existingNode instanceof List)) {
                List<Object> listNode = new ArrayList<>();
                listNode.add(existingNode);
                node.put(child.getName(), listNode);
            }

            List<Object> target = ((List)node.get(child.getName()));
            target.add(generateChildNode(child));
        }
        else {
            node.put(child.getName(), generateChildNode(child));
        }
    }

    return node;
}
 

private OptionallyConfigurableMojoComponent configureCompoundComponent(OptionallyConfigurableMojoComponent component,
                                                                       PlexusConfiguration configuration) throws ComponentConfigurationException {

    PlexusConfiguration name = configuration.getChild(OptionallyConfigurableMojoComponent.ELEMENT_NAME, false);
    if (name == null || name.getValue() == null) {
        throw new ComponentConfigurationException(String.format(
                "Cannot configure component; \"%s\" property must be provided", OptionallyConfigurableMojoComponent.ELEMENT_NAME));
    }

    component.setName(name.getValue());

    PlexusConfiguration config = configuration.getChild(OptionallyConfigurableMojoComponent.ELEMENT_CONFIGURATION, false);
    if (config != null) {
        component.setConfiguration(generateConfigurationMap(config));
    }

    return component;
}
 

@Test
public void extractionOfMojoSpecificConfigurationAndMergingwithDefaultMojoConfiguration() throws Exception {
  InputStream is = getClass().getResourceAsStream("/META-INF/maven/plugin.xml");
  assertNotNull(is);
  PluginDescriptor pluginDescriptor = pluginDescriptorBuilder.build(new InputStreamReader(is, "UTF-8"));
  String goal = merger.determineGoal("io.takari.maven.plugins.jar.Jar", pluginDescriptor);
  assertEquals("We expect the goal name to be 'jar'", "jar", goal);
  MojoDescriptor mojoDescriptor = pluginDescriptor.getMojo(goal);
  PlexusConfiguration defaultMojoConfiguration = mojoDescriptor.getMojoConfiguration();
  System.out.println(defaultMojoConfiguration);

  PlexusConfiguration configurationFromMaven = builder("configuration") //
      .es("jar") //
      .es("sourceJar").v("true").ee() //
      .ee() //
      .buildPlexusConfiguration();

  PlexusConfiguration mojoConfiguration = merger.extractAndMerge(goal, configurationFromMaven, defaultMojoConfiguration);

  String xml = mojoConfiguration.toString();
  assertXpathEvaluatesTo("java.io.File", "/configuration/classesDirectory/@implementation", xml);
  assertXpathEvaluatesTo("${project.build.outputDirectory}", "/configuration/classesDirectory/@default-value", xml);
  assertXpathEvaluatesTo("java.util.List", "/configuration/reactorProjects/@implementation", xml);
  assertXpathEvaluatesTo("${reactorProjects}", "/configuration/reactorProjects/@default-value", xml);
  assertXpathEvaluatesTo("true", "/configuration/sourceJar", xml);
}
 

@Test
public void plexusConfigurationMerging() throws Exception {

  PlexusConfiguration mojoConfigurationFromPom = builder("configuration") //
      .es("sourceJar").v("true").ee() //
      .buildPlexusConfiguration();

  PlexusConfiguration defaultMojoConfiguration = builder("configuration") //
      .entry("classesDirectory", "java.io.File", "${project.build.outputDirectory}") //
      .entry("reactorProjects", "java.util.List", "${reactorProjects}") //
      .entry("souceJar", "boolean", "${sourceJar") //
      .buildPlexusConfiguration();

  PlexusConfiguration mojoConfiguration = merger.mergePlexusConfiguration(mojoConfigurationFromPom, defaultMojoConfiguration);

  String xml = mojoConfiguration.toString();
  assertXpathEvaluatesTo("java.io.File", "/configuration/classesDirectory/@implementation", xml);
  assertXpathEvaluatesTo("${project.build.outputDirectory}", "/configuration/classesDirectory/@default-value", xml);
  assertXpathEvaluatesTo("java.util.List", "/configuration/reactorProjects/@implementation", xml);
  assertXpathEvaluatesTo("${reactorProjects}", "/configuration/reactorProjects/@default-value", xml);
  assertXpathEvaluatesTo("true", "/configuration/sourceJar", xml);
}
 

private static PlexusConfiguration convertArray(ModelNode configuration, ConversionContext ctx) {
    ModelNode itemsSchema = ctx.currentSchema.get("items");
    if (!itemsSchema.isDefined()) {
        throw new IllegalArgumentException(
                "No schema found for items of a list. Cannot continue with XML-to-JSON conversion.");
    }
    PlexusConfiguration list = new XmlPlexusConfiguration(ctx.tagName);
    if (ctx.id != null) {
        list.setAttribute("id", ctx.id);
    }

    for (ModelNode childConfig : configuration.asList()) {
        ctx.tagName = "item";
        ctx.currentSchema = itemsSchema;
        ctx.id = null;
        ctx.currentPath.push("[]");
        PlexusConfiguration child = convert(childConfig, ctx);
        ctx.currentPath.pop();
        list.addChild(child);
    }
    return list;
}
 

public void configureComponent(Object component, PlexusConfiguration configuration,
        ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm,
        ConfigurationListener listener)
        throws ComponentConfigurationException
{

    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);
    converterLookup.registerConverter(new ClassRealmConverter(containerRealm));
    ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration,
            expressionEvaluator, listener);
}
 

Xpp3Dom convert(PlexusConfiguration c) throws ComponentConfigurationException {
  try {
    return Xpp3DomBuilder.build(new StringReader(c.toString()));
  } catch (Exception e) {
    throw new ComponentConfigurationException("Failure converting PlexusConfiguration to Xpp3Dom.", e);
  }
}
 

private Xpp3Dom toXpp3Dom(PlexusConfiguration config) {
    Xpp3Dom result = new Xpp3Dom(config.getName());
    result.setValue(config.getValue(null));
    for (String name : config.getAttributeNames()) {
        result.setAttribute(name, config.getAttribute(name));
    }
    for (PlexusConfiguration child : config.getChildren()) {
        result.addChild(toXpp3Dom(child));
    }
    return result;
}
 

@Override
public void configureComponent(final Object mojoInstance, //
    final PlexusConfiguration pluginConfigurationFromMaven, //
    final ExpressionEvaluator evaluator, //
    final ClassRealm realm, //
    final ConfigurationListener listener) throws ComponentConfigurationException {

  super.configureComponent(mojoInstance, pluginConfigurationFromMaven, evaluator, realm, listener);
}
 

/**
 * This will copy the configuration from <b>src</b> to the result whereas the placeholder will be replaced with the
 * current value.
 */
private PlexusConfiguration copyConfiguration( Xpp3Dom src, String iteratorName, String value )
{

    XmlPlexusConfiguration dom = new XmlPlexusConfiguration( src.getName() );

    if ( src.getValue() == null )
    {
        dom.setValue( src.getValue() );
    }
    else
    {
        if ( src.getValue().contains( iteratorName ) )
        {
            dom.setValue( src.getValue().replaceAll( iteratorName, value ) );
        }
        else
        {
            dom.setValue( src.getValue() );
        }
    }

    for ( String attributeName : src.getAttributeNames() )
    {
        dom.setAttribute( attributeName, src.getAttribute( attributeName ) );
    }

    for ( Xpp3Dom child : src.getChildren() )
    {
        dom.addChild( copyConfiguration( child, iteratorName, value ) );
    }

    return dom;
}
 

/**
 * Taken from MojoExecutor of Don Brown. Converts PlexusConfiguration to a Xpp3Dom.
 * 
 * @param config the PlexusConfiguration. Must not be {@code null}.
 * @return the Xpp3Dom representation of the PlexusConfiguration
 */
public Xpp3Dom toXpp3Dom( PlexusConfiguration config )
{
    Xpp3Dom result = new Xpp3Dom( config.getName() );
    result.setValue( config.getValue( null ) );
    for ( String name : config.getAttributeNames() )
    {
        result.setAttribute( name, config.getAttribute( name ) );
    }
    for ( PlexusConfiguration child : config.getChildren() )
    {
        result.addChild( toXpp3Dom( child ) );
    }
    return result;
}
 

private Xpp3Dom convertPlexusConfiguration(PlexusConfiguration config) {

    Xpp3Dom xpp3DomElement = new Xpp3Dom(config.getName());
    xpp3DomElement.setValue(config.getValue());

    for (String name : config.getAttributeNames()) {
      xpp3DomElement.setAttribute(name, config.getAttribute(name));
    }

    for (PlexusConfiguration child : config.getChildren()) {
      xpp3DomElement.addChild(convertPlexusConfiguration(child));
    }

    return xpp3DomElement;
  }
 

@Override
public void configureComponent(Object component, PlexusConfiguration configuration,
                               ExpressionEvaluator expressionEvaluator, ClassRealm containerRealm,
                               ConfigurationListener listener)
        throws ComponentConfigurationException {
    addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

    ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();
    converter.processConfiguration(converterLookup, component, containerRealm.getClassLoader(), configuration,
            expressionEvaluator, listener);
}
 

/**
 * Extract the Mojo specific configuration from the incoming plugin configuration from Maven by looking at an enclosing element with the goal name. Use this and merge it with the default Mojo
 * configuration and use this to apply values to the Mojo.
 * 
 * @param goal
 * @param pluginConfigurationFromMaven
 * @param defaultMojoConfiguration
 * @return
 * @throws ComponentConfigurationException
 */
PlexusConfiguration extractAndMerge(String goal, PlexusConfiguration pluginConfigurationFromMaven, PlexusConfiguration defaultMojoConfiguration) throws ComponentConfigurationException {
  //
  // We need to extract the specific configuration for this goal out of the POM configuration
  //
  PlexusConfiguration mojoConfigurationFromPom = new XmlPlexusConfiguration("configuration");
  for (PlexusConfiguration element : pluginConfigurationFromMaven.getChildren()) {
    if (element.getName().equals(goal)) {
      for (PlexusConfiguration goalConfigurationElements : element.getChildren()) {
        mojoConfigurationFromPom.addChild(goalConfigurationElements);
      }
    }
  }
  return new XmlPlexusConfiguration(Xpp3Dom.mergeXpp3Dom(convert(mojoConfigurationFromPom), convert(defaultMojoConfiguration)));
}
 

private Xpp3Dom toXpp3Dom(PlexusConfiguration config) {
    Xpp3Dom result = new Xpp3Dom(config.getName());
    result.setValue(config.getValue(null));
    for (String name : config.getAttributeNames()) {
        result.setAttribute(name, config.getAttribute(name));
    }
    for (PlexusConfiguration child : config.getChildren()) {
        result.addChild(toXpp3Dom(child));
    }
    return result;
}
 

private void mergeXmlConfigFile(AnalysisContext.Builder ctxBld, ConfigurationFile configFile, Reader rdr)
        throws IOException, XmlPullParserException {
    XmlToJson<PlexusConfiguration> conv = new XmlToJson<>(revapi, PlexusConfiguration::getName,
            PlexusConfiguration::getValue, PlexusConfiguration::getAttribute, x -> Arrays.asList(x.getChildren()));

    PlexusConfiguration xml = new XmlPlexusConfiguration(Xpp3DomBuilder.build(rdr));

    String[] roots = configFile.getRoots();

    if (roots == null) {
        ctxBld.mergeConfiguration(conv.convert(xml));
    } else {
        roots:
        for (String r : roots) {
            PlexusConfiguration root = xml;
            boolean first = true;
            String[] rootPath = r.split("/");
            for (String name : rootPath) {
                if (first) {
                    first = false;
                    if (!name.equals(root.getName())) {
                        continue roots;
                    }
                } else {
                    root = root.getChild(name);
                    if (root == null) {
                        continue roots;
                    }
                }
            }

            ctxBld.mergeConfiguration(conv.convert(root));
        }
    }
}
 

private void parseIncludeExclude(PlexusConfiguration parent, Consumer<String> handleInclude,
        Consumer<String> handleExclude) {

    PlexusConfiguration include = parent.getChild("include");
    PlexusConfiguration exclude = parent.getChild("exclude");

    if (include != null) {
        Stream.of(include.getChildren()).forEach(c -> handleInclude.accept(c.getValue()));
    }

    if (exclude != null) {
        Stream.of(exclude.getChildren()).forEach(c -> handleExclude.accept(c.getValue()));
    }
}
 

private PipelineConfiguration.Builder parsePipelineConfigurationXML() {
    PipelineConfiguration.Builder bld = PipelineConfiguration.builder();

    if (pipelineConfiguration == null) {
        return bld;
    }

    for (PlexusConfiguration c : pipelineConfiguration.getChildren()) {
        switch (c.getName()) {
        case "analyzers":
            parseIncludeExclude(c, bld::addAnalyzerExtensionIdInclude, bld::addAnalyzerExtensionIdExclude);
            break;
        case "reporters":
            parseIncludeExclude(c, bld::addReporterExtensionIdInclude, bld::addReporterExtensionIdExclude);
            break;
        case "filters":
            parseIncludeExclude(c, bld::addFilterExtensionIdInclude, bld::addFilterExtensionIdExclude);
            break;
        case "transforms":
            parseIncludeExclude(c, bld::addTransformExtensionIdInclude, bld::addTransformExtensionIdExclude);
            break;
        case "transformBlocks":
            for (PlexusConfiguration b : c.getChildren()) {
                List<String> blockIds = Stream.of(b.getChildren())
                        .map(PlexusConfiguration::getValue).collect(toList());
                bld.addTransformationBlock(blockIds);
            }
            break;
        }
    }

    return bld;
}
 

private static PlexusConfiguration convertToXml(Map<String, ModelNode> extensionSchemas, String xmlOrJson)
        throws IOException, XmlPullParserException {
    ModelNode jsonConfig;
    try {
        jsonConfig = ModelNode.fromJSONString(JSONUtil.stripComments(xmlOrJson));
    } catch (IllegalArgumentException e) {
        //ok, this already is XML
        return null;
    }
    return SchemaDrivenJSONToXmlConverter.convertToXml(extensionSchemas, jsonConfig);
}
 

static void toIndentedString(PlexusConfiguration xml, int indentationSize, int currentDepth, Writer wrt)
        throws IOException {

    indent(indentationSize, currentDepth, wrt);

    boolean hasChildren = xml.getChildCount() > 0;
    boolean hasContent = xml.getValue() != null && !xml.getValue().isEmpty();
    wrt.write('<');
    wrt.write(xml.getName());
    if (!hasChildren && !hasContent) {
        wrt.write("/>");
    } else {
        wrt.write('>');
        if (hasChildren) {
            wrt.write('\n');
            for (PlexusConfiguration c : xml.getChildren()) {
                toIndentedString(c, indentationSize, currentDepth + 1, wrt);
                wrt.append('\n');
            }

            if (!hasContent) {
                indent(indentationSize, currentDepth, wrt);
            }
        }

        if (hasContent) {
            escaped(wrt, xml.getValue());
        }

        wrt.write("</");
        wrt.write(xml.getName());
        wrt.write('>');
    }
}
 

private static PlexusConfiguration
convertNewStyleConfigToXml(Map<String, ModelNode> extensionSchemas, ModelNode jsonConfig) throws IOException {
    PlexusConfiguration xmlConfig = new XmlPlexusConfiguration("analysisConfiguration");

    for (ModelNode extConfig : jsonConfig.asList()) {
        String extensionId = extConfig.get("extension").asString();
        ModelNode configuration = extConfig.get("configuration");
        String id = extConfig.hasDefined("id") ? extConfig.get("id").asString() : null;

        ModelNode schema = extensionSchemas.get(extensionId);
        if (schema == null) {
            continue;
        }

        ConversionContext ctx = new ConversionContext();
        ctx.rootSchema = schema;
        ctx.currentSchema = schema;
        ctx.pushTag(extensionId);
        ctx.id = id;
        //we don't assign the ignorable paths, because this must not be tracked in a new-style configuration
        PlexusConfiguration extXml = convert(configuration, ctx);
        ctx.currentPath.pop();
        xmlConfig.addChild(extXml);
    }

    return xmlConfig;
}
 

private static PlexusConfiguration convertOldStyleConfigToXml(Map<String, ModelNode> extensionSchemas,
                                                              ModelNode jsonConfig) {
    PlexusConfiguration xmlConfig = new XmlPlexusConfiguration("analysisConfiguration");

    extensionCheck: for (Map.Entry<String, ModelNode> e : extensionSchemas.entrySet()) {
        String extensionId = e.getKey();
        ModelNode schema = e.getValue();

        String[] extensionPath = extensionId.split("\\.");

        ModelNode config = jsonConfig;
        for (String segment : extensionPath) {
            if (!config.has(segment)) {
                continue extensionCheck;
            } else {
                config = config.get(segment);
            }
        }

        ConversionContext ctx = new ConversionContext();
        ctx.rootSchema = schema;
        ctx.currentSchema = schema;
        ctx.pushTag(extensionId);
        ctx.id = null;
        ctx.ignorablePaths = extensionSchemas.keySet().stream()
                .filter(id -> !extensionId.equals(id) && id.startsWith(extensionId))
                .collect(Collectors.toList());
        PlexusConfiguration extXml = convert(config, ctx);
        ctx.currentPath.pop();
        xmlConfig.addChild(extXml);
    }

    return xmlConfig;
}
 

private static PlexusConfiguration convertSimple(String tagName, String id, String value) {
    XmlPlexusConfiguration ret = new XmlPlexusConfiguration(tagName);
    if (id != null) {
        ret.setAttribute("id", id);
    }

    ret.setValue(value);
    return ret;
}
 

private static PlexusConfiguration convertObject(ModelNode configuration, ConversionContext ctx) {
    XmlPlexusConfiguration object = new XmlPlexusConfiguration(ctx.tagName);
    if (ctx.id != null) {
        object.setAttribute("id", ctx.id);
    }

    ModelNode propertySchemas = ctx.currentSchema.get("properties");
    ModelNode additionalPropSchemas = ctx.currentSchema.get("additionalProperties");
    for (String key : configuration.keys()) {
        ModelNode childConfig = configuration.get(key);
        ModelNode childSchema = propertySchemas.get(key);
        if (!childSchema.isDefined()) {
            if (additionalPropSchemas.getType() == ModelType.BOOLEAN) {
                throw new IllegalArgumentException("Cannot determine the format for the '" + key +
                        "' JSON value during the JSON-to-XML conversion.");
            }
            childSchema = additionalPropSchemas;
        }

        ctx.currentSchema = childSchema;
        ctx.pushTag(key);
        ctx.id = null;

        if (!childSchema.isDefined()) {
            //check if this is an ignorable path
            if (ctx.ignorablePaths.contains(ctx.getCurrentPathString())) {
                ctx.currentPath.pop();
                continue;
            }
            throw new IllegalArgumentException("Could not determine the format for the '" + key +
                    "' JSON value during the JSON-to-XML conversion.");
        }

        PlexusConfiguration xmlChild = convert(childConfig, ctx);
        ctx.currentPath.pop();
        object.addChild(xmlChild);
    }
    return object;
}