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

Antwrap 0.5.2 → 0.5.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 (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