RubyGems - Antwrap - Versions diffs - 0.2 → 0.3 - Mend

Antwrap 0.2 → 0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

data/README +1 -2
data/docs/index.html +119 -0
data/lib/antwrap.rb +157 -46
data/lib/convert.rb +5 -2
data/test/tc_antwrap.rb +35 -52
metadata +7 -7
data/test/output/classes/foo/bar/FooBar.class +0 -0

data/README CHANGED

@@ -1,7 +1,6 @@
 # antwrap
 #
 # Copyright Caleb Powell 2007
-#
 # Licensed under the LGPL, see the file COPYING in the distribution
 #
@@ -10,4 +9,4 @@ https://rubyforge.org/projects/antwrap/
 Questions?
 Contact: caleb.powell@gmail.com
-More documentation to come.
+More documentation to come.

data/docs/index.html ADDED

@@ -0,0 +1,119 @@
+<html><head><title>Antwrap - Invoke Ant tasks from your JRuby script!</title></head><body><ul>
+<pre><li>Sample code of the Antwrap library looks like this;
+<code lang="ruby">
+    #All options are optional. The defaults are as follows;
+    #{:name=&gt'', :basedir=&gt'.', :declarative=&gt true, :logger=&gt Logger.new(STDOUT), :loglevel=&gt Logger::DEBUG}
+    #so you can call AntProject.new() if you like.
+    @ant = AntProject.new({:name=&gt"FooProject",
+                           :basedir=&gt current_dir,
+                           :declarative=&gt true,
+                           :logger=&gt Logger.new(STDOUT),
+                           :loglevel=&gt Logger::DEBUG})
+    @ant.path(:id =&gt; "other.class.path"){
+        pathelement(:location =&gt; "classes")
+        pathelement(:location =&gt; "config")
+    }
+    @ant.path(:id =&gt; "common.class.path"){
+        fileset(:dir =&gt; "${common.dir}/lib"){
+            include(:name =&gt; "**/*.jar")
+        }
+        pathelement(:location =&gt; "${common.classes}")
+    }
+    @ant.javac(:srcdir =&gt; "test", :destdir =&gt; "classes"){
+        classpath(:refid =&gt; "common.class.path")
+        classpath(:refid =&gt; "foo.class.path")
+    }
+</code>
+</li>
+</pre>
+<pre><li>Alternatively, you can declare your Ant project to run in non-declarative mode, so that it only executes tasks
+upon the invocation of the execute() method (this is a more Object Oriented approach, and may be useful in some
+circumstances):
+<code lang="ruby">
+    @ant = AntProject.new({:name=&gt"FooProject", :declarative=&gttrue})
+    javac_task = @ant.javac(:srcdir =&gt; "test", :destdir =&gt; "classes"){
+        classpath(:refid =&gt; "common.class.path")
+        classpath(:refid =&gt; "foo.class.path")
+    }
+    javac_task.execute
+</code>
+</li>
+</pre>
+<pre><li>There are some reserved words that we have to work around. For example, Ant-Contrib tasks such as 'if' and 'else'
+conflict with the Ruby reserved words. Under most circumstances, you won't need to use these tasks (indeed, the
+awkwardness of conditional operations in Ant scripts is likely one of the reasons why you want to move to a build system
+such as Rake).
+Nevertheless, there are that occasions demands it. One such situation is the &lt;java&gt; Ant task. The 'java'
+symbol conflicts with a symbol in the JRuby library.
+Reserved words like this can be worked around by simply prepending an underscore character ('_') to the task:
+<code lang="ruby">
+    @ant._java(:classname => 'foo.bar.FooBar', :fork => 'false') {
+      arg(:value => 'argOne')
+      classpath(){
+        pathelement(:location => '${output_dir}/classes')
+        pathelement(:location => '${resource_dir}/parent.jar')
+      }
+      arg(:value => 'argTwo')
+      jvmarg(:value => 'client')
+      sysproperty(:key=> 'antwrap', :value => 'coolio')
+    }
+    #Because the 'java' Ant task is likely to be very popular, there is an alias you can use called 'jvm'.
+    #The above task could be rewritten as:
+    @ant.jvm(:classname => 'foo.bar.FooBar', :fork => 'false') {...
+    #This is an example of the Ant-Contrib tasks.
+    #note: I added an underscore to 'equals' even though it isn't a reserved word.
+    #This makes the code block more symmetrical (it's not required though). It also
+    #illustrates that you can apply an underscore to any task and it will be stripped by Antwrap.
+    @ant._if(){
+      _equals(:arg1 => "${bar}", :arg2 => "bar")
+      _then(){
+        echo(:message => "if 1 is equal")
+      }
+      _else(){
+        echo(:message => "if 1 is not equal")
+      }
+    }
+</code>
+</li>
+</pre>
+<pre><li>Content data is added via a 'pcdata' attribute:
+<code lang="ruby">
+    @ant.echo(:pcdata =&gt; "&lt;foo&amp;bar&gt;")
+</code>
+</li>
+<li>Antwrap includes a conversion script to take an existing Ant build file and convert it to a rake file. It will
+convert each Ant Target into a JRake task. It will also convert each and every Any Task into an Antwrap method call.
+Ant tasks that conflict with Ruby keywords are prepended with an
+underscore (see above).
+</li>
+<li>Antwrap is a Beta release. I'd love any feedback you can provide on your experence with it.
+There are no 3rd party jars required other than the Ant jar files in your JRuby Classpath.
+</li></pre>
+</ul>
+Comments or Questions? <br>
+Caleb Powell <br>
+caleb.powell@gmail.com <br>
+</body></html>

data/lib/antwrap.rb CHANGED

@@ -9,49 +9,41 @@ require 'logger'
 require 'java'
 module ApacheAnt
- include_class "org.apache.tools.ant.UnknownElement"
- include_class "org.apache.tools.ant.RuntimeConfigurable"
- include_class "org.apache.tools.ant.Project"
- include_class "org.apache.tools.ant.DefaultLogger"
+  include_class "org.apache.tools.ant.UnknownElement"
+  include_class "org.apache.tools.ant.RuntimeConfigurable"
+  include_class "org.apache.tools.ant.Project"
+  include_class "org.apache.tools.ant.DefaultLogger"
+  include_class "org.apache.tools.ant.Target"
+  include_class "org.apache.tools.ant.Main"
 end
 module JavaLang
- include_class "java.lang.System"
+  include_class "java.lang.System"
 end
-@@log = Logger.new(STDOUT)
-@@log.level = Logger::ERROR
 class AntTask
   private
   @@task_stack = Array.new
-  attr_reader :unknown_element, :project, :taskname
+  attr_reader :unknown_element, :project, :taskname, :logger
   public
-  def initialize(taskname, project, attributes, proc)
+  def initialize(taskname, antProject, attributes, proc)
     if(taskname[0,1] == "_")
       taskname = taskname[1, taskname.length-1]
     end
+    @logger = antProject.logger
+    @logger.debug("AntTask.taskname: #{taskname}, antProject:#{antProject}, atts:#{attributes.to_s}, proc:#{proc.to_s}")
     @taskname = taskname
-    @project = project
-    @unknown_element = ApacheAnt::UnknownElement.new(taskname)
-    @unknown_element.project= project
-    @unknown_element.namespace= ''
-    @unknown_element.QName= taskname
-    @unknown_element.taskType= taskname
-    @unknown_element.taskName= taskname
-    wrapper = ApacheAnt::RuntimeConfigurable.new(@unknown_element, @unknown_element.getTaskName());
-    attributes.each do |key, val|
-      if(key.to_s != 'pcdata')
-        wrapper.setAttribute(key.to_s, val)
-      else
-        wrapper.addText(val)
-      end
-    end unless attributes == nil
+    @project_wrapper = antProject
+    @project = antProject.project()
+    @logger.debug(@project)
+    @unknown_element = create_unknown_element(@project, taskname)
+    @logger.debug("1")
+    addAttributes(attributes)
+    @logger.debug("2")
     if proc
-      @@log.debug("task_stack.push #{taskname} >> #{@@task_stack}")
+      @logger.debug("task_stack.push #{taskname} >> #{@@task_stack}")
       @@task_stack.push self
       singleton_class = class << proc; self; end
@@ -63,20 +55,51 @@ class AntTask
       proc.instance_eval &proc
       @@task_stack.pop
     end
+    @logger.debug("3")
+  end
+  def create_unknown_element(project, taskname)
+    unknown_element = ApacheAnt::UnknownElement.new(taskname)
+    unknown_element.project= project
+    unknown_element.owningTarget= ApacheAnt::Target.new()
+    unknown_element.namespace= ''
+    unknown_element.QName= taskname
+    unknown_element.taskType= taskname
+    unknown_element.taskName= taskname
+    return unknown_element
+  end
+  def addAttributes(attributes)
+    wrapper = ApacheAnt::RuntimeConfigurable.new(@unknown_element, @unknown_element.getTaskName());
+    attributes.each do |key, val|
+      if(key.to_s != 'pcdata')
+        wrapper.setAttribute(key.to_s, val)
+      else
+        wrapper.addText(val)
+      end
+    end unless attributes == nil
   end
   def method_missing(sym, *args)
-    @@log.debug("AntTask.method_missing sym[#{sym.to_s}]")
+    @logger.debug("AntTask.method_missing sym[#{sym.to_s}]")
     begin
       proc = block_given? ? Proc.new : nil
-      self.add(AntTask.new(sym.to_s, project, args[0], proc))
+      if(@project_wrapper.ant_version < 1.6)
+        @logger.debug("Creating a 1.5. task")
+        task = Ant15Task.new(sym.to_s, @project_wrapper, args[0], proc)
+      else
+        task = AntTask.new(sym.to_s, @project_wrapper, args[0], proc)
+      end
+      self.add(task)
     rescue StandardError
-      @@log.error("AntTask.method_missing error:" + $!)
+      @logger.error("AntTask.method_missing error:" + $!)
     end
   end
   def add(child)
-    @@log.debug("adding child[#{child.unknown_element().getTaskName()}] to [#{@unknown_element.getTaskName()}]")
+    @logger.debug("adding child[#{child.unknown_element().getTaskName()}] to [#{@unknown_element.getTaskName()}]")
     @unknown_element.addChild(child.unknown_element())
     @unknown_element.getRuntimeConfigurableWrapper().addChild(child.unknown_element().getRuntimeConfigurableWrapper())
   end
@@ -91,47 +114,135 @@ class AntTask
     @executed
   end
+  #overridden. 'mkdir' conflicts wth the rake library.
+  def mkdir(attributes)
+    create_task('mkdir', attributes, (block_given? ? Proc.new : nil))
+  end
+  #overridden. 'copy' conflicts wth the rake library.
+  def copy(attributes)
+    create_task('copy', attributes, (block_given? ? Proc.new : nil))
+  end
+  #overridden. 'java' conflicts wth the JRuby library.
+  def jvm(attributes=Hash.new)
+    create_task('java', attributes, (block_given? ? Proc.new : nil))
+  end
+end
+class Ant15Task < AntTask
+  def create_unknown_element(project, taskname)
+    unknown_element = ApacheAnt::UnknownElement.new(taskname)
+    unknown_element.project= project
+    unknown_element.owningTarget= ApacheAnt::Target.new()
+    unknown_element.taskName= taskname
+    return unknown_element
+  end
+  def addAttributes(attributes)
+    wrapper = ApacheAnt::RuntimeConfigurable.new(@unknown_element, @unknown_element.getTaskName());
+    @unknown_element.setRuntimeConfigurableWrapper(wrapper)
+    attribute_list = org.xml.sax.helpers.AttributeListImpl.new
+    attributes.each do |key, val|
+      if(key.to_s != 'pcdata')
+        attribute_list.addAttribute(key.to_s, 'CDATA', val)
+      else
+        wrapper.addText(val)
+      end
+    end unless attributes == nil
+    wrapper.setAttributes(attribute_list)
+  end
 end
 class AntProject
   attr :project, false
+  attr :version, false
+  attr :ant_version, true
   attr :declarative, true
+  attr :logger, true
-  def initialize(name='', default='', basedir='',declarative=true)
+  # Create an AntProject. Parameters are specified via a hash:
+  # :name=><em>project_name</em>
+  #   -A String indicating the name of this project. Corresponds to the
+  #   'name' attrbute on an Ant project.
+  # :basedir=><em>project_basedir</em>
+  #   -A String indicating the basedir of this project. Corresponds to the 'basedir' attribute
+  #   on an Ant project.
+  # :declarative=><em>declarative_mode</em>
+  #   -A boolean value indicating wether Ant tasks created by this project instance should
+  #   have their execute() method invoked during their creation. For example, with
+  #   the option :declarative=>true the following task would execute;
+  #   @antProject.echo(:message => "An Echo Task")
+  #   However, with the option :declarative=>false, the programmer is required to execute the
+  #   task explicitly;
+  #   echoTask = @antProject.echo(:message => "An Echo Task")
+  #   echoTask.execute()
+  #   Default value is <em>true</em>.
+  # :logger=><em>Logger</em>
+  #   -A Logger instance. Defaults to Logger.new(STDOUT)
+  # :loglevel=><em>The level to set the logger to</em>
+  #   -Defaults to Logger::ERROR
+  def initialize(options=Hash.new)
     @project= ApacheAnt::Project.new
-    @project.name= name
-    @project.default= default
-    @project.basedir= basedir
+    @project.name= options[:name] || ''
+    @project.default= ''
+    @project.basedir= options[:basedir] || '.'
     @project.init
-    self.declarative= declarative
+    self.declarative= options[:declarative] || true
     default_logger = ApacheAnt::DefaultLogger.new
     default_logger.messageOutputLevel= 2
     default_logger.outputPrintStream= JavaLang::System.out
     default_logger.errorPrintStream= JavaLang::System.err
     default_logger.emacsMode= false
     @project.addBuildListener default_logger
+    @version = ApacheAnt::Main.getAntVersion
+    @ant_version = @version[/\d\.\d\.\d/].to_f
+    @logger = options[:logger] || Logger.new(STDOUT)
+    @logger.level = options[:loglevel] || Logger::ERROR
+    @logger.debug(@version)
   end
   def create_task(taskname, attributes, proc)
-    task = AntTask.new(taskname, project(), attributes, proc)
+    @logger.debug("Antproject.create_task.taskname = " + taskname)
+    @logger.debug("Antproject.create_task.attributes = " + attributes.to_s)
+    task = nil;
+    if(ant_version < 1.6)
+      task = Ant15Task.new(taskname, self, attributes, proc)
+    else
+      task = AntTask.new(taskname, self, attributes, proc)
+    end
     task.execute if declarative
     if taskname == 'macrodef'
-      @@log.debug("Pushing #{attributes[:name]} to tasks")
+      @logger.debug("Pushing #{attributes[:name]} to tasks")
     end
     task
   end
   def method_missing(sym, *args)
-      begin
-        @@log.info("AntProject.method_missing sym[#{sym.to_s}]")
-        proc = block_given? ? Proc.new : nil
-        return create_task(sym.to_s, args[0], proc)
-      rescue
-        @@log.error("Error instantiating task[#{sym.to_s}]" + $!)
-      end
+    begin
+      @logger.info("AntProject.method_missing sym[#{sym.to_s}]")
+      proc = block_given? ? Proc.new : nil
+      return create_task(sym.to_s, args[0], proc)
+    rescue
+      @logger.error("Error instantiating task[#{sym.to_s}]" + $!)
+    end
   end
+  def name()
+    return @project.name
+  end
+  def basedir()
+    return @project.getBaseDir().getAbsolutePath();
+  end
   #overridden. 'mkdir' conflicts wth the rake library.
   def mkdir(attributes)
     create_task('mkdir', attributes, (block_given? ? Proc.new : nil))

data/lib/convert.rb CHANGED

@@ -5,7 +5,7 @@
 # Licensed under the LGPL, see the file COPYING in the distribution
 #
 require 'rexml/document'
 if ARGV.empty?
     puts "Usage: #{$0} [antfile] [rakefile]"
     exit! 1
@@ -17,7 +17,7 @@ end
                     'def',  'defined',  'do',  'else',  'elsif',  'END',  'end',  'ensure',
                     'false',  'for',  'if',  'in',  'module',  'next',  'nil',  'not',  'or',
                     'redo',  'rescue',  'retry',  'return',  'self',  'super',  'then',  'true',
-                    'undef',  'unless',  'until',  'when',  'while',  'yield']
+                    'undef',  'unless',  'until',  'when',  'while',  'yield', 'java']
 xml = REXML::Document.new(@antfile)
@@ -49,7 +49,10 @@ def print_task(task, tab=@one_tab, prefix='')
   if(task_name == 'macrodef')
     task.attributes['name'] = rubyize(task.attributes['name'])
+  elsif(task_name == 'java')
+    task_name = 'jvm'
   end
   isFirst = true;
   task.attributes.each do |key, value|
     if !isFirst

data/test/tc_antwrap.rb CHANGED

@@ -15,10 +15,16 @@ class TestAntwrap < Test::Unit::TestCase
     #   @output_dir = ENV['PWD'] + '/output'
     #   @resource_dir = ENV['PWD'] + '/test-resources'
     #   The following is a workaround
-    current_dir = Java::java.lang.System.getProperty("user.dir")
-    @ant = AntProject.new("testProject", "", current_dir, true)
-    @output_dir = current_dir + '/test/output'
-    @resource_dir = current_dir + '/test/test-resources'
+    @current_dir = Java::java.lang.System.getProperty("user.dir")
+    @ant_proj_props = {:name=>"testProject", :basedir=>@current_dir, :declarative=>true,
+                        :logger=>Logger.new(STDOUT), :loglevel=>Logger::DEBUG}
+    @ant = AntProject.new(@ant_proj_props)
+    assert(@ant_proj_props[:name] == @ant.name())
+    assert(@ant_proj_props[:basedir] == @ant.basedir())
+    assert(@ant_proj_props[:declarative] == @ant.declarative())
+    @output_dir = @current_dir + '/test/output'
+    @resource_dir = @current_dir + '/test/test-resources'
     if File.exists?(@output_dir)
       FileUtils.remove_dir(@output_dir)
@@ -26,10 +32,16 @@ class TestAntwrap < Test::Unit::TestCase
     FileUtils.mkdir(@output_dir, :mode => 0775)
   end
-  def teardown
+  def test_antproject_init
+    @ant_proj_props = {:name=>"testProject", :declarative=>true,
+                        :logger=>Logger.new(STDOUT), :loglevel=>Logger::ERROR}
+    ant_proj = AntProject.new(@ant_proj_props)
+    assert(@ant_proj_props[:name] == ant_proj.name())
+    assert(@current_dir == ant_proj.basedir())
+    assert(@ant_proj_props[:declarative] == ant_proj.declarative())
+    assert(@ant_proj_props[:logger] == ant_proj.logger())
   end
   def test_unzip_task
     assert_absent @output_dir + '/parent/FooBarParent.class'
     task = @ant.unzip(:src => @resource_dir + '/parent.jar',
@@ -49,11 +61,6 @@ class TestAntwrap < Test::Unit::TestCase
     assert_absent file
   end
-  #  <javac srcdir='${src}'
-  #         destdir='${build}'
-  #         classpath='xyz.jar'
-  #         debug='on'
-  #         source='1.4'/>
   def test_javac_task
     FileUtils.mkdir(@output_dir + '/classes', :mode => 0775)
@@ -77,12 +84,6 @@ class TestAntwrap < Test::Unit::TestCase
     FileUtils.mkdir(@output_dir + '/classes', :mode => 0775)
     assert_absent @output_dir + '/classes/foo/bar/FooBar.class'
-    #    <path id="common.class.path">
-    #        <fileset dir="${common.dir}/lib">
-    #            <include name="**/*.jar"/>
-    #        </fileset>
-    #        <pathelement location="${common.classes}"/>
-    #    </path>
     @ant.property(:name => 'pattern', :value => '**/*.jar')
     @ant.property(:name => 'resource_dir', :value => @resource_dir)
     @ant.path(:id => 'common.class.path'){
@@ -94,7 +95,7 @@ class TestAntwrap < Test::Unit::TestCase
     @ant.javac(:srcdir => @resource_dir + '/src',
     :destdir => @output_dir + '/classes',
     :debug => 'on',
-    :verbose => 'no',
+    :verbose => 'yes',
     :fork => 'no',
     :failonerror => 'yes',
     :includes => 'foo/bar/**',
@@ -105,27 +106,21 @@ class TestAntwrap < Test::Unit::TestCase
     assert_absent @output_dir + '/classes/foo/bar/baz/FooBarBaz.class'
   end
-  #  <jar destfile='${dist}/lib/app.jar' basedir='${build}/classes'/>
   def test_jar_task
     assert_absent @output_dir + '/Foo.jar'
     @ant.property(:name => 'outputdir', :value => @output_dir)
     @ant.property(:name => 'destfile', :value => '${outputdir}/Foo.jar')
     @ant.jar( :destfile => "${destfile}",
     :basedir => @resource_dir + '/src',
-    :level => '9',
     :duplicate => 'preserve')
     assert_exists @output_dir + '/Foo.jar'
   end
-  # <java classname="test.Main">
-  #    <arg value="-h"/>
-  #    <classpath>
-  #    <pathelement location="dist/test.jar"/>
-  #    <pathelement path="${java.class.path}"/>
-  #    </classpath>
-  # </java>
   def test_java_task
+    return if @ant.ant_version < 1.7
     FileUtils.mkdir(@output_dir + '/classes', :mode => 0775)
     @ant.javac(:srcdir => @resource_dir + '/src',
     :destdir => @output_dir + '/classes',
@@ -139,20 +134,21 @@ class TestAntwrap < Test::Unit::TestCase
     @ant.property(:name => 'output_dir', :value => @output_dir)
     @ant.property(:name => 'resource_dir', :value =>@resource_dir)
-    @ant.jvm(:classname => 'foo.bar.FooBar', :fork => 'no') {
+    @ant._java(:classname => 'foo.bar.FooBar', :fork => 'false') {
       arg(:value => 'argOne')
       classpath(){
         pathelement(:location => '${output_dir}/classes')
         pathelement(:location => '${resource_dir}/parent.jar')
       }
       arg(:value => 'argTwo')
-      jvmarg(:value => 'server')
+      jvmarg(:value => 'client')
       sysproperty(:key=> 'antwrap', :value => 'coolio')
     }
   end
   def test_echo_task
     @ant.echo(:message => "Antwrap is running an Echo task", :level => 'info')
+    @ant.echo(:pcdata => "<foo&bar>")
   end
   def test_mkdir_task
@@ -177,6 +173,9 @@ class TestAntwrap < Test::Unit::TestCase
   end
   def test_macrodef_task
+    return if @ant.ant_version < 1.6
     dir = @output_dir + '/foo'
     assert_absent dir
@@ -185,12 +184,11 @@ class TestAntwrap < Test::Unit::TestCase
       attribute(:name => 'destination')
       sequential(){
         echo(:message => "Creating @{destination}")
-        mkdir(:dir => "@{destination}")
+        _mkdir(:dir => "@{destination}")
       }
-    }
+    }
     @ant.testmacrodef(:destination => dir)
     assert_exists dir
   end
   def test_cdata
@@ -198,25 +196,9 @@ class TestAntwrap < Test::Unit::TestCase
   end
   def test_ant_contrib
-    #<if>
-    # <equals arg1="${foo}" arg2="bar" />
-    # <then>
-    #   <echo message="The value of property foo is 'bar'" />
-    # </then>
-    #
-    # <elseif>
-    #  <equals arg1="${foo}" arg2="foo" />
-    #  <then>
-    #   <echo message="The value of property foo is 'foo'" />
-    #  </then>
-    # </elseif>
-    #
-    #
-    # <else>
-    #   <echo message="The value of property foo is not 'foo' or 'bar'" />
-    # </else>
-    #</if>
-    #
+    return if @ant.ant_version < 1.6
     @ant.taskdef(:resource => "net/sf/antcontrib/antlib.xml")
     @ant.property(:name => "bar", :value => "bar")
@@ -242,6 +224,7 @@ class TestAntwrap < Test::Unit::TestCase
     }
   end
   private
   def assert_exists(file_path)
     assert(File.exists?(file_path), "Does not exist[#{file_path}]")

metadata CHANGED

@@ -3,9 +3,10 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: Antwrap
 version: !ruby/object:Gem::Version
-  version: "0.2"
-date: 2007-01-30
-summary: A JRuby module that wraps the Apache Ant build tool
+  version: "0.3"
+date: 2007-02-19
+summary: "A JRuby module that wraps the Apache Ant build tool, enabling Ant Tasks to be
+  invoked from a JRuby script."
 require_paths:
   - lib
 email: caleb.powell@gmail.com
@@ -32,11 +33,9 @@ files:
   - test/output
   - test/tc_antwrap.rb
   - test/tc_convert.rb
+  - test/test
   - test/test-resources
-  - test/output/classes
-  - test/output/classes/foo
-  - test/output/classes/foo/bar
-  - test/output/classes/foo/bar/FooBar.class
+  - test/test/output
   - test/test-resources/build.xml
   - test/test-resources/foo.txt
   - test/test-resources/foo.zip
@@ -50,6 +49,7 @@ files:
   - test/test-resources/src/foo/bar/baz
   - test/test-resources/src/foo/bar/FooBar.java
   - test/test-resources/src/foo/bar/baz/FooBarBaz.java
+  - docs/index.html
   - README
   - COPYING
 test_files:

data/test/output/classes/foo/bar/FooBar.class DELETED

Binary file