return moduleVersion;
    }

    public void setModuleVersion(@Nullable ModuleVersionIdentifier moduleVersion) {
        this.moduleVersion = moduleVersion;
    }

    @Override
    public void appendNode(Node node) {
        Map<String, Object> attributes = new LinkedHashMap<>();
        attributes.put("sourcepath", sourcePath == null ? null : sourcePath.getPath());
        addClasspathEntry(node, attributes);
    }

            attributes.put("exported", "");
        }
        if (!Strings.isNullOrEmpty(scope) && !"COMPILE".equals(scope)) {
            attributes.put("scope", scope);
        }
        parentNode.appendNode("orderEntry", attributes);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!getClass().equals(o.getClass())) {

        outputFile = new File(outputFile.parentFile, 'someBetterName.ipr')

        ipr {
            withXml {
                def node = it.asNode()
                node.appendNode('someInterestingConfiguration', 'hey buddy!')
            }
        }
    }
}
'''
        result.assertTasksExecuted(":ideaModule", ":ideaProject", ":ideaWorkspace",
            ":api:ideaModule",

 *
 * <pre class='autoTested'>
 * plugins {
 *     id 'java'
 *     id 'idea'
 * }
 *
 * idea.workspace.iws.withXml { provider -&gt;
 *     provider.asNode().appendNode('gradleRocks', 'true')
 * }
 * </pre>
 */
public abstract class IdeaWorkspace {

    private XmlFileContentMerger iws;

    /**
     * Enables advanced manipulation of the output XML.
     * <p>

        new SourceFolder(new XmlParser().parseText(XML_TEXT)) == createSourceFolder()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createSourceFolder().appendNode(rootNode)

        then:
        new SourceFolder(rootNode.classpathentry[0]) == createSourceFolder()
    }

    def equality() {
        SourceFolder sourceFolder = createSourceFolder()

        if(prefix != null) {
            name = prefix + "-" + name;
        }
        path = name;
    }

    private static final Joiner JOINER = Joiner.on("|");

    @Override
    public void appendNode(Node node) {
        Map<String, Object> attributes = new LinkedHashMap<>();
        attributes.put("including", JOINER.join(includes));
        attributes.put("excluding", JOINER.join(excludes));

        def pomFile = createPomFile(makeProjectIdentity("group", "artifact", "version"), new Action<XmlProvider>() {
            void execute(XmlProvider xml) {
                xml.asNode().appendNode("parent")
            }
        })
        def publication = new MavenNormalizedPublication("pub-name", projectIdentity, "pom", pomFile, null, emptySet())

        when:

        assertArgumentNotNull("children", children);
        assertArgumentNotNull("buf", buf);

        final int length = children.getLength();
        for (int i = 0; i < length; ++i) {
            appendNode(children.item(i), buf);
        }
    }

    /**
     * {@link NamedNodeMap}の文字列表現を追加します。
     *
     * @param attrs
     *            属性。{@literal null}であってはいけません
     * @param buf

                }
                publications {
                    maven(MavenPublication) {
                        from components.java
                        pom.withXml {
                            asNode().appendNode('description', '${sq(description)}')
                        }
                    }
                }
            }
        """
        when:
        succeeds 'publish'

        then:

          assert it.deployName == 'coolDeployName'
        }
        whenMerged {
          hooks << 'whenMerged'
          it.deployName = 'betterDeployName'
        }
        withXml { it.asNode().appendNode('be', 'cool') }
      }
    }
  }
}

eclipseWtpComponent.doLast() {
  assert hooks == ['beforeMerged', 'whenMerged']
}

        """

        //when