Antwrap 0.5.4 → 0.6.0

data/lib/antwrap_utilities.rb

@@ -1,31 +1,34 @@
-if(RUBY_PLATFORM == 'java')
-  require 'java'
-  autoload :ApacheAnt, 'jruby_modules.rb'
-  autoload :JavaLang, 'jruby_modules.rb'
-  autoload :XmlOrg, 'jruby_modules.rb'
-else
-  require 'rubygems'
-  require 'rjb'
-  autoload :ApacheAnt, 'rjb_modules.rb'
-  autoload :JavaLang, 'rjb_modules.rb'
-  autoload :XmlOrg, 'rjb_modules.rb'
-end
+# antwrap_utilities.rb
+#
+# Copyright Caleb Powell 2007
+#
+# Licensed under the LGPL, see the file COPYING in the distribution
+#
 
 module AntwrapClassLoader
+  
   require 'find'
+  
   def match(*paths)
-    matched=[]
+    
+    matched = Array.new 
     Find.find(*paths){ |path| matched << path if yield path }
     return matched
+    
   end
   
   def load_ant_libs(ant_home)
-    jars = match(ant_home + '/lib') {|p| ext = p[-4...p.size]; ext && ext.downcase == '.jar'} 
+    
+    jars = match(ant_home + File::SEPARATOR + 'lib') {|p| ext = p[-4...p.size]; ext && ext.downcase == '.jar'} 
+    
     if(RUBY_PLATFORM == 'java')
       jars.each {|jar| require jar }
     else
-      Rjb::load(jars.join(":"), [])
+      Rjb::load(jars.join(File::PATH_SEPARATOR), [])
     end
+    
   end
+  
   module_function :match, :load_ant_libs
+  
 end

data/lib/jruby_modules.rb

@@ -1,3 +1,10 @@
+# jruby_modules.rb
+#
+# Copyright Caleb Powell 2007
+#
+# Licensed under the LGPL, see the file COPYING in the distribution
+
+
 module ApacheAnt
   include_class "org.apache.tools.ant.DefaultLogger"
   include_class "org.apache.tools.ant.Main"

data/lib/rjb_modules.rb

@@ -1,3 +1,10 @@
+# rjb_modules.rb
+#
+# Copyright Caleb Powell 2007
+#
+# Licensed under the LGPL, see the file COPYING in the distribution
+#
+
 module ApacheAnt
   DefaultLogger =  Rjb::import("org.apache.tools.ant.DefaultLogger")
   Main = Rjb::import("org.apache.tools.ant.Main")

data/test/{tc_antwrap.rb → antwrap_test.rb}

@@ -4,23 +4,23 @@
 #
 # Licensed under the LGPL, see the file COPYING in the distribution
 #
+
 require 'test/unit'
 require 'fileutils'
-$LOAD_PATH.push(ENV['PWD'] + '/lib')
+$LOAD_PATH.push(FileUtils::pwd + '/lib')
 require 'antwrap'
 require 'logger'
 
-class TestAntwrap < Test::Unit::TestCase
+class AntwrapTest < Test::Unit::TestCase
   
   def setup
-    @current_dir = ENV['PWD']
-    @output_dir = @current_dir + '/test/output'
-    @resource_dir = @current_dir + '/test/test-resources'
+    @output_dir = FileUtils::pwd + File::SEPARATOR + 'test' + File::SEPARATOR + 'output'
+    @resource_dir = FileUtils::pwd  + File::SEPARATOR + 'test' + File::SEPARATOR + 'test-resources'
     
-    @ant_home = @resource_dir + "/apache-ant-1.7.0"
+    @ant_home = @resource_dir  + File::SEPARATOR + "apache-ant-1.7.0"
 #    @ant_home = "/Users/caleb/tools/apache-ant-1.6.5"
 #    @ant_home = "/Users/caleb/tools/apache-ant-1.5.4"
-    @ant_proj_props = {:name=>"testProject", :basedir=>@current_dir, :declarative=>true, 
+    @ant_proj_props = {:name=>"testProject", :basedir=>FileUtils::pwd, :declarative=>true, 
                         :logger=>Logger.new(STDOUT), :loglevel=>Logger::DEBUG, :ant_home => @ant_home}
     @ant = AntProject.new(@ant_proj_props)
     
@@ -35,7 +35,7 @@ class TestAntwrap < Test::Unit::TestCase
                         :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(FileUtils::pwd == ant_proj.basedir())
     assert(@ant_proj_props[:declarative] == ant_proj.declarative())
     assert(@ant_proj_props[:logger] == ant_proj.logger())
   end
@@ -83,14 +83,14 @@ class TestAntwrap < Test::Unit::TestCase
     @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.fileset(:dir => '${resource_dir}'){
+        @ant.include(:name => '${pattern}')
       }
     }
-    
+    puts "Resource dir: #{@resource_dir}"
     @ant.javac(:srcdir => @resource_dir + '/src', 
     :destdir => @output_dir + '/classes',
-    :debug => 'on',
+    :debug => true,
     :verbose => true,
     :fork => 'no',
     :failonerror => 'blahblahblah',
@@ -130,15 +130,15 @@ class TestAntwrap < Test::Unit::TestCase
     
     @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')
+    @ant.java(:classname => 'foo.bar.FooBar', :fork => 'false') {|ant|
+      ant.arg(:value => 'argOne')
+      ant.classpath(){
+        ant.pathelement(:location => '${output_dir}/classes')
+        ant.pathelement(:location => '${resource_dir}/parent.jar')
       }
-      arg(:value => 'argTwo')
-      jvmarg(:value => 'client')
-      sysproperty(:key=> 'antwrap', :value => 'coolio')
+      ant.arg(:value => 'argTwo')
+      ant.jvmarg(:value => 'client')
+      ant.sysproperty(:key=> 'antwrap', :value => 'coolio')
     }
   end
   
@@ -178,11 +178,11 @@ class TestAntwrap < Test::Unit::TestCase
     
     assert_absent dir
     
-    @ant.macrodef(:name => 'testmacrodef'){
-      attribute(:name => 'destination')
-      sequential(){
-        echo(:message => "Creating @{destination}")
-        _mkdir(:dir => "@{destination}")
+    @ant.macrodef(:name => 'testmacrodef'){|ant|
+      ant.attribute(:name => 'destination')
+      ant.sequential(){
+        ant.echo(:message => "Creating @{destination}")
+        ant._mkdir(:dir => "@{destination}")
       }
     }      
     @ant.testmacrodef(:destination => dir)
@@ -200,24 +200,24 @@ class TestAntwrap < Test::Unit::TestCase
     @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")
+    @ant._if(){|ant|
+      ant._equals(:arg1 => "${bar}", :arg2 => "bar")
+      ant._then(){
+        ant.echo(:message => "if 1 is equal")
       }
-      _else(){
-        echo(:message => "if 1 is not equal")
+      ant._else(){
+        ant.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")
+    @ant._if(){|ant|
+      ant._equals(:arg1 => "${baz}", :arg2 => "bar")
+      ant._then(){
+        ant.echo(:message => "if 2 is equal")
       }
-      _else(){
-        echo(:message => "if 2 is not equal")
+      ant._else(){
+        ant.echo(:message => "if 2 is not equal")
       }
     }
 
@@ -234,16 +234,17 @@ class TestAntwrap < Test::Unit::TestCase
     rescue ArgumentError
     end
   end
-#  def test_open_pja
-#    @ant.taskdef(:name=>"mappingtool", :classname=>"org.apache.openjpa.jdbc.ant.MappingToolTask") 
-#    
-#    @ant.mappingtool(:action => "buildSchema"){
-#      fileset(:dir => "."){
-#        include(:name => "**/*.jdo")
-#      }
-#    }
-#  end
   
+  def test_declarative
+    @ant = AntProject.new({:declarative=>false,:loglevel=>Logger::DEBUG, :ant_home => @ant_home})
+    echo = @ant.echo(:message => "Echo")
+    assert_not_nil(echo)
+
+    @ant = AntProject.new({:declarative=>true,:loglevel=>Logger::DEBUG, :ant_home => @ant_home})
+    echo = @ant.echo(:message => "Echo")
+    assert_nil(echo)
+  end
+    
   private 
   def assert_exists(file_path)
     assert(File.exists?(file_path), "Does not exist[#{file_path}]")

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: Antwrap
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
-date: 2007-06-13
+  version: 0.6.0
+date: 2007-06-18
 summary: "A Ruby module that wraps the Apache Ant build tool, enabling Ant Tasks to be
   invoked from a Ruby/JRuby scripts."
 require_paths: 
@@ -28,16 +28,15 @@ platform: ruby
 authors: 
   - Caleb Powell
 files: 
+  - lib/ant_project.rb
+  - lib/ant_task.rb
   - lib/antwrap.rb
   - lib/antwrap_utilities.rb
-  - lib/convert.rb
-  - lib/dsl.rb
   - lib/jruby_modules.rb
   - lib/rjb_modules.rb
+  - test/antwrap_test.rb
   - test/build.xml
   - test/output
-  - test/tc_antwrap.rb
-  - test/tc_convert.rb
   - test/test-resources
   - test/output/META-INF
   - test/output/parent
@@ -57,10 +56,15 @@ files:
   - test/test-resources/src/foo/bar/FooBar.java
   - test/test-resources/src/foo/bar/baz/FooBarBaz.java
   - docs/index.html
+  - docs/index_files
+  - docs/index_files/blankdot.gif
+  - docs/index_files/blankdot.html
+  - docs/index_files/Brander.css
+  - docs/index_files/urchin.js
   - README
   - COPYING
 test_files: 
-  - test/tc_antwrap.rb
+  - test/antwrap_test.rb
 rdoc_options: []
 extra_rdoc_files: 
   - README

data/lib/convert.rb

@@ -1,104 +0,0 @@
-# antwrap
-#
-# Copyright Caleb Powell 2007
-#
-# Licensed under the LGPL, see the file COPYING in the distribution
-#
-require 'rexml/document'
- 
-if ARGV.empty?
-    puts "Usage: #{$0} [antfile] [rakefile]" 
-    exit! 1
-end
-
-@antfile = File.open(ARGV[0])
-@rakefile = File.new(ARGV[1], 'w+')
-@@reserved_words = ['alias',  'and',  'BEGIN',  'begin',  'break',  'case',  'class',  
-                    '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', 'java']
-
-xml = REXML::Document.new(@antfile)
-
-puts "Converting from Ant build script[#{@antfile.path}] == to ==> \n Rakefile[#{@rakefile.path}]"
-
-def create_symbol(str)
-    str = rubyize(str)    
-    return str.gsub(/(\w*[^,\s])/, ':\1')
-end
-
-def rubyize(str)
-  if (str == nil) 
-    str = ''
-  elsif (@@reserved_words.index(str) != nil)
-    str = '_' + str
-  else
-    str = str.gsub(/(\w*)[\-|\.](\w*)/, '\1_\2')
-  end
-  return str
-end
-
-
-@rakefile.print "require_gem 'Antwrap'\n"
-@rakefile.print "@ant = AntProject.new()\n"
-@one_tab= '   '
-def print_task(task, tab=@one_tab, prefix='')
-  task_name = rubyize(task.name)
-  @rakefile.print "#{tab}#{prefix}#{task_name}("
-  
-  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 
-      @rakefile.print(",\n#{tab+@one_tab}")
-    end
-    @rakefile.print ":#{key} => \"#{value}\""
-    isFirst = false;
-  end
-  
-  if task.has_text?
-    pcdata = task.texts().join
-    if(pcdata.strip() != '')
-      @rakefile.print ":pcdata => \"#{pcdata}\""  
-    end
-  end
-  @rakefile.print ")"
-  
-  
-  if task.elements.size > 0 
-    @rakefile.print "{"
-    task.elements.each do |child|
-      @rakefile.print "\n"
-      print_task(child, (tab+@one_tab), '')
-    end
-    @rakefile.print "\n#{tab}}"
-  end
-end
-
-xml.elements.each("/project/*") do |node|
-  if node.name != 'target'
-    print_task(node, '', '@ant.')
-    @rakefile.print "\n\n"
-  end
-end
-
-xml.elements.each("/project/target") do |node|
-  
-    task = "\ntask " + create_symbol(node.attributes['name']) + 
-         " => [" + create_symbol(node.attributes['depends']) + "] do\n"
-    
-    @rakefile.print task
-    
-    node.elements.each do |child|
-      print_task(child, @one_tab, '@ant.')
-      @rakefile.print "\n"
-    end
-    @rakefile.print "end\n"
-end
-

data/lib/dsl.rb

@@ -1,163 +0,0 @@
-# A Domain Specific Language is used to introduce a new scope with an embedded set of methods.
-#
-# The idea is to avoid polluting the global namespace. Instead of adding methods to Kernel, we
-# add methods to a new DomainSpecificLanguage, and then we can evaluate code with the new language
-# using the #eval class method or using the #with method added to Kernel.
-#
-# For a similar approach, see http://www.infoq.com/articles/eval-options-in-ruby
-
-class DomainSpecificLanguage
-  
-  # See http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-  def metaclass; class << self; self; end; end
-  def meta_eval &blk; metaclass.instance_eval &blk; end
-  
-  # Adds methods to a metaclass
-  def meta_def name, &blk
-    meta_eval { define_method name, &blk }
-  end
-  
-  # See http://onestepback.org/index.cgi/Tech/Ruby/RubyBindings.rdoc
-  class ReadOnlyReference
-    def initialize(var_name, vars)
-      @getter = eval "lambda { #{var_name} }", vars
-    end
-    def value
-      @getter.call
-    end
-  end
-  
-  attr_reader :outer_binding, :outer_self
-  
-  # instances of a DomainSpecificLanguage are created each time
-  # a block is evaluated with that language. The instance is
-  # intialized with the block's binding.
-  
-  def initialize(given_binding)
-    @outer_binding = given_binding
-    @outer_self = ReadOnlyReference.new(:self, given_binding)
-  end
-  
-  # some jiggery-pokery to access methods defined in the block's
-  # scope, because when the block is evaluated with the DomainSpecificLanguage,
-  # we use #instance_eval to set <tt>self</tt> to the DomainSpecificLanguage
-  # instance.
-  def method_missing(symbol, *args, &block)
-    if args.empty?
-      r = ReadOnlyReference.new(symbol, outer_binding)
-      meta_def(symbol) { r.value }
-      r.value
-    else
-      outer_self.value.send symbol, *args, &block
-    end
-  end
-  
-  class << self
-    
-    # Evaluates a block in the context of a new DomainSpecificlanguage
-    # instance.
-    def eval &block
-      new(block.binding).instance_eval(&block)
-    end
-    
-  end
-  
-end
-
-# We open Kernel and add just one method for introducing DomainSpecificLanguages
-
-module Kernel
-  
-  # Evaluate a block with a DomainSpecificLanguage
-  
-  def with dsl_class, &block
-    dsl_class.eval(&block)
-  end
-  
-end
-
-# Let is a DomainSpecificLanguage that actually creates DomainSpecificLanguages.
-#
-# Let works a lot like <tt>let</tt> in Scheme. Your provide a hash of names and value
-# expressions. The value expressions are evaluated in the outer scope, and then we have
-# a little domain specific language where the inner scope has the names all bound to the
-# values. E.g.
-# <tt>
-# with Let do
-#     let :x => 100, :y => 50 do
-#         print "#{x + y} should equal fifty"
-#     end
-# end
-# </tt>
-#
-# Within the Let DomainSpecificLanguage, you can declare multiple <tt>let</tt> statements and nest
-# them as you please.
-#
-# One important limitation: you cannot bind a value to a name that is already a local variable.
-
-class Let < DomainSpecificLanguage
-  
-  class Scope < DomainSpecificLanguage
-    
-    # initializes a Scope. In addition to the outer binding, we also pass in the
-    # hash of names and values. Note the check to ensure we are not trying to
-    # override a lcoal variable.
-    
-    def initialize given_binding, let_clauses = {}
-      let_clauses.each do |symbol, value| 
-        var_name = symbol.to_s
-        raise ArgumentError.new("Cannot override local #{var_name}") if eval("local_variables", given_binding).detect { |local| local == var_name  }
-        meta_eval { attr_accessor(var_name) }
-        send "#{var_name}=", value
-      end
-      super(given_binding)
-    end
-    
-  end
-  
-  # Define a new Scope: you're really defining a new DomainSpecificLanguage
-  
-  def let let_clauses = {}, &block
-    Scope.new(block.binding, let_clauses).instance_eval(&block)
-  end
-  
-  class << self
-    
-    # If you just want a one-off
-    # def eval let_clauses = {}, &block
-    #   Scope.new(block.binding, let_clauses).instance_eval(&block)
-    # end
-    
-  end
-  
-end
-
-# A DomainSpecificDelegator is a DSL that delegates methods to a class or object.
-# The main use is to separate the mechanics of scoping from the methods of a utility
-# class.
-
-class DomainSpecificDelegator < DomainSpecificLanguage
-  
-  class << self
-    
-    # insert one or more #delegate_to calls in the class definition, giving a receiver
-    # and a hash. Each hash pair is of the form <tt>verb => method</tt> where verb is the
-    # name you will use in the DSL and method is the method in the receiver that will handle
-    # it.
-    def delegate_to receiver, method_hash
-      @@delegations ||= {}
-      method_hash.each { |verb, method_name| @@delegations[verb.to_s] = [receiver, method_name.to_s] }
-    end
-    
-  end
-  
-  def method_missing symbol, *args, &block
-    receiver, method_name = *@@delegations[symbol.to_s]
-    if receiver
-      receiver.send method_name, *args, &block
-    else
-      super(symbol, *args, &block)
-    end
-  end
-  
-end