ant-ivy-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Geoff Clitheroe <g.clithe...@gmail.com>
Subject Re: Integrating Ivy with NetBeans
Date Fri, 12 Feb 2010 02:17:45 GMT
Hi,

Here's how we do it.  I'm busy so this isn't going to be very comprehensive
but ask if you want more details.

We have integrated Ivy via the netbeans ant file.  The project does not need
to be free form and after check out, or a change to the ivy file, we just
need to run the ant target 'setup-nb-build-environment' to do an ivy resolve
and sort out the NB classpath.  Our build-base.xml file and Ivy configs are
all stored in a web server which is not public so look for where I have
changed them.   There are also some targets to run various styles of tests,
deploy to and restart tomcat, get clover, and publish to our local repo etc
that you may not need to get running.

We bootstrap the Ivy jar (and clover) from our enterprise repo so you would
need to change this to a public repo.

I would like to package something like this up for distribution but this may
give you some ideas now.  It was a little bit of work to get running but
well worth it.

In the NB build file add these targets

    <get src="http://your.server.com/ivy/build/build-base.xml"
        dest="${basedir}/build-base.xml" username="" password=""
        usetimestamp="true" ignoreerrors="true"/>

    <import file="${basedir}/build-base.xml" optional="true"/>

    <target name="setup-nb-build-environment"
depends="ivy-resolve,ivy-generate-nbproject-classpaths"
        description="Run once after project check-out, or whenever ivy
dependencies have changed in ivy.xml"/>

    <target name="-post-init" depends="-init-check-ivy,-do-ivy-init"/>

    <target name="-init-check-ivy">

        <condition property="ivy.needs.init">

            <and>
                <available file="${basedir}/ivy.xml" type="file"/>

                <not>
                    <available file="${ivy.lib.dir}" type="dir"/>
                </not>
            </and>
        </condition>
    </target>

    <target name="-do-ivy-init" if="ivy.needs.init">
        <antcall target="setup-nb-build-environment"/>
    </target>

Then this is build-base.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--$Id: build-base.xml 1031 2010-02-09 20:02:41Z richardg $-->
<project name="build-base" xmlns:ivy="antlib:org.apache.ivy.ant">
    <description>This build file is intended as an import for full projects.
It adds tasks to
        bootstrap ivy and subsequent artifact resolution and publishing, and
for clover (Java) code
        coverage analysis and reporting.</description>


    <!-- Load environment variables -->
    <property environment="env"/>

    <!-- Capture the computer name in a cross-platform manner -->
    <property name="env.COMPUTERNAME" value="${env.HOSTNAME}"/>

    <!--Ant properties are immutable, so this only takes effect if it hasn't
been set in some previous target.-->
    <property name="ivy.lib.dir" value="lib-ivy"/>

    <property name="ivy.install.version" value="2.1.0-rc1"/>

    <property name="ivy.jar.dir" value="${user.home}/.ant/lib"/>
    <property name="ivy.jar.file" value="${ivy.jar.dir}/ivy.jar"/>

    <target name="with.geonet.enterprise.only" description="Tells ivy to use
the enterprise repositories settings only.">
        <property name="geonet.ivy.settings"
value="ivysettings-geonet-enterprise-only.xml"/>
    </target>

    <target name="with.geonet.enterprise.populate.fs" description="Tells ivy
to use the settings that populate the enterprise mirror repository
filesystem.">
        <property name="geonet.ivy.settings"
value="ivysettings-geonet-enterprise-populate-fs.xml"/>
    </target>

    <target name="download-ivy" unless="offline">

        <mkdir dir="${ivy.jar.dir}"/>
        <!-- download Ivy from web site so that it can be used even without
any special installation -->
        <get
            src="
http://your.server.com/ivy/repo/manual/org/apache/ivy/ivy/${ivy.install.version}/ivy-${ivy.install.version}.jar<http://your.server.com/ivy/repo/manual/org/apache/ivy/ivy/$%7Bivy.install.version%7D/ivy-$%7Bivy.install.version%7D.jar>
"
            username="" password="" dest="${ivy.jar.file}"
usetimestamp="true"/>
    </target>

    <target name="init-ivy" depends="download-ivy">
        <!-- try to load ivy here from ivy home, in case the user has not
already dropped
        it into ant's lib dir (note that the latter copy will always take
precedence).
        We will not fail as long as local lib dir exists (it may be empty)
and
        ivy is in at least one of ant's lib dir or the local lib dir. -->
        <path id="ivy.lib.path">
            <fileset dir="${ivy.jar.dir}" includes="*.jar"/>

        </path>
        <taskdef resource="org/apache/ivy/ant/antlib.xml"
uri="antlib:org.apache.ivy.ant"
            classpathref="ivy.lib.path"/>

        <!--Ant properties are immutable, so this only takes effect if it
hasn't been set in some previous target.-->
        <property name="geonet.ivy.settings" value="ivysettings.xml"/>

        <ivy:settings id="ivy.geonet"
            url="http://your.server.com/ivy/repo/${geonet.ivy.settings}<http://your.server.com/ivy/repo/$%7Bgeonet.ivy.settings%7D>
">
            <credentials host="" realm="GeoNet" username="" passwd=""/>
        </ivy:settings>

    </target>

    <target name="ivy-resolve" description="retrieve dependencies with ivy"
depends="init-ivy">
        <ivy:retrieve settingsRef="ivy.geonet" sync="true"

pattern="${ivy.lib.dir}/[conf]/[artifact]-[revision](-[classifier]).[ext]"/>

    </target>

    <target name="ivy-clean-cache" depends="init-ivy, ivy-delete-lib"
description="Cleans the Ivy cache and removes the lib dir.">
        <ivy:cleancache settingsRef="ivy.geonet"/>
    </target>

    <target name="ivy-delete-lib" description="Removes the lib dir.">
        <delete dir="${ivy.lib.dir}"/>
    </target>

    <target name="ivy-init-all-classpaths">
        <description>
            creates paths on a per-ivy-configuration basis and combines
those
            paths to form classpaths appropriate for netbeans projects for
later
            reference.
        </description>

        <!-- Generate a path-ref for each configuration that we use later
-->
        <path id="ivy.compile.path">
            <fileset dir="${ivy.lib.dir}" includes="compile/*.jar" />
        </path>
        <path id="ivy.provided.path">
            <fileset dir="${ivy.lib.dir}" includes="provided/*.jar" />
        </path>
        <path id="ivy.runtime.path">
            <fileset dir="${ivy.lib.dir}" includes="runtime/*.jar" />
        </path>
        <path id="ivy.test.path">
            <fileset dir="${ivy.lib.dir}" includes="test/*.jar" />
        </path>
        <path id="ivy.javadoc.path">
            <fileset dir="${ivy.lib.dir}" includes="javadoc/*.jar" />
        </path>
        <path id="ivy.foride.path">
            <fileset dir="${ivy.lib.dir}" includes="foride/*.jar" />
        </path>
        <path id="ivy.optional.path">
            <fileset dir="${ivy.lib.dir}" includes="optional/*.jar" />
        </path>

        <!-- And combine the above in to netbeans classpaths. -->
        <path id="ivy.netbeans.javac.classpath">
            <path refid="ivy.compile.path" />
            <path refid="ivy.foride.path" />
            <path refid="ivy.javadoc.path" />
            <path refid="ivy.provided.path" />
        </path>

        <path id="ivy.netbeans.run.classpath">
            <pathelement path="$${build.classes.dir}" />

            <path refid="ivy.runtime.path" />
            <path refid="ivy.optional.path" />
        </path>

        <path id="ivy.netbeans.javac.test.classpath">
            <pathelement path="$${build.classes.dir}" />

            <path refid="ivy.test.path" />
            <path refid="ivy.foride.path" />
            <path refid="ivy.javadoc.path" />
            <path refid="ivy.provided.path" />
        </path>

        <path id="ivy.netbeans.run.test.classpath">
            <pathelement path="$${build.classes.dir}" />
            <pathelement path="$${build.test.classes.dir}" />
            <path refid="ivy.test.path" />
            <path refid="ivy.optional.path" />
        </path>
    </target>


    <target name="ivy-generate-nbproject-classpaths"
        depends="init-ivy,ivy-init-all-classpaths"
        description="add dependent jars resolved with ivy to
nbproject/project.properties">

        <ivy:cachepath settingsRef="ivy.geonet"
            organisation="nz.org.geonet" module="GeoNetAntTasks"
            revision="latest." conf="bin-dist" inline="true"
            pathid="geonet-anttasks.classpath" />
        <taskdef resource="geonet-antlib.xml"
classpathref="geonet-anttasks.classpath" />

        <editablepropertyfile file="nbproject/project.properties">
            <!-- Default netbeans javac.classpath is (nothing!) just ivy's
compile configuration -->
            <pathentry key="javac.classpath" relative="${basedir}">
                <path refid="ivy.netbeans.javac.classpath" />
            </pathentry>

            <!-- Default netbeans run.classpath is ${build.classes.dir} -->
            <pathentry key="run.classpath" relative="${basedir}">
                <path refid="ivy.netbeans.run.classpath" />
            </pathentry>

            <!-- Default netbeans javac.test.classpath is
${build.classes.dir} -->
            <pathentry key="javac.test.classpath" relative="${basedir}">
                <path refid="ivy.netbeans.javac.test.classpath" />
            </pathentry>

            <!-- Default netbeans run.test.classpath is
${build.classes.dir}:${build.test.classes.dir} -->
            <pathentry key="run.test.classpath" relative="${basedir}">
                <path refid="ivy.netbeans.run.test.classpath" />
            </pathentry>
        </editablepropertyfile>
    </target>

    <target name="ivy-rename-netbeans-dist-files" depends="init,init-ivy"
description="Copies the netbeans named jar to the ivy module name">
        <ivy:info settingsRef="ivy.geonet"/>
        <copy todir="${dist.dir}" preservelastmodified="true">
            <fileset dir="${dist.dir}">
                <include name="${ant.project.name}*"/>
            </fileset>
            <globmapper from="${ant.project.name}*" to="${ivy.module}*"/>
        </copy>
    </target>

    <target name="ivy-publish-local-release"
depends="clean,ivy-update-manifest,jar,jar-sources,jar-javadoc,ivy-rename-netbeans-dist-files,init-ivy"
description="Publishes a new release version of the project artifact(s) to
the local (disk) repository.">

        <ivy:info settingsRef="ivy.geonet"/>

        <property name="ivy.publish.local.pattern"
value="${dist.dir}/[artifact](-[classifier]).[ext]"/>

        <ivy:buildnumber settingsRef="ivy.geonet"
            resolver="geonet-enterprise-publish-http"
            organisation="${ivy.organisation}"
            module="${ivy.module}"
                        revision="${ivy.revision}"
            default="1.0.0" defaultBuildNumber="1" revSep="."/>

<!-- note use either revision=working or ivy:retrieve work around or cf
http://issues.apache.org/jira/browse/IVY-964 -->

                <ivy:retrieve settingsRef="ivy.geonet"/>

        <ivy:publish settingsRef="ivy.geonet"
            artifactspattern="${ivy.publish.local.pattern}"
            resolver="local"
            pubrevision="${ivy.new.revision}"
            status="release"
            />

<!--        <ivy:publish settingsRef="ivy.geonet"
            artifactspattern="${ivy.publish.local.pattern}"
            resolver="local"
                        revision="working"
            pubrevision="${ivy.new.revision}"
            status="release"
            /> -->

    </target>

    <target name="ivy-publish-local-snapshot"
depends="jar,ivy-update-manifest,jar-sources,jar-javadoc,ivy-rename-netbeans-dist-files,init-ivy"
description="Publishes a new snapshot version of the project artifact(s) to
the local (disk) repository.">

        <ivy:info settingsRef="ivy.geonet"/>

        <property name="ivy.publish.local.pattern"
value="${dist.dir}/[artifact](-[classifier]).[ext]"/>

        <ivy:buildnumber settingsRef="ivy.geonet"
            resolver="geonet-enterprise-publish-http"
            organisation="${ivy.organisation}"
            module="${ivy.module}"
            revision="${ivy.revision}"
            default="0.0.1" defaultBuildNumber="1" revSep="."/>

        <ivy:publish settingsRef="ivy.geonet"
            artifactspattern="${ivy.publish.local.pattern}"
            resolver="local"
            pubrevision="${ivy.new.revision}-SNAPSHOT"
            status="integration"
            update="true"
            overwrite="true"
            />

    </target>

    <target name="ivy-update-manifest" depends="init,init-ivy"
        description="updates the manifest.mf file with package versioning
information">
        <ivy:info settingsRef="ivy.geonet" />

        <ivy:buildnumber settingsRef="ivy.geonet"
            resolver="geonet-enterprise-publish-http"
            organisation="${ivy.organisation}"
            module="${ivy.module}"
            revision="${ivy.revision}"
            default="0.0.1" defaultBuildNumber="1" revSep="."/>

        <!-- Set the default timestamp variables TODAY, DSTAMP and TSTAMP
-->
        <tstamp/>

        <manifest file="${manifest.file}" mode="update">
            <attribute name="Built-By" value="${user.name
}@${env.COMPUTERNAME}"/>
            <!--This might be better done using the jarlib-manifest task-->
            <section name="${ivy.organisation}">
                <attribute name="Specification-Title"
value="${application.title}"/>
                <attribute name="Specification-Version"
value="${ivy.revision}"/>
                <attribute name="Specification-Vendor"
value="${application.vendor}"/>
                <attribute name="Implementation-Title"
value="${ivy.organisation}.${ivy.module}"/>
                <attribute name="Implementation-Version"
value="${ivy.new.revision}-${DSTAMP}${TSTAMP}"/>
                <attribute name="Implementation-Vendor"
value="${ivy.organisation}"/>
            </section>
        </manifest>
    </target>


    <property name="clover.report.dir" value="clover-reports"/>

    <target name="with.clover" depends="clover.init"
        description="enables clover e.g., 'ant with.clover test'.  It may be
necessary to clean all the tests first with 'ant clean'">

        <property name="clover.enabled" value="true"/>
    </target>

    <target name="with.optimized.testset" depends="with.clover"
        description="enables clover testset optimization e.g., 'ant
with.optimized.testset test'.  It may be necessary to clean all the tests
first with 'ant clean'">

        <property name="clover.enable.optimization" value="true"/>
    </target>

    <target name="clover.init"
        description="initialises clover, but doesn't necessarily enable it.
Use 'ant with.clover ...' to enable clover.">
        <path id="clover.classpath">
            <fileset dir="${ivy.lib.dir}">
                <include name="**/clover*.jar"/>
            </fileset>
        </path>
        <taskdef resource="cloverlib.xml" classpathref="clover.classpath"/>
        <taskdef resource="cloverjunitlib.xml"
classpathref="clover.classpath"/>

        <!--This could potentially be an inline ivy retrieve (from our
enterprise repo)-->
        <!--that depends on a specific version of clover-->
        <get
            src="http://your.server.com/ivy/clover/license/clover.license"
            username="" password=""
dest="${ivy.lib.dir}/optional/clover.license" usetimestamp="true"/>

        <clover-setup enabled="${clover.enabled}"/>
    </target>

    <target name="clover.html" depends="clover.init"
        description="generates a clover code coverage report in html e.g.,
'ant clover.html'">
        <clover-html-report outdir="${clover.report.dir}/html" title="${
ant.project.name}"/>
    </target>

        <target name="clover.current.xml">
          <mkdir dir="${clover.report.dir}/pdf"/>
         <clover-report>
          <current outfile="${clover.report.dir}/current.xml"/>
        </clover-report>
        </target>

    <target name="clover.pdf" depends="clover.init"
        description="generates a clover code coverage pdf report e.g., 'ant
clover.pdf'">
        <mkdir dir="${clover.report.dir}/pdf"/>
        <clover-pdf-report
            outfile="${clover.report.dir}/pdf/${ant.project.name
}-clover-coverage.pdf"/>
    </target>

    <target name="clover.clean" depends="clover.init"
        description="cleans the clover cache files">
        <clover-clean/>
        <delete dir="${clover.report.dir}"/>
    </target>

    <target name="clover.snapshot" depends="clover.init"
        description="generates a snapshot db for future test optimization.">
        <clover-snapshot/>
    </target>

    <target name="-init-macrodef-clover-optimized-junit"
depends="clover.init">
        <macrodef name="junit" uri="
http://www.netbeans.org/ns/j2se-project/3">
            <attribute default="${includes}" name="includes"/>
            <attribute default="${excludes}" name="excludes"/>
            <attribute default="**" name="testincludes"/>
            <sequential>
                <junit dir="${work.dir}" errorproperty="tests.failed"
failureproperty="tests.failed" fork="true" showoutput="true">
                    <batchtest todir="${build.test.results.dir}"
fork="true">
                        <clover-optimized-testset
enabled="${clover.enable.optimization}">
                            <fileset dir="${test.test.dir}"
excludes="@{excludes},${excludes}" includes="@{includes}">
                                <filename name="@{testincludes}"/>
                            </fileset>
                        </clover-optimized-testset>
                    </batchtest>
                    <classpath>
                        <path path="${run.test.classpath}"/>
                    </classpath>
                    <syspropertyset>
                        <propertyref prefix="test-sys-prop."/>
                        <mapper from="test-sys-prop.*" to="*" type="glob"/>
                    </syspropertyset>
                    <formatter type="brief" usefile="false"/>
                    <formatter type="xml"/>
                    <jvmarg line="${run.jvmargs}"/>
                </junit>
            </sequential>
        </macrodef>
    </target>

    <target name="jar-sources" depends="init,-pre-jar,-pre-pre-jar"
        description="Creates a source jar for publication alongside
implementation">
        <!--Needs to use src.*dir-->
        <jar destfile="${dist.dir}/${ant.project.name}-sources.jar"
            basedir="${src.dir}" compress="${jar.compress}"
            manifest="${manifest.file}"/>

    </target>

    <target name="jar-javadoc" depends="init,-pre-jar,-pre-pre-jar,javadoc"
        description="Creates a javadoc jar for publication alongside
implementation">
        <jar destfile="${dist.dir}/${ant.project.name}-javadoc.jar"
            basedir="${dist.javadoc.dir}" compress="${jar.compress}"
            manifest="${manifest.file}"/>

    </target>

    <target name="restart.tomcat" if="tomcat.requires.restart"
        description="Restarts the tomcat process remotely.">
        <!-- Default values -->
        <property name="tomcat.server" value="your.server.com" />
        <property name="tomcat.user" value="" />

        <sshexec host="${tomcat.server}" username="" timeout="300000"
            keyfile="${user.home}/.ssh/your.key"
            command="$${HOME}/sbin/restart-tomcat-and-wait-for-manager.sh"/>

    </target>

    <target name="deploy" depends="init,jar,restart.tomcat"
        description="Deploys the distribution war to a tomcat manager.">

        <!--<property name="context.path" value="/delta" />-->
        <fail unless="context.path">Must set context.path</fail>

        <!-- Default values -->
        <property name="tomcat.server" value="your.server.com" />
        <property name="manager.url"
value="http://${tomcat.server}/manager/html"
/>
        <property name="username" value="tomcat" />
        <property name="password" value="test" />
        <property name="tomcat.update" value="true" />

        <path id="catalina-ant.lib.path">
            <fileset dir="${ivy.lib.dir}">
                <include name="**/catalina-ant*.jar" />
            </fileset>
        </path>
        <taskdef name="deploy"
classname="org.apache.catalina.ant.DeployTask"
            classpathref="catalina-ant.lib.path"/>


        <echo message="Deploying ${dist.war} as ${context.path} on
${tomcat.server}." level="info" />
        <deploy url="${manager.url}" username="${username}"
password="${password}"
            path="${context.path}" war="${basedir}/${dist.war}"
update="${tomcat.update}" />
    </target>

    <target name="fitnesse.test" depends="init"
        description="Run Fitnesse tests on the deployed webapp">

        <get src="http://your.server.com/ivy/build/fitnesse-to-junit.xsl"
            username="" password="" dest="${basedir}/fitnesse-to-junit.xsl"
usetimestamp="true"/>

        <!--<property name="fitnesse.testpage" value="GeoNetDeltaWeb" />-->
        <fail unless="fitnesse.testpage">Must set fitnesse.testpage</fail>

        <!-- Default values -->
        <property name="fitnesse.host" value="dryad.gns.cri.nz" />
        <property name="fitnesse.port" value="8081" />
        <property name="testresults.file" value="${fitnesse.testpage}.xml"
/>
        <property name="fitnesse.testresults.file"
value="${build.test.results.dir}/${testresults.file}" />
        <property name="junit.testresults.file"
value="${build.test.results.dir}/FITNESSE-${testresults.file}" />

        <path id="fitnesse.lib.path">
            <fileset dir="${ivy.lib.dir}">
                <include name="**/fitnesse*.jar" />
            </fileset>
        </path>

        <mkdir dir="${build.test.results.dir}" />

        <echo message="Running fitnesse." level="info" />

        <java classname="fitnesse.runner.TestRunner" fork="true"
resultproperty="fitnesse.tests.failed">
            <arg line="-v -xml ${fitnesse.testresults.file} ${fitnesse.host}
${fitnesse.port} ${fitnesse.testpage}" />
            <classpath>
                <path refid="fitnesse.lib.path" />
            </classpath>
        </java>

        <xslt style="${basedir}/fitnesse-to-junit.xsl"
in="${fitnesse.testresults.file}" out="${junit.testresults.file}" />

        <fail message="Failed Fitnesse tests: ${fitnesse.tests.failed}
failures/exceptions">
            <condition>
                <not>
                    <equals arg1="${fitnesse.tests.failed}" arg2="0" />
                </not>
            </condition>
        </fail>

        <echo message="Finished Fitnesse tests: ${fitnesse.tests.failed}
failures/exceptions" level="info" />

    </target>

    <target name="jmeter.init" depends="init,init-ivy"
        description="Initialise Default JMeter parameters and task
definition.">

        <!-- Default values -->
        <property name="jmeter.home" value="/usr/local/jmeter" />
        <property name="jmeter.resultlogdir"
value="${build.test.results.dir}" />

        <mkdir dir="${build.test.results.dir}" />

        <ivy:cachepath settingsRef="ivy.geonet"
            organisation="org.programmerplanet.ant"    module="ant-jmeter"
            revision="1.0.9" inline="true" pathid="jmeter.classpath" />

        <taskdef name="jmeter" classpathref="jmeter.classpath"
            classname="org.programmerplanet.ant.taskdefs.jmeter.JMeterTask"
/>

    </target>

    <target name="jmeter.test" depends="jmeter.init"
        description="Run JMeter tests on the deployed webapp.">

        <property name="jmeter.testplan.dir" value="${basedir}/jmeter" />

        <jmeter
            jmeterhome="${jmeter.home}"
            resultlogdir="${jmeter.resultlogdir}"
            failureproperty="jmeter.tests.failed">
            <property name="jmeter.save.saveservice.output_format"
                value="xml" />
            <property name="jmeter.save.saveservice.assertion_results"
                value="all" />

            <testplans dir="${jmeter.testplan.dir}" includes="*.jmx" />
        </jmeter>

        <xslt
            basedir="${jmeter.resultlogdir}"
            destdir="${jmeter.resultlogdir}"

style="${jmeter.home}/extras/jmeter-results-detail-report_21.xsl">
            <globmapper from="*.jtl" to="*.html" />
        </xslt>

        <fail message="Failed JMeter tests." if="jmeter.tests.failed" />
    </target>

    <target name="jmeter.load.test" depends="jmeter.init"
        description="Run JMeter load tests on the deployed webapp.">

        <property name="jmeter.testplan.dir" value="${basedir}/jmeter-load"
/>
        <jmeter
            jmeterhome="${jmeter.home}"
            resultlogdir="${jmeter.resultlogdir}"
            failureproperty="jmeter.tests.failed">

            <testplans dir="${jmeter.testplan.dir}" includes="*.jmx" />
        </jmeter>

<!--    The output of this JMeter execution is the default csv so we can't
        perform an XSL transformation on it.
        Instead it can be aggregated across builds by something like bamboo.
-->

        <fail message="Failed JMeter tests." if="jmeter.tests.failed" />
    </target>

</project>


On Tue, Feb 9, 2010 at 8:43 AM, CBy <ivy@byrman.demon.nl> wrote:

> Hi,
>
> I was wondering what's the most convenient way to use Ivy in combination
> with NetBeans 6.8. I am currently doing something similar to
> http://wiki.netbeans.org/FaqIvy. It works save some minor details:
>
> 1) After checking out a project from a repository, NetBeans complains about
> reference problems. Fair enough, but building the project does not make the
> warning go away. I have to explicitly open the "Resolve Reference
> Problems..." dialog and click Close - there is nothing to resolve anymore -
> to calm NetBeans.
>
> 2) When managing dependencies manually, I can point to javadoc and sources
> as well, which comes in handy when developing. How to get this feature using
> Ivy? By manipulating project.properties?
>
> 3) My project.properties keeps on changing. I have to commit or revert it
> after every build.
>
> Small annoyances, and more NetBeans than Ivy issues, but perhaps someone
> knows how to address them?
>
> CBy
>

Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message