RubyGems - Antwrap - Versions diffs - 0.5.2 → 0.5.3 - Mend

Antwrap 0.5.2 → 0.5.3

Files changed (8) hide show

data/docs/index.html CHANGED

@@ -1,4 +1,6 @@
 <html><head><title>Antwrap - Invoke Ant tasks from your Ruby/JRuby scripts!</title></head><body><ul>
+<h1>Antwrap</h1>
+<h3>Invoke Ant tasks from your Ruby/JRuby scripts!</h3><br/>
 <pre><li>Sample code of the Antwrap library looks like this;
 <code lang="ruby">
@@ -96,9 +98,13 @@ in order to instantiate Java objects.
 </li></pre>
 </ul>
-Comments or Questions? <br>
+<a href='http://rubyforge.org/projects/antwrap/'>Project Info</a><br/>
+<a href='http://buildr.rubyforge.org/'>Buildr</a><br/>
+<a href='http://rubyforge.org/projects/raven/'>Raven</a><br/>
+Comments or Questions? <br/>
 Caleb Powell <br>
 caleb.powell@gmail.com <br>
-</body></html>
+</body>
+</html>

data/lib/antwrap.rb CHANGED

@@ -5,10 +5,11 @@
 # Licensed under the LGPL, see the file COPYING in the distribution
 #
 require 'antwrap_utilities'
+require 'dsl'
 class AntTask
   @@task_stack = Array.new
-  attr_accessor(:unknown_element, :project, :taskname, :logger, :executed)
+  attr_accessor :unknown_element, :project, :taskname, :logger, :executed
   public
   def initialize(taskname, antProject, attributes, proc)
@@ -81,23 +82,33 @@ class AntTask
     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)})
+        apply_to_wrapper(wrapper, key.to_s, val.to_s){ |k,v| wrapper.setAttribute(k, v)}
       end
     else
       @unknown_element.setRuntimeConfigurableWrapper(wrapper)
-      attribute_list = org.xml.sax.helpers.AttributeListImpl.new()
+      attribute_list = XmlSax::AttributeListImpl.new()
       attributes.each do |key, val|
-        outer_func.call(key.to_s, val, lambda{|k,v| attribute_list.addAttribute(k, 'CDATA', v)})
+        apply_to_wrapper(wrapper, key.to_s, val.to_s){ |k,v| attribute_list.addAttribute(k, 'CDATA', v)}
       end
       wrapper.setAttributes(attribute_list)
     end
   end
+  def apply_to_wrapper(wrapper, key, value)
+    begin
+      if(key == 'pcdata')
+        wrapper.addText(value)
+      else
+        yield key, value
+      end
+    rescue StandardError
+      raise ArgumentError, "Unable to set :#{key} attribute with value => '#{value}'"
+    end
+  end
   #Add <em>child</em> as a child of this task.
   def add(child)
     @unknown_element.addChild(child.unknown_element())
@@ -113,7 +124,7 @@ class AntTask
 end
-class AntProject
+class AntProject
   require 'logger'
   private
@@ -164,7 +175,6 @@ class AntProject
   # :loglevel=><em>The level to set the logger to</em>
   #   -Defaults to Logger::ERROR
   def initialize(options=Hash.new)
     @logger = options[:logger] || Logger.new(STDOUT)
     @logger.level = options[:loglevel] || Logger::ERROR
@@ -176,9 +186,8 @@ class AntProject
     @logger.debug(ApacheAnt::Main.getAntVersion())
     @ant_version = ApacheAnt::Main.getAntVersion()[/\d\.\d\.\d/].to_f
     init_project(options)
   end
   def method_missing(sym, *args)
@@ -188,8 +197,8 @@ class AntProject
       task.execute if declarative
       return task
     rescue
-      @logger.error("Error instantiating task[#{sym.to_s}]" + $!)
-      throw $!
+      @logger.error("Error instantiating '#{sym.to_s}' task; " + $!)
+      raise
     end
   end

data/lib/antwrap_utilities.rb CHANGED

@@ -2,11 +2,13 @@ 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
 module AntwrapClassLoader

data/lib/dsl.rb ADDED

@@ -0,0 +1,163 @@
+# 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

data/lib/jruby_modules.rb CHANGED

@@ -9,4 +9,8 @@ end
 module JavaLang
   include_class "java.lang.System"
+end
+module XmlSax
+  include_class "org.xml.sax.helpers.AttributeListImpl"
 end

data/lib/rjb_modules.rb CHANGED

@@ -9,4 +9,8 @@ end
 module JavaLang
   System = Rjb::import("java.lang.System")
+end
+module XmlSax
+  AttributeListImpl = Rjb::import("org.xml.sax.helpers.AttributeListImpl")
 end

data/test/tc_antwrap.rb CHANGED

@@ -9,42 +9,20 @@ 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']
     @output_dir = @current_dir + '/test/output'
     @resource_dir = @current_dir + '/test/test-resources'
     @ant_home = @resource_dir + "/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,
                         :logger=>Logger.new(STDOUT), :loglevel=>Logger::DEBUG, :ant_home => @ant_home}
     @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())
     if File.exists?(@output_dir)
       FileUtils.remove_dir(@output_dir)
@@ -64,9 +42,7 @@ class TestAntwrap < Test::Unit::TestCase
   def test_unzip_task
     assert_absent @output_dir + '/parent/FooBarParent.class'
-    task = @ant.unzip(:src => @resource_dir + '/parent.jar',
-    :dest => @output_dir)
+    @ant.unzip(:src => @resource_dir + '/parent.jar', :dest => @output_dir)
     assert_exists @output_dir + '/parent/FooBarParent.class'
   end
@@ -106,18 +82,18 @@ class TestAntwrap < Test::Unit::TestCase
     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.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',
+    :verbose => true,
     :fork => 'no',
-    :failonerror => 'yes',
+    :failonerror => 'blahblahblah',
     :includes => 'foo/bar/**',
     :excludes => 'foo/bar/baz/**',
     :classpathref => 'common.class.path')
@@ -140,7 +116,7 @@ class TestAntwrap < Test::Unit::TestCase
   def test_java_task
     return if @ant.ant_version < 1.7
+    puts "executing java task"
     FileUtils.mkdir(@output_dir + '/classes', :mode => 0775)
     @ant.javac(:srcdir => @resource_dir + '/src',
     :destdir => @output_dir + '/classes',
@@ -167,15 +143,10 @@ class TestAntwrap < Test::Unit::TestCase
   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>")
+    @ant.echo(:message => 100000, :level => 'info')
+    @ant.echo(:pcdata => 1000)
   end
   def test_mkdir_task
@@ -255,6 +226,17 @@ class TestAntwrap < Test::Unit::TestCase
   def test_tstamp
     @ant.tstamp
   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
   private
   def assert_exists(file_path)
     assert(File.exists?(file_path), "Does not exist[#{file_path}]")

metadata CHANGED

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: Antwrap
 version: !ruby/object:Gem::Version
-  version: 0.5.2
-date: 2007-04-17
+  version: 0.5.3
+date: 2007-06-13
 summary: "A Ruby module that wraps the Apache Ant build tool, enabling Ant Tasks to be
   invoked from a Ruby/JRuby scripts."
 require_paths:
@@ -31,6 +31,7 @@ files:
   - lib/antwrap.rb
   - lib/antwrap_utilities.rb
   - lib/convert.rb
+  - lib/dsl.rb
   - lib/jruby_modules.rb
   - lib/rjb_modules.rb
   - test/build.xml