RubyGems - Antwrap - Versions diffs - 0.5.0-java - Mend

Antwrap 0.5.0-java

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 (18) hide show

data/COPYING +504 -0
data/README +12 -0
data/docs/index.html +100 -0
data/lib/antwrap.rb +210 -0
data/lib/jruby_modules.rb +14 -0
data/lib/rjb_modules.rb +16 -0
data/test/output/META-INF/MANIFEST.MF +3 -0
data/test/output/parent/FooBarParent.class +0 -0
data/test/tc_antwrap.rb +260 -0
data/test/tc_convert.rb +34 -0
data/test/test-resources/build.xml +340 -0
data/test/test-resources/foo.txt +0 -0
data/test/test-resources/foo.zip +0 -0
data/test/test-resources/parent-src/parent/FooBarParent.java +19 -0
data/test/test-resources/parent.jar +0 -0
data/test/test-resources/src/foo/bar/FooBar.java +26 -0
data/test/test-resources/src/foo/bar/baz/FooBarBaz.java +7 -0
metadata +67 -0

data/README ADDED Viewed

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

data/docs/index.html ADDED Viewed

@@ -0,0 +1,100 @@
+<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=&gt false})
+    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. Reserved words like this can be worked around by simply prepending an
+underscore character ('_') to the task:
+<code lang="ruby">
+    #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 ADDED Viewed

@@ -0,0 +1,210 @@
+# antwrap
+#
+# Copyright Caleb Powell 2007
+#
+# Licensed under the LGPL, see the file COPYING in the distribution
+#
+if(RUBY_PLATFORM == 'java')
+  require 'jruby_modules.rb'
+else
+  require 'rjb_modules.rb'
+end
+class AntTask
+  private
+  @@task_stack = Array.new
+  attr_accessor(:unknown_element, :project, :taskname, :logger, :executed)
+  def create_unknown_element(project, taskname)
+    element = ApacheAnt::UnknownElement.new(taskname)
+    element.setProject(project)
+    element.setOwningTarget(ApacheAnt::Target.new())
+    element.setTaskName(taskname)
+    if(@project_wrapper.ant_version >= 1.6)
+      element.setTaskType(taskname)
+      element.setNamespace('')
+      element.setQName(taskname)
+    end
+    return element
+  end
+  def method_missing(sym, *args)
+    begin
+      @logger.debug("AntTask.method_missing sym[#{sym.to_s}]")
+      task = AntTask.new(sym.to_s, @project_wrapper, args[0], block_given? ? Proc.new : nil)
+      self.add(task)
+    rescue StandardError
+      @logger.error("AntTask.method_missing error:" + $!)
+    end
+  end
+  public
+  def initialize(taskname, antProject, attributes, proc)
+    taskname = taskname[1, taskname.length-1] if taskname[0,1] == "_"
+    @logger = antProject.logger
+    @taskname = taskname
+    @project_wrapper = antProject
+    @project = antProject.project()
+    @logger.debug(antProject.to_s)
+    @unknown_element = create_unknown_element(@project, taskname)
+    @logger.debug(to_s)
+    addAttributes(attributes)
+    if proc
+#      @logger.debug("task_stack.push #{taskname} >> #{@@task_stack}")
+      @@task_stack.push self
+      singleton_class = class << proc; self; end
+      singleton_class.module_eval{
+        def method_missing(m, *a, &proc)
+          @@task_stack.last().send(m, *a, &proc)
+        end
+      }
+      proc.instance_eval &proc
+      @@task_stack.pop
+    end
+  end
+  # Sets each attribute on the AntTask instance.
+  # :attributes - is a Hash.
+  def addAttributes(attributes)
+    return if attributes == nil
+    wrapper = ApacheAnt::RuntimeConfigurable.new(@unknown_element, @unknown_element.getTaskName());
+    outer_func = lambda{ |key, val, tfunc|  key == 'pcdata' ? wrapper.addText(val) : tfunc.call(key, val) }
+    if(@project_wrapper.ant_version >= 1.6)
+      attributes.each do |key, val|
+        outer_func.call(key.to_s, val, lambda{|k,v| wrapper.setAttribute(k, val)})
+      end
+    else
+      @unknown_element.setRuntimeConfigurableWrapper(wrapper)
+      attribute_list = org.xml.sax.helpers.AttributeListImpl.new()
+      attributes.each do |key, val|
+        outer_func.call(key.to_s, val, lambda{|k,v| attribute_list.addAttribute(k, 'CDATA', v)})
+      end
+      wrapper.setAttributes(attribute_list)
+    end
+  end
+  #Add <em>child</em> as a child of this task.
+  def add(child)
+#    @logger.debug("adding child[#{child.taskname()}] to [#{@taskname}]")
+    @unknown_element.addChild(child.getUnknownElement())
+    @unknown_element.getRuntimeConfigurableWrapper().addChild(child.getUnknownElement().getRuntimeConfigurableWrapper())
+  end
+  def getUnknownElement
+    return @unknown_element
+  end
+  #Invokes the AntTask.
+  def execute
+    @unknown_element.maybeConfigure
+    @unknown_element.execute
+    @executed = true
+  end
+  def to_s
+    return self.class.name + "[#{@taskname}]"
+  end
+end
+class AntProject
+  require 'logger'
+  attr :project, false
+  attr :version, false
+  attr :ant_version, true
+  attr :declarative, true
+  attr :logger, 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.setName(options[:name] || '')
+    @project.setDefault('')
+    @project.setBasedir(options[:basedir] || '.')
+    @project.init
+    self.declarative= options[:declarative] || true
+    default_logger = ApacheAnt::DefaultLogger.new
+    default_logger.setMessageOutputLevel(2)
+    default_logger.setOutputPrintStream(options[:outputstr] || JavaLang::System.out)
+    default_logger.setErrorPrintStream(options[:errorstr] || JavaLang::System.err)
+    default_logger.setEmacsMode(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)
+    @logger.debug("AntProject.create_task.taskname = " + taskname)
+    @logger.debug("AntProject.create_task.attributes = " + attributes.to_s)
+    task = AntTask.new(taskname, self, attributes, proc)
+    task.execute if declarative
+    return task
+  end
+  def method_missing(sym, *args)
+    begin
+      @logger.debug("AntProject.method_missing sym[#{sym.to_s}]")
+      return create_task(sym.to_s, args[0], block_given? ? Proc.new : nil)
+    rescue
+      @logger.error("Error instantiating task[#{sym.to_s}]" + $!)
+    end
+  end
+  #The Ant Project's name. Default is ''.
+  def name()
+    return @project.getName
+  end
+  #The Ant Project's basedir. Default is '.'.
+  def basedir()
+    return @project.getBaseDir().getAbsolutePath();
+  end
+  def to_s
+    return self.class.name + "[#{@project.getName()}]"
+  end
+  #This method invokes create_task. It is here to prevent conflicts wth the JRuby library
+  #over the 'java' symbol.
+  def java(attributes=Hash.new)
+    create_task('java', attributes, (block_given? ? Proc.new : nil))
+  end
+end

data/lib/jruby_modules.rb ADDED Viewed

@@ -0,0 +1,14 @@
+module ApacheAnt
+  require 'java'
+  include_class "org.apache.tools.ant.DefaultLogger"
+  include_class "org.apache.tools.ant.Main"
+  include_class "org.apache.tools.ant.Project"
+  include_class "org.apache.tools.ant.RuntimeConfigurable"
+  include_class "org.apache.tools.ant.Target"
+  include_class "org.apache.tools.ant.UnknownElement"
+end
+module JavaLang
+  require 'java'
+  include_class "java.lang.System"
+end

data/lib/rjb_modules.rb ADDED Viewed

@@ -0,0 +1,16 @@
+module ApacheAnt
+  require 'rubygems'
+  require 'rjb'
+  DefaultLogger =  Rjb::import("org.apache.tools.ant.DefaultLogger")
+  Main = Rjb::import("org.apache.tools.ant.Main")
+  Project = Rjb::import("org.apache.tools.ant.Project")
+  RuntimeConfigurable = Rjb::import("org.apache.tools.ant.RuntimeConfigurable")
+  Target = Rjb::import("org.apache.tools.ant.Target")
+  UnknownElement = Rjb::import("org.apache.tools.ant.UnknownElement")
+end
+module JavaLang
+  require 'rubygems'
+  require 'rjb'
+  System = Rjb::import("java.lang.System")
+end

data/test/output/META-INF/MANIFEST.MF ADDED Viewed

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Created-By: 1.5.0_06 (Apple Computer, Inc.)

data/test/output/parent/FooBarParent.class ADDED Viewed

Binary file

data/test/tc_antwrap.rb ADDED Viewed

@@ -0,0 +1,260 @@
+# antwrap
+#
+# Copyright Caleb Powell 2007
+#
+# Licensed under the LGPL, see the file COPYING in the distribution
+#
+require 'test/unit'
+require 'fileutils'
+$LOAD_PATH.push(ENV['PWD'] + '/lib')
+require 'antwrap'
+require 'logger'
+#class TestStream < java.io.PrintStream
+#    attr_reader :last_line
+#
+#    def initialise(out)
+#      self.super(out)
+#    end
+#
+#    def println(s)
+#      puts "s"
+#      @last_line = s
+#      self.super(s)
+#    end
+#
+#    def print(s)
+#      puts "s"
+#      @last_line = s
+#      self.super(s)
+#    end
+#end
+class TestAntwrap < Test::Unit::TestCase
+  def setup
+    @current_dir = ENV['PWD']
+    @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)
+    end
+    FileUtils.mkdir(@output_dir, :mode => 0775)
+  end
+  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',
+    :dest => @output_dir)
+    assert_exists @output_dir + '/parent/FooBarParent.class'
+  end
+  def test_copyanddelete_task
+    file = @output_dir + '/foo.txt'
+    assert_absent file
+    @ant.copy(:file => @resource_dir + '/foo.txt',
+    :todir => @output_dir)
+    assert_exists file
+    @ant.delete(:file => file)
+    assert_absent file
+  end
+  def test_javac_task
+    FileUtils.mkdir(@output_dir + '/classes', :mode => 0775)
+    assert_absent @output_dir + '/classes/foo/bar/FooBar.class'
+    @ant.javac(:srcdir => @resource_dir + '/src',
+    :destdir => @output_dir + '/classes',
+    :debug => 'on',
+    :verbose => 'no',
+    :fork => 'no',
+    :failonerror => 'yes',
+    :includes => 'foo/bar/**',
+    :excludes => 'foo/bar/baz/**',
+    :classpath => @resource_dir + '/parent.jar')
+    assert_exists @output_dir + '/classes/foo/bar/FooBar.class'
+    assert_absent @output_dir + '/classes/foo/bar/baz/FooBarBaz.class'
+  end
+  def test_javac_task_with_property
+    FileUtils.mkdir(@output_dir + '/classes', :mode => 0775)
+    assert_absent @output_dir + '/classes/foo/bar/FooBar.class'
+    @ant.property(:name => 'pattern', :value => '**/*.jar')
+    @ant.property(:name => 'resource_dir', :value => @resource_dir)
+      @ant.path(:id => 'common.class.path'){
+        fileset(:dir => '${resource_dir}'){
+          include(:name => '${pattern}')
+        }
+      }
+    @ant.javac(:srcdir => @resource_dir + '/src',
+    :destdir => @output_dir + '/classes',
+    :debug => 'on',
+    :verbose => 'yes',
+    :fork => 'no',
+    :failonerror => 'yes',
+    :includes => 'foo/bar/**',
+    :excludes => 'foo/bar/baz/**',
+    :classpathref => 'common.class.path')
+    assert_exists @output_dir + '/classes/foo/bar/FooBar.class'
+    assert_absent @output_dir + '/classes/foo/bar/baz/FooBarBaz.class'
+  end
+  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',
+    :duplicate => 'preserve')
+    assert_exists @output_dir + '/Foo.jar'
+  end
+  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',
+    :debug => 'on',
+    :verbose => 'no',
+    :fork => 'no',
+    :failonerror => 'yes',
+    :includes => 'foo/bar/**',
+    :excludes => 'foo/bar/baz/**',
+    :classpath => @resource_dir + '/parent.jar')
+    @ant.property(:name => 'output_dir', :value => @output_dir)
+    @ant.property(:name => 'resource_dir', :value =>@resource_dir)
+    @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')
+    }
+  end
+  def test_echo_task
+#    stream = TestStream.new(java.lang.System.out)
+#
+#    @ant = AntProject.new({:name=>"testProject", :basedir=>@current_dir, :declarative=>true,
+#                        :logger=>Logger.new(STDOUT), :loglevel=>Logger::DEBUG, :outputstr => stream})
+    msg = "Antwrap is running an Echo task"
+    @ant.echo(:message => msg, :level => 'info')
+#    assert(stream.last_line, stream.last_line == msg)
+    @ant.echo(:pcdata => "<foo&bar>")
+  end
+  def test_mkdir_task
+    dir = @output_dir + '/foo'
+    assert_absent dir
+    @ant.mkdir(:dir => dir)
+    assert_exists dir
+  end
+  def test_mkdir_task_with_property
+    dir = @output_dir + '/foo'
+    assert_absent dir
+    @ant.property(:name => 'outputProperty', :value => dir)
+    @ant.mkdir(:dir => "${outputProperty}")
+    assert_exists dir
+  end
+  def test_macrodef_task
+    return if @ant.ant_version < 1.6
+    dir = @output_dir + '/foo'
+    assert_absent dir
+    @ant.macrodef(:name => 'testmacrodef'){
+      attribute(:name => 'destination')
+      sequential(){
+        echo(:message => "Creating @{destination}")
+        _mkdir(:dir => "@{destination}")
+      }
+    }
+    @ant.testmacrodef(:destination => dir)
+    assert_exists dir
+  end
+  def test_cdata
+    @ant.echo(:pcdata => "Foobar &amp; <><><>")
+  end
+  def test_ant_contrib
+    return if @ant.ant_version < 1.6
+    @ant.taskdef(:resource => "net/sf/antcontrib/antlib.xml")
+    @ant.property(:name => "bar", :value => "bar")
+    @ant._if(){
+      _equals(:arg1 => "${bar}", :arg2 => "bar")
+      _then(){
+        echo(:message => "if 1 is equal")
+      }
+      _else(){
+        echo(:message => "if 1 is not equal")
+      }
+    }
+    @ant.property(:name => "baz", :value => "foo")
+    @ant._if(){
+      _equals(:arg1 => "${baz}", :arg2 => "bar")
+      _then(){
+        echo(:message => "if 2 is equal")
+      }
+      _else(){
+        echo(:message => "if 2 is not equal")
+      }
+    }
+  end
+  private
+  def assert_exists(file_path)
+    assert(File.exists?(file_path), "Does not exist[#{file_path}]")
+  end
+  def assert_absent(file_path)
+    assert(!File.exists?(file_path), "Should not exist[#{file_path}]")
+  end
+end