AntBuilder 0.4.1

data/examples/script1/version.txt

@@ -0,0 +1,20 @@
+Project Version : V1-0-0
+Tagged by : Joe Smith
+Comments : First try
+
+Project Version : V1-1-1
+Tagged by : Denis Menace
+Comments : Lots of features added 
+		
+Project Version : V1-2-3
+Tagged by : Tim James
+Comments : RFC183492/1 RFC183342/3
+
+Project Version : V1-2-7
+Tagged by : Tim James
+Comments : RFC293646/4 
+
+
+
+		
+		

data/lib/antbuilder.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+#--
+# Copyright 2006 by Tim Azzopardi (tim@tigerfive.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+require 'builder/antbuilder'
+

data/lib/builder/antbuilder.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2005 by Tim Azzopardi (tim@tigerfive.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+require 'builder/xmlbase'
+
+require 'java'
+include_class 'org.leafcutter.core.TaskRunner'
+
+module Builder
+  
+  class AntBuilder < XmlBase
+    
+    # Create an ant markup builder.  Parameters are specified by an
+    # option hash.
+    #
+    # :target=><em>target_object</em>::
+    #    Object receiving the markup.  +out+ must respond to the
+    #    <tt><<</tt> operator.  The default is a plain string target.
+    # :indent=><em>indentation</em>::
+    #    Number of spaces used for indentation.  The default is no
+    #    indentation and no line breaks.
+    # :margin=><em>initial_indentation_level</em>::
+    #    Amount of initial indentation (specified in levels, not
+    #    spaces).
+    #    
+    def initialize(options={})
+      indent = options[:indent] || 0
+      margin = options[:margin] || 0
+      super(indent, margin)
+      @target = options[:target] || ""
+      @debug = options[:debug] 
+      @debug = false if @debug.nil?
+    end
+    
+    # Return the target of the builder.
+    def target!
+      @target
+    end
+    
+    def _check_for_circular_dependencies(call_stack, some_method_name) 
+      # remove noise from the stack - all we want left are the ant task methods
+      method_name_on_stack_regexp = /`\w+'/ 
+      call_stack.reject!{|c| c =~ /#{__FILE__}/ or c=~ /`instance_eval'/ or c=~ /`each'/ or not c=~ method_name_on_stack_regexp }
+      
+      # collect just those lines that look like method names
+      call_stack.collect!{|c| (method_name_on_stack_regexp.match(c))[0] }
+      
+      # check whether some_method_name is on the stack
+      call_stack.each do |c|
+          if c=~ /`#{some_method_name}'/
+            # circular dependecy detected 
+            err = call_stack.inject(some_method_name){|message,method_name|  "#{message} <- #{method_name}"}
+            raise RuntimeError, "\nBUILD FAILED\nCircular dependency: #{err}", []
+          end
+      end
+    end
+
+    # implement the ant depends clause    
+    def depends(*ant_task_dependecies) 
+  
+      # who called me?
+      my_caller_matcher = caller[0].match(/`(\w+)'/)
+      my_caller = my_caller_matcher[1] if not my_caller_matcher.nil?
+
+      # Call the dependencies if they haven't been called already
+      for ant_task_dependency in ant_task_dependecies
+      
+            if not respond_to?(ant_task_dependency) 
+              raise RuntimeError, "\nBUILD FAILED\nTarget '#{ant_task_dependency}' does not exist in this project. It is used from target `#{my_caller}'.", []
+            end
+            _check_for_circular_dependencies(caller, ant_task_dependency.to_s) 
+            
+            cmd = "puts \"\n#{ant_task_dependency}:\" if  not @__#{ant_task_dependency}__.nil?; @__#{ant_task_dependency}__ ||= #{ant_task_dependency} || true"
+            puts "#{cmd}" if @debug 
+            instance_eval(cmd)
+      end
+      
+      # Now print the name of the calling task, from the first line of stack
+      puts
+      puts "#{my_caller}:"
+      
+      # and make sure we also record the fact that the caller has been called (as we have done for its dependencies)
+      instance_eval("@__#{my_caller}__ = true ")
+
+    end    
+
+    # Subclasses ONLY can use this at the end of their class definition to run targets from the command line like ant does.
+    # For example: 
+    # "jruby build.rb clean compile release" is like saying "ant clean compile release # this is any comment"
+    def AntBuilder.run_targets_from_command_line
+      # self would be expected to be a subclass here, because AntBuilder doesnt define any 'ant_target'
+      builder = self.new
+      ARGV.each do |ant_target| 
+        return if ant_target == "#"
+        if builder.respond_to?(ant_target)
+          builder.instance_eval("builder.#{ant_target}") 
+        else
+          raise RuntimeError, "\nBUILD FAILED\nTarget '#{ant_target}' does not exist in this project.", []
+        end
+      end
+    end
+    
+    private
+
+    ########################################################################  
+    # NOTE: All private methods of a builder object are prefixed when
+    # a "_" character to avoid possible conflict with ant tags.
+    ########################################################################
+  
+    def _execute ()
+      # Remove the outer brackets as requied by the leafcutter syntax
+      cmd = @target.slice(1,@target.size-2)
+      puts __FILE__ << " _execute " << cmd if @debug
+      case cmd
+      when  /^([\w]+) id=([\w.]+)(\()/
+        # leafcutter supports ant references explicitly http://ant.apache.org/manual/using.html#references
+        # An ant reference of form for example path id=project.class.path
+        reference = $1 +$3 + $' #'
+        reference_name = $2
+        puts __FILE__ << " _execute " << "TaskRunner.addReference(\"#{reference_name}\",\"#{reference}\");" if@debug
+        TaskRunner.addReference(reference_name, reference);    
+      when /taskdef .* name=(\w+)/
+        name=$1
+        # match on classname
+        cmd =~ /classname=([\w.]+)/
+        classname = $1
+        puts __FILE__ << " _execute " << "TaskRunner.addTaskDef(\"#{name}\",\"#{classname}\");" if@debug
+        TaskRunner.addTaskDef(name, classname)
+      else
+        # The "normal" case of some ant command
+        
+        # get the ant properties before the ant command
+        ant_properties_before = _get_ant_properties_as_hash
+        
+        begin
+          puts __FILE__ << " _execute " << "TaskRunner.run(\"#{cmd}\");" if@debug
+          TaskRunner.run(cmd);    
+        rescue
+          raise RuntimeError, "BUILD FAILED\n#{$!}", []
+        end
+        
+        # get the ant properties after the ant command
+        ant_properties_after = _get_ant_properties_as_hash
+
+        # get the new ant properties after the command (if any). 
+        # (Remember ant properties can't be redefined so we only need the new ones.)
+        ant_properties_new = ant_properties_after.select{|k, v| not ant_properties_before.has_key?(k) }
+        
+        # define the ant properies as ruby instance variables
+        ant_properties_new.each do | k,v | 
+
+          # property name may contain alot of different wacky characters which are not legal in ruby instance variable names
+          # so replace all wacky characters with underscores
+          k.gsub!(/\W/, "_")
+
+          # Replace \ with \\ : this is hell : some windows env vars can look like "C:\some\windows\dir"
+          v.gsub!(/\\/, "\\\\\\\\")
+          v.gsub!(/"/, "\\\"")
+          decl = "@#{k}=\"#{v}\""
+          puts "About to define ruby instance variable: " << decl if @debug 
+          instance_eval(decl) 
+          puts "Defined ruby instance variable: " << decl << " read back as: " << instance_eval("@#{k}") if @debug 
+        end        
+        
+      end
+      
+      @target = ''
+    end
+  
+    def _get_ant_properties_as_hash
+      hash = Hash.new 
+      TaskRunner.getAntProjectProperties.each { | k,v | hash[k] = v }
+      hash
+    end
+  
+    # Insert text directly in to the builder's target.
+    def _text(text)
+      @target << text
+    end
+    
+    def _indent
+      raise ArgumentError, "It looks like this object has not been initialized. Did the object get an initialize call?" if @target.nil?
+      super
+    end
+    
+    def method_missing(sym, *args, &block)
+      ret = super
+      _execute if @level==0
+      ret
+    end
+    
+    
+    # Start an tag.  If <tt>end_too</tt> is true, then the start
+    # tag is also the end tag 
+    def _start_tag(sym, attrs, end_too=false)
+      @target << "(#{sym}"
+      _insert_attributes(attrs)
+      @target << ")" if end_too
+      # @target << ")"
+    end
+    
+    # Insert an ending tag.
+    def _end_tag(sym)
+      @target << ")"
+    end
+    
+    # Insert the attributes (given in the hash).
+    def _insert_attributes(attrs)
+      return if attrs.nil?
+      attrs.each do |k, v|
+        # if the attribute value contains spaces then put single quotes around the string
+        v = "'#{v}'" if v =~ " " 
+        @target << %{ #{k}=#{v}}
+      end
+    end
+  
+  end # class
+
+end # module

data/lib/builder/blankslate.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# Copyright 2005 by Tim Azzopardi (tim@tigerfive.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+module Builder
+
+  # BlankSlate provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  class BlankSlate
+    class << self
+      def hide(name)
+        undef_method name if
+          instance_methods.include?(name.to_s) and 
+           name !~ /^(__|instance_eval)/ and 
+           name !~ /^(__|respond_to?)/
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+end
+
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a hook in the Object and Kernel classes that will hide any defined 
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+    def method_added(name)
+      blank_slate_method_added(name)
+      return if self != Kernel
+      Builder::BlankSlate.hide(name)
+    end
+  end
+end
+
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+    def method_added(name)
+      blank_slate_method_added(name)
+      return if self != Object
+      Builder::BlankSlate.hide(name)
+    end
+  end
+end

data/lib/builder/xmlbase.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+require 'builder/blankslate'
+
+module Builder
+
+  # Generic error for builder
+  class IllegalBlockError < RuntimeError; end
+
+  # XmlBase is a base class for building XML builders.  See
+  # Builder::XmlMarkup and Builder::XmlEvents for examples.
+  class XmlBase < BlankSlate
+
+    # Create an XML markup builder.
+    #
+    # out::     Object receiving the markup.1  +out+ must respond to
+    #           <tt><<</tt>.
+    # indent::  Number of spaces used for indentation (0 implies no
+    #           indentation and no line breaks).
+    # initial:: Level of initial indentation.
+    #
+    def initialize(indent=0, initial=0)
+      @indent = indent
+      @level  = initial
+    end
+    
+    # Create a tag named +sym+.  Other than the first argument which
+    # is the tag name, the arguements are the same as the tags
+    # implemented via <tt>method_missing</tt>.
+    def tag!(sym, *args, &block)
+      self.__send__(sym, *args, &block)
+    end
+
+    # Create XML markup based on the name of the method.  This method
+    # is never invoked directly, but is called for each markup method
+    # in the markup block.
+    def method_missing(sym, *args, &block)
+      text = nil
+      attrs = nil
+      sym = "#{sym}:#{args.shift}" if args.first.kind_of?(Symbol)
+      args.each do |arg|
+        case arg
+        when Hash
+          attrs ||= {}
+          attrs.merge!(arg)
+        else
+          text ||= ''
+          text << arg.to_s
+        end
+      end
+      if block
+        unless text.nil?
+          raise ArgumentError, "XmlMarkup cannot mix a text argument with a block"
+        end
+        _capture_outer_self(block) if @self.nil?
+        _indent
+        _start_tag(sym, attrs)
+        _newline
+        _nested_structures(block)
+        _indent
+        _end_tag(sym)
+        _newline
+      elsif text.nil?
+        _indent
+        _start_tag(sym, attrs, true)
+        _newline
+      else
+        _indent
+        _start_tag(sym, attrs)
+        text! text
+        _end_tag(sym)
+        _newline
+      end
+      @target
+    end
+
+
+
+    # Append text to the output target.  Escape any markup.  May be
+    # used within the markup brakets as:
+    #
+    #   builder.p { |b| b.br; b.text! "HI" }   #=>  <p><br/>HI</p>
+    def text!(text)
+      _text(_escape(text))
+    end
+    
+    # Append text to the output target without escaping any markup.
+    # May be used within the markup brakets as:
+    #
+    #   builder.p { |x| x << "<br/>HI" }   #=>  <p><br/>HI</p>
+    #
+    # This is useful when using non-builder enabled software that
+    # generates strings.  Just insert the string directly into the
+    # builder without changing the inserted markup.
+    #
+    # It is also useful for stacking builder objects.  Builders only
+    # use <tt><<</tt> to append to the target, so by supporting this
+    # method/operation builders can use other builders as their
+    # targets.
+    def <<(text)
+      _text(text)
+    end
+    
+    # For some reason, nil? is sent to the XmlMarkup object.  If nil?
+    # is not defined and method_missing is invoked, some strange kind
+    # of recursion happens.  Since nil? won't ever be an XML tag, it
+    # is pretty safe to define it here. (Note: this is an example of
+    # cargo cult programming,
+    # cf. http://fishbowl.pastiche.org/2004/10/13/cargo_cult_programming).
+    def nil?
+      false
+    end
+
+    private
+    
+    def _escape(text)
+      text.
+        gsub(%r{&}, '&amp;').
+        gsub(%r{<}, '&lt;').
+        gsub(%r{>}, '&gt;')
+    end
+
+    def _capture_outer_self(block)
+      @self = eval("self", block)
+    end
+    
+    def _newline
+      return if @indent == 0
+      text! "\n"
+    end
+    
+    def _indent
+      return if @indent == 0 || @level == 0
+      text!(" " * (@level * @indent))
+    end
+    
+    def _nested_structures(block)
+      @level += 1
+      block.call(self)
+    ensure
+      @level -= 1
+    end
+    
+  end
+end