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

Antwrap 0.5.0-java

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