buildr 1.3.5-x86-mswin32 → 1.4.0-x86-mswin32

data/lib/buildr/core/generate.rb

@@ -21,7 +21,7 @@ module Buildr
   module Generate #:nodoc:
 
     task 'generate' do
-      script = nil 
+      script = nil
       choose do |menu|
         menu.header = "To use Buildr you need a buildfile. Do you want me to create one?"
 
@@ -29,12 +29,12 @@ module Buildr
         menu.choice("From directory structure") { script = Generate.from_directory(Dir.pwd).join("\n") }
         menu.choice("Skip") { }
       end
-       
-      if script    
+
+      if script
         buildfile = File.expand_path(Buildr::Application::DEFAULT_BUILDFILES.first)
         File.open(buildfile, "w") { |file| file.write script }
         puts "Created #{buildfile}"
-      end        
+      end
     end
 
     class << self
@@ -107,7 +107,7 @@ define "#{name}" do
             proxy = settings['proxies'].first['proxy'].find { |proxy|
               proxy["active"].nil? || proxy["active"].to_s =~ /true/
             } rescue nil
-            
+
             if proxy
               url = %{#{proxy["protocol"].first}://#{proxy["host"].first}:#{proxy["port"].first}}
               exclude = proxy["nonProxyHosts"].to_s.gsub("|", ",") if proxy["nonProxyHosts"]
@@ -189,7 +189,7 @@ define "#{name}" do
         script << "end"
         script.flatten
       end
-       
+
     end
   end
-end 
+end

data/lib/buildr/core/help.rb

@@ -24,7 +24,7 @@ module Buildr
     class << self
 
       def <<(arg)
-        if arg.respond_to?(:call) 
+        if arg.respond_to?(:call)
           texters << arg
         else
           texters << lambda { arg }

data/lib/buildr/core/osx.rb

@@ -16,7 +16,7 @@
 
 # Let's see if we can use Growl.  Must be running from console in verbose mode.
 if $stdout.isatty && verbose
-  notify = lambda do |type, title, message|
+  def growl_notify(type, title, message)
     begin
       # Loading Ruby Cocoa can slow the build down (hooks on Object class), so we're
       # saving the best for last and only requiring it at the very end.
@@ -27,7 +27,7 @@ if $stdout.isatty && verbose
       # Register with Growl, that way you can turn notifications on/off from system preferences.
       OSX::NSDistributedNotificationCenter.defaultCenter.
         postNotificationName_object_userInfo_deliverImmediately(:GrowlApplicationRegistrationNotification, nil,
-          { :ApplicationName=>'Buildr', :AllNotifications=>['Completed', 'Failed'], 
+          { :ApplicationName=>'Buildr', :AllNotifications=>['Completed', 'Failed'],
             :ApplicationIcon=>icon.TIFFRepresentation }, true)
 
       OSX::NSDistributedNotificationCenter.defaultCenter.
@@ -39,8 +39,8 @@ if $stdout.isatty && verbose
       # calls raises an exception; system doesn't have osx/cocoa, e.g. MacPorts Ruby 1.9,
       # so we also need to rescue LoadError.
     end
-  end  
-  
-  Buildr.application.on_completion { |title, message| notify['Completed', title, message] if verbose }
-  Buildr.application.on_failure { |title, message, ex| notify['Failed', title, message] if verbose }
+  end
+
+  Buildr.application.on_completion { |title, message| growl_notify('Completed', title, message) if verbose }
+  Buildr.application.on_failure { |title, message, ex| growl_notify('Failed', title, message) if verbose }
 end

data/lib/buildr/core/progressbar.rb

@@ -66,7 +66,7 @@ class ProgressBar
   end
 
   def title
-    @title.size > ProgressBar.width / 5 ? (@title[0, ProgressBar.width / 5 - 2] + '..') : @title 
+    @title.size > ProgressBar.width / 5 ? (@title[0, ProgressBar.width / 5 - 2] + '..') : @title
   end
 
   def count
@@ -93,7 +93,7 @@ class ProgressBar
   end
 
   def elapsed
-    'Time: %s' % duration(Time.now - @start) 
+    'Time: %s' % duration(Time.now - @start)
   end
 
   def rate
@@ -130,7 +130,7 @@ protected
     @output.print "\r", " " * (ProgressBar.width - 1), "\r"
     @output.flush
   end
-    
+
   def render
     return unless @output
     format, *args = @format
@@ -143,7 +143,7 @@ protected
   end
 
   def changed?
-    return false unless @output && Time.now - @last_time > 0.1 
+    return false unless @output && Time.now - @last_time > 0.1
     return human(@count) != human(@previous) if @total == 0
     return true if (@count - @previous) >= @total / 100
     return Time.now - @last_time > 1

data/lib/buildr/core/project.rb

@@ -210,8 +210,8 @@ module Buildr
           @projects[name] = project
           # Set the project properties first, actions may use them.
           properties.each { |name, value| project.send "#{name}=", value } if properties
-          # Instantiate callbacks for this project, and setup to call before/after define.
-          # Don't cache list of callbacks, since project may add new callbacks.
+          # Setup to call before/after define extension callbacks
+          # Don't cache list of extensions, since project may add new extensions.
           project.enhance do |project|
             project.send :call_callbacks, :before_define
             project.enhance do |project|
@@ -219,14 +219,14 @@ module Buildr
             end
           end
           project.enhance do |project|
-            @on_define.each { |callback| callback[project] }
+            @on_define.each { |extension| extension[project] }
           end if @on_define
           # Enhance the project using the definition block.
           project.enhance { project.instance_exec project, &block } if block
 
           # Top-level project? Invoke the project definition. Sub-project? We don't invoke
           # the project definiton yet (allow project calls to establish order of evaluation),
-          # but must do so before the parent project's definition is done. 
+          # but must do so before the parent project's definition is done.
           project.parent.enhance { project.invoke } if project.parent
         end
       end
@@ -375,11 +375,15 @@ module Buildr
         project if Project === project
       end
 
-      # Callback classes.
-      def callbacks #:nodoc:
-        @callbacks ||= []
+      # Loaded extension modules.
+      def extension_modules #:nodoc:
+        @extension_modules ||= []
       end
 
+      # Extension callbacks that apply to all projects
+      def global_callbacks #:nodoc:
+        @global_callbacks ||= []
+      end
     end
 
 
@@ -402,11 +406,8 @@ module Buildr
         @parent = task(split[0...-1].join(':'))
         raise "No parent project #{split[0...-1].join(':')}" unless @parent && Project === parent
       end
-      callbacks = Project.callbacks.uniq.map(&:new)
-      @callbacks = [:before_define, :after_define].inject({}) do |hash, state|
-        methods = callbacks.select { |callback| callback.respond_to?(state) }.map { |callback| callback.method(state) }
-        hash.update(state=>methods)
-      end
+      # Inherit all global callbacks
+      @callbacks = Project.global_callbacks.dup
     end
 
     # :call-seq:
@@ -587,6 +588,16 @@ module Buildr
       %Q{project(#{name.inspect})}
     end
 
+    def callbacks #:nodoc:
+      # global + project_local callbacks for this project
+      @callbacks ||= []
+    end
+
+    def calledback #:nodoc:
+      # project-local callbacks that have been called
+      @calledback ||= {}
+    end
+
   protected
 
     # :call-seq:
@@ -626,14 +637,35 @@ module Buildr
       end
     end
 
-    # Call all callbacks for a particular state, e.g. :before_define, :after_define.
-    def call_callbacks(state) #:nodoc:
-      methods = @callbacks.delete(state) || []
-      methods.each { |method| method.call(project) }
+    # Call all extension callbacks for a particular phase, e.g. :before_define, :after_define.
+    def call_callbacks(phase) #:nodoc:
+      remaining = @callbacks.select { |cb| cb.phase == phase }
+      known_callbacks = remaining.map { |cb| cb.name }
+      
+      # call each extension in order
+      until remaining.empty?
+        callback = first_satisfied(remaining, known_callbacks)
+        if callback.nil?
+          hash = remaining.map { |cb| { cb.name => cb.dependencies} }
+          fail "Unsatisfied dependencies in extensions for #{phase}: #{hash.inspect}"
+        end
+        callback.blocks.each { |b| b.call(self) }
+      end
     end
-
-    def add_callback(callback)
-      @callbacks[:after_define] << callback.method(:after_define) if callback.respond_to?(:after_define)
+    
+    private
+    
+    # find first callback with satisfied dependencies
+    def first_satisfied(r, known_callbacks)
+      remaining_names = r.map { |cb| cb.name }
+      res = r.find do |cb|
+        cb.dependencies.each do |dep|
+          fail "Unknown #{phase.inspect} extension dependency: #{dep.inspect}" unless known_callbacks.index(dep)
+        end
+        satisfied = cb.dependencies.find { |dep| remaining_names.index(dep) } == nil
+        cb if satisfied
+      end
+      r.delete res
     end
 
   end
@@ -707,6 +739,22 @@ module Buildr
   #   end
   module Extension
 
+    # Extension callback details
+    class Callback #:nodoc:
+      attr_accessor :phase, :name, :dependencies, :blocks
+
+      def initialize(phase, name, dependencies, blocks)
+        @phase = phase
+        @name = name
+        @dependencies = dependencies
+        @blocks = (blocks ? (Array === blocks ? blocks : [blocks]) : [])
+      end
+
+      def merge(callback)
+        Callback.new(phase, name, @dependencies + callback.dependencies, @blocks + callback.blocks)
+      end
+    end
+
     def self.included(base) #:nodoc:
       base.extend ClassMethods
     end
@@ -715,49 +763,109 @@ module Buildr
     module ClassMethods
 
       def included(base) #:nodoc:
-        # When included in Project, add callback and call first_time.
-        if Project == base && !base.callbacks.include?(callbacks)
-          base.callbacks << callbacks
-          callbacks.first_time if callbacks.respond_to?(:first_time)
+        # When included in Project, add module instance, merge callbacks and call first_time.
+        if Project == base && !base.extension_modules.include?(module_callbacks)
+          base.extension_modules << module_callbacks
+          merge_callbacks(base.global_callbacks, module_callbacks)
+          first_time = module_callbacks.select { |c| c.phase == :first_time }
+          first_time.each do |c|
+            c.blocks.each { |b| b.call }
+          end
         end
       end
 
       def extended(base) #:nodoc:
-        # When extending project, add instance and call before_define.
+        # When extending project, merge after_define callbacks and call before_define callback(s)
+        # immediately
         if Project === base
-          callbacks = self.send(:callbacks).new
-          callbacks.before_define(base) if callbacks.respond_to?(:before_define)
-          base.send :add_callback, callbacks
+          merge_callbacks(base.callbacks, module_callbacks.select { |cb| cb.phase == :after_define })
+          calls = module_callbacks.select { |cb| cb.phase == :before_define }
+          calls.each do |cb|
+            cb.blocks.each { |b| b.call(base) } unless base.calledback[cb]
+            base.calledback[cb] = cb
+          end
         end
       end
 
-      # This block will be called once for any particular extension.
+      # This block will be called once for any particular extension included in Project.
       # You can use this to setup top-level and local tasks.
       def first_time(&block)
-        meta = class << callbacks ; self ; end
-        meta.send :define_method, :first_time, &block
+        module_callbacks << Callback.new(:first_time, self.name, [], block)
       end
 
       # This block is called once for the project with the project instance,
       # right before running the project definition.  You can use this to add
       # tasks and set properties that will be used in the project definition.
-      def before_define(&block)
-        callbacks.send :define_method, :before_define, &block
+      #
+      # The block may be named and dependencies may be declared similar to Rake
+      # task dependencies:
+      #
+      #   before_define(:my_setup) do |project|
+      #     # do stuff on project
+      #   end
+      #
+      #   # my_setup code must run before :compile
+      #   before_define(:compile => :my_setup)
+      #
+      def before_define(*args, &block)
+        if args.empty?
+          name = self.name
+          deps = []
+        else
+          name, args, deps = Buildr.application.resolve_args(args)
+        end
+        module_callbacks << Callback.new(:before_define, name, deps, block)
       end
 
       # This block is called once for the project with the project instance,
       # right after running the project definition.  You can use this to do
       # any post-processing that depends on the project definition.
-      def after_define(&block)
-        callbacks.send :define_method, :after_define, &block
+      #
+      # The block may be named and dependencies may be declared similar to Rake
+      # task dependencies:
+      #
+      #   after_define(:my_setup) do |project|
+      #     # do stuff on project
+      #   end
+      #
+      #   # my_setup code must run before :compile (but only after project is defined)
+      #   after_define(:compile => :my_setup)
+      #
+      def after_define(*args, &block)
+        if args.empty?
+          name = self.name
+          deps = []
+        else
+          name, args, deps = Buildr.application.resolve_args(args)
+        end
+        module_callbacks << Callback.new(:after_define, name, deps, block)
       end
 
     private
 
-      def callbacks
-        const_get('Callbacks') rescue const_set('Callbacks', Class.new)
+      def module_callbacks
+        begin
+          const_get('Callbacks')
+        rescue
+          callbacks = []
+          const_set('Callbacks', callbacks)
+        end
       end
 
+      def merge_callbacks(base, merge)
+        # index by phase and name
+        index = base.inject({}) { |hash,cb| { [cb.phase, cb.name] => cb } }
+        merge.each do |cb|
+          existing = index[[cb.phase, cb.name]]
+          if existing
+            base[base.index(existing)] = existing.merge(cb)
+          else
+            base << cb
+          end
+          index[[cb.phase, cb.name]] = cb
+        end
+        base
+      end
     end
 
   end

data/lib/buildr/core/shell.rb

@@ -22,29 +22,29 @@ module Buildr
   module Shell
 
     class BeanShell < Base
-      
+
       include JavaRebel
-      
+
       VERSION = '2.0b4'
 
       class << self
         def version
           Buildr.settings.build['bsh'] || VERSION
         end
-        
+
         def artifact
           "org.beanshell:bsh:jar:#{version}"
         end
-        
+
         def lang
           :java
         end
-        
+
         def to_sym
           :bsh
         end
       end
-      
+
       def launch
         cp = project.compile.dependencies + [project.path_to(:target, :classes), Buildr.artifact(BeanShell.artifact)]
         Java::Commands.java 'bsh.Console', {
@@ -53,32 +53,32 @@ module Buildr
           :java_args => rebel_args
         }
       end
-      
+
     end # BeanShell
 
-        
+
     class JIRB < Base
       include JavaRebel
-      
-      JRUBY_VERSION = '1.3.1'
-      
-      class << self        
+
+      JRUBY_VERSION = '1.4.0'
+
+      class << self
         def lang
           :none
         end
       end
-      
+
       def launch
         if jruby_home     # if JRuby is installed, use it
-          cp = project.compile.dependencies + 
+          cp = project.compile.dependencies +
             [project.path_to(:target, :classes)] +
             Dir.glob("#{jruby_home}#{File::SEPARATOR}lib#{File::SEPARATOR}*.jar")
-          
+
           props = {
             'jruby.home' => jruby_home,
             'jruby.lib' => "#{jruby_home}#{File::SEPARATOR}lib"
           }
-          
+
           if not Util.win_os?
             uname = `uname -m`
             cpu = if uname =~ /i[34567]86/
@@ -88,24 +88,24 @@ module Buildr
             elsif uname =~ /amd64|x86_64/
               'amd64'
             end
-            
+
             os = `uname -s | tr '[A-Z]' '[a-z]'`
             path = if os == 'darwin'
               'darwin'
             else
               "#{os}-#{cpu}"
             end
-            
+
             props['jna.boot.library.path'] = "#{jruby_home}/lib/native/#{path}"
           end
-          
+
           props['jruby.script'] = if Util.win_os? then 'jruby.bat' else 'jruby' end
           props['jruby.shell'] = if Util.win_os? then 'cmd.exe' else '/bin/sh' end
-          
+
           args = [
             "-Xbootclasspath/a:#{Dir.glob("#{jruby_home}#{File::SEPARATOR}lib#{File::SEPARATOR}jruby*.jar").join File::PATH_SEPARATOR}"
           ]
-          
+
           Java::Commands.java 'org.jruby.Main', "#{jruby_home}#{File::SEPARATOR}bin#{File::SEPARATOR}jirb", {
             :properties => props.merge(rebel_props(project)),
             :classpath => cp,
@@ -116,7 +116,7 @@ module Buildr
               jruby_artifact,
               project.path_to(:target, :classes)
             ]
-          
+
           Java::Commands.java 'org.jruby.Main', '--command', 'irb', {
             :properties => rebel_props(project),
             :classpath => cp,
@@ -133,33 +133,33 @@ module Buildr
         version = Buildr.settings.build['jruby'] || JRUBY_VERSION
         "org.jruby:jruby-complete:jar:#{version}"
       end
-    
+
     end
-    
+
     class Clojure < Base
       include JavaRebel
-      
+
       JLINE_VERSION = '0.9.94'
-      
+
       class << self
         def lang
           :none
         end
-        
+
         def to_sym
           :clj      # more common than `clojure`
         end
       end
-      
+
       # don't build if it's *only* Clojure sources
       def build?
         !has_source?(:clojure) or has_source?(:java) or has_source?(:scala) or has_source?(:groovy)
       end
-      
+
       def launch
         fail 'Are we forgetting something? CLOJURE_HOME not set.' unless clojure_home
-        
-        cp = project.compile.dependencies + 
+
+        cp = project.compile.dependencies +
           [
             if build?
               project.path_to(:target, :classes)
@@ -169,7 +169,7 @@ module Buildr
             File.expand_path('clojure.jar', clojure_home),
             'jline:jline:jar:0.9.94'
           ]
-        
+
         if build?
           Java::Commands.java 'jline.ConsoleRunner', 'clojure.lang.Repl', {
             :properties => rebel_props(project),
@@ -180,12 +180,12 @@ module Buildr
           Java::Commands.java 'jline.ConsoleRunner', 'clojure.lang.Repl', :classpath => cp
         end
       end
-      
+
     private
       def clojure_home
         @home ||= ENV['CLOJURE_HOME']
       end
-      
+
       def has_source?(lang)
         File.exists? project.path_to(:src, :main, lang)
       end