buildr 1.2.0 → 1.2.1

data/CHANGELOG

@@ -1,4 +1,16 @@
-1.2 (6/6/2007)
+1.2.1 (7/12/2007)
+* Added: Proxy exclusion, use environment variable NO_PROXY, or options.proxy.exclude = <url> || [<url>] (http://groups.google.com/group/buildr-talk/t/9f1e988e0dbeea9f).
+* Added: You can now copy resources from multiple source directories, using resources.from (http://groups.google.com/group/buildr-talk/browse_thread/thread/4f2867a6dbbc19d4).
+* Added: Hash.from_java_properties(string) and hash.to_java_properties.
+* Changed: Buildr.options now wrap various environment variables instead of duplicating them (HTTP_PROXY, NO_PROXY, TEST, DEBUG).
+* Changed: No longer passing proxies to transports, instead they obtain them from environment variables.
+* Changed: Buildr now uses XJavaDoc 1.1 instead of 1.1-j5. If you need the 1.1-j5 fix, see here http://groups.google.com/group/buildr-talk/browse_thread/thread/49f3226810466c94/1f0d25d002433fe2.
+* Fixed: One RubyForge release for all packages, instead of one per package (Anatol Pomozov).
+* Fixed: buildr command does not recognize project tasks (foo:compile) or default task (http://groups.google.com/group/buildr-talk/t/660061a0bc81989a).
+* Fixed: Upload fails on SFTP permissions.
+* Fixed: Hibernate.schema_export not passing Ant task when yielding.
+
+1.2.0 (6/6/2007)
 * Added: Artifact.list returns specs for all registered artifacts (those created with artifact or package).
 * Added: Buildr.option.java_args are used when creating the RJB JVM, when running a Java process (unless you override directly), and when running JUnit tests (again, unless override).
 * Added: TestNG support (test.using :testng).

data/Rakefile

@@ -141,10 +141,12 @@ end
 
 namespace :upload do
   task :docs=>"rake:docs" do |task|
-    `rsync -r --del --progress html/* rubyforge.org:/var/www/gforge-projects/#{spec.rubyforge_project.downcase}`
+    sh "rsync -r --del --progress html/* rubyforge.org:/var/www/gforge-projects/#{spec.rubyforge_project.downcase}"
   end
 
   task :packages=>["rake:docs", "rake:package"] do |task|
+    require 'rubyforge'
+
     # Read the changes for this release.
     pattern = /(^(\d+\.\d+(?:\.\d+)?)\s+\(\d+\/\d+\/\d+\)\s*((:?^[^\n]+\n)*))/
     changelog = File.read(__FILE__.pathmap("%d/CHANGELOG"))
@@ -156,12 +158,13 @@ namespace :upload do
     fail "No changeset found for version #{spec.version}" unless current
 
     puts "Uploading #{spec.name} #{spec.version}"
-    files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{spec.name}-#{spec.version}.#{ext}" }
-    system "rubyforge", "login"
-    files.each do |file|
-      system "rubyforge", "add_release", spec.rubyforge_project.downcase, spec.name.downcase,
-        spec.version.to_s, file, "-a", current
-    end
+    files = %w( gem tgz zip ).map { |ext| "pkg/#{spec.name}-#{spec.version}.#{ext}" }
+    rubyforge = RubyForge.new
+    rubyforge.login    
+    File.open(".changes", 'w'){|f| f.write(current)}
+    rubyforge.userconfig.merge!("release_changes" => ".changes",  "preformatted" => true)
+    rubyforge.add_release spec.rubyforge_project.downcase, spec.name.downcase, spec.version, *files
+    rm ".changes"
     puts "Release #{spec.version} uploaded"
   end
 end

data/lib/buildr.rb

@@ -19,10 +19,11 @@ require "facet/string/starts_with"
 require "facet/openobject"
 require "facets/core/kernel/tap"
 # A different kind of buildr, one we use to create XML.
+require "builder"
 
 
 module Buildr
-  VERSION = "1.2.0".freeze
+  VERSION = "1.2.1".freeze
 end
 
 
@@ -32,141 +33,143 @@ end
 unless defined?(Rake)
   require "rake"
 
-  class Application < Rake::Application #:nodoc:
-
-    DEFAULT_BUILDFILES = ["buildfile", "Buildfile"] + DEFAULT_RAKEFILES
-
-    OPTIONS = [     # :nodoc:
-      ['--help',     '-H', GetoptLong::NO_ARGUMENT,
-        "Display this help message."],
-      ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
-        "Do not search parent directories for the buildfile."],
-      ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
-        "Do not log messages to standard output."],
-      ['--buildfile', '-f', GetoptLong::OPTIONAL_ARGUMENT,
-        "Use FILE as the buildfile."],
-      ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
-        "Require MODULE before executing buildfile."],
-      ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
-        "Turn on invoke/execute tracing, enable full backtrace."],
-      ['--verbose',  '-v', GetoptLong::NO_ARGUMENT,
-        "Log message to standard output (default)."],
-      ['--version',  '-V', GetoptLong::NO_ARGUMENT,
-        "Display the program version."],
-      ['--freeze',   "-F",  GetoptLong::NO_ARGUMENT,
-       "Freezes the Buildfile so it always uses Buildr version #{Buildr::VERSION}"],
-      ['--unfreeze', "-U",  GetoptLong::NO_ARGUMENT,
-       "Unfreezes the Buildfile to use the latest version of Buildr"]
-    ]
-
-    def initialize()
-      super
-      @rakefiles = DEFAULT_BUILDFILES
-    end
-
-    def run()
-      standard_exception_handling do
+  module Buildr
+    class Application < Rake::Application #:nodoc:
+
+      DEFAULT_BUILDFILES = ["buildfile", "Buildfile"] + DEFAULT_RAKEFILES
+
+      OPTIONS = [     # :nodoc:
+        ['--help',     '-H', GetoptLong::NO_ARGUMENT,
+          "Display this help message."],
+        ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
+          "Do not search parent directories for the buildfile."],
+        ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
+          "Do not log messages to standard output."],
+        ['--buildfile', '-f', GetoptLong::OPTIONAL_ARGUMENT,
+          "Use FILE as the buildfile."],
+        ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
+          "Require MODULE before executing buildfile."],
+        ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
+          "Turn on invoke/execute tracing, enable full backtrace."],
+        ['--verbose',  '-v', GetoptLong::NO_ARGUMENT,
+          "Log message to standard output (default)."],
+        ['--version',  '-V', GetoptLong::NO_ARGUMENT,
+          "Display the program version."],
+        ['--freeze',   "-F",  GetoptLong::NO_ARGUMENT,
+         "Freezes the Buildfile so it always uses Buildr version #{Buildr::VERSION}"],
+        ['--unfreeze', "-U",  GetoptLong::NO_ARGUMENT,
+         "Unfreezes the Buildfile to use the latest version of Buildr"]
+      ]
+
+      def initialize()
+        super
+        @rakefiles = DEFAULT_BUILDFILES
         @name = "Buildr"
         opts = GetoptLong.new(*command_line_options)
         opts.each { |opt, value| do_option(opt, value) }
         collect_tasks
-        load_buildfile
-        top_level
       end
-    end
 
-    def do_option(opt, value)
-      case opt
-      when '--help'
-        help
-        exit
-      when "--buildfile"
-        @rakefiles.clear
-        @rakefiles << value
-      when '--version'
-        puts "Buildr, version #{Buildr::VERSION}"
-        exit
-      when "--freeze" 
-        find_buildfile
-        puts "Freezing the Buildfile so it always uses Buildr version #{Buildr::VERSION}"
-        gem = 
-        original = File.read(rakefile)
-        if original =~ /gem\s*(["'])buildr\1/
-          modified = original.sub(/gem\s*(["'])buildr\1\s*,\s*(["']).*\2/, %{gem "buildr", "#{Buildr::VERSION}"})
-        else
-          modified = %{gem "buildr", "#{Buildr::VERSION}"\n} + original
+      def run()
+        standard_exception_handling do
+          load_buildfile
+          top_level
         end
-        File.open(rakefile, "w") { |file| file.write modified }
-        exit
-      when "--unfreeze"
-        find_buildfile
-        puts "Unfreezing the Buildfile to use the latest version of Buildr from your Gems repository."
-        modified = File.read(rakefile).sub(/^\s*gem\s*(["'])buildr\1.*\n/, "")
-        File.open(rakefile, "w") { |file| file.write modified }
-        exit
-      when '--require', "--nosearch", "--quiet", "--trace", "--verbose"
-        super
       end
-    end
 
-    def find_buildfile()
-      here = Dir.pwd
-      while ! have_rakefile
-        Dir.chdir("..")
-        if Dir.pwd == here || options.nosearch
-          error = "No Buildfile found (looking for: #{@rakefiles.join(', ')})"
-          if STDIN.isatty
-            if $terminal.agree("To use Buildr you need a buildfile. Do you want me to create one? (yes/no)")
-              chdir(original_dir) { task("generate").invoke }
-            end
-            exit 1
+      def do_option(opt, value)
+        case opt
+        when '--help'
+          help
+          exit
+        when "--buildfile"
+          @rakefiles.clear
+          @rakefiles << value
+        when '--version'
+          puts "Buildr, version #{Buildr::VERSION}"
+          exit
+        when "--freeze" 
+          find_buildfile
+          puts "Freezing the Buildfile so it always uses Buildr version #{Buildr::VERSION}"
+          gem = 
+          original = File.read(rakefile)
+          if original =~ /gem\s*(["'])buildr\1/
+            modified = original.sub(/gem\s*(["'])buildr\1\s*,\s*(["']).*\2/, %{gem "buildr", "#{Buildr::VERSION}"})
           else
-            raise error
+            modified = %{gem "buildr", "#{Buildr::VERSION}"\n} + original
           end
+          File.open(rakefile, "w") { |file| file.write modified }
+          exit
+        when "--unfreeze"
+          find_buildfile
+          puts "Unfreezing the Buildfile to use the latest version of Buildr from your Gems repository."
+          modified = File.read(rakefile).sub(/^\s*gem\s*(["'])buildr\1.*\n/, "")
+          File.open(rakefile, "w") { |file| file.write modified }
+          exit
+        when '--require', "--nosearch", "--quiet", "--trace", "--verbose"
+          super
         end
+      end
+
+      def find_buildfile()
         here = Dir.pwd
+        while ! have_rakefile
+          Dir.chdir("..")
+          if Dir.pwd == here || options.nosearch
+            error = "No Buildfile found (looking for: #{@rakefiles.join(', ')})"
+            if STDIN.isatty
+              if $terminal.agree("To use Buildr you need a buildfile. Do you want me to create one? (yes/no)")
+                chdir(original_dir) { task("generate").invoke }
+              end
+              exit 1
+            else
+              raise error
+            end
+          end
+          here = Dir.pwd
+        end
       end
-    end
 
-    def load_buildfile()
-      find_buildfile
-      puts "(in #{Dir.pwd})"
-      load File.expand_path(@rakefile) if @rakefile != ''
-      load_imports
-    end
+      def load_buildfile()
+        find_buildfile
+        puts "(in #{Dir.pwd})"
+        load File.expand_path(@rakefile) if @rakefile != ''
+        load_imports
+      end
 
-    def usage()
-      puts "Buildr #{Buildr::VERSION}"
-      puts
-      puts "Usage:"
-      puts "  buildr [-f buildfile] {options} targets..."
-    end
+      def usage()
+        puts "Buildr #{Buildr::VERSION}"
+        puts
+        puts "Usage:"
+        puts "  buildr [-f buildfile] {options} targets..."
+      end
 
-    def help()
-      usage
-      puts
-      puts "Options:"
-      OPTIONS.sort.each do |long, short, mode, desc|
-        if mode == GetoptLong::REQUIRED_ARGUMENT
-          if desc =~ /\b([A-Z]{2,})\b/
-            long = long + "=#{$1}"
+      def help()
+        usage
+        puts
+        puts "Options:"
+        OPTIONS.sort.each do |long, short, mode, desc|
+          if mode == GetoptLong::REQUIRED_ARGUMENT
+            if desc =~ /\b([A-Z]{2,})\b/
+              long = long + "=#{$1}"
+            end
           end
+          printf "  %-20s (%s)\n", long, short
+          printf "      %s\n", desc
         end
-        printf "  %-20s (%s)\n", long, short
-        printf "      %s\n", desc
+        puts
+        puts "For help with your buildfile:"
+        puts "  buildr help"
+      end
+
+      def command_line_options
+        OPTIONS.collect { |lst| lst[0..-2] }
       end
-      puts
-      puts "For help with your buildfile:"
-      puts "  buildr help"
-    end
 
-    def command_line_options
-      OPTIONS.collect { |lst| lst[0..-2] }
     end
 
+    Rake.application = Application.new
   end
-
-  Rake.application = Application.new
 end
 
 

data/lib/buildr/hibernate.rb

@@ -12,7 +12,8 @@ module Buildr
       :dom4j        => "dom4j:dom4j:jar:1.6.1",
       :hibernate    => "org.hibernate:hibernate:jar:3.1.2",
       :xdoclet      => Buildr.group("xdoclet", "xdoclet-xdoclet-module", "xdoclet-hibernate-module",
-                         :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1-j5"]
+                         # :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1-j5"]
+                         :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1"]
     )
 
     class << self
@@ -50,10 +51,10 @@ module Buildr
       #     :drop=>"no", :create=>"yes", :output=>target) do
       #     fileset :dir=>source.to_s, :includes=>"**/*.hbm.xml"
       #   end
-      def schemaexport(options = nil, &block)
+      def schemaexport(options = nil)
         ant "schemaexport" do |ant|
           ant.taskdef :name=>"schemaexport", :classname=>"org.hibernate.tool.hbm2ddl.SchemaExportTask", :classpath=>requires
-          ant.schemaexport options, &block if options
+          ant.schemaexport(options) { yield ant if block_given? } if options
         end
       end
 

data/lib/core/common.rb

@@ -7,6 +7,23 @@ require "uri/open-sftp"
 
 class Hash
 
+  class << self
+
+    # :call-seq:
+    #   Hash.from_java_properties(string)
+    #
+    # Returns a hash from a string in the Java properties file format. For example:
+    #   str = "foo=bar\nbaz=fab"
+    #   Hash.from_properties(str)
+    #   => { "foo"=>"bar", "baz"=>"fab" }.to_properties
+    def from_java_properties(string)
+      string.gsub(/\\\n/, "").split("\n").select { |line| line =~ /^[^#].*=.*/ }.
+        map { |line| line.gsub(/\\[trnf\\]/) { |escaped| {?t=>"\t", ?r=>"\r", ?n=>"\n", ?f=>"\f", ?\\=>"\\"}[escaped[1]] } }.
+        inject({}) { |hash, line| name, value = line.split("=") ; hash[name] = value ; hash }
+    end
+
+  end
+
   # :call-seq:
   #   only(keys*) => hash
   #
@@ -32,6 +49,20 @@ class Hash
     self.inject({}) { |hash, pair| hash[pair[0]] = pair[1] unless keys.include?(pair[0]) ; hash }
   end
 
+  # :call-seq:
+  #   to_java_properties() => string
+  #
+  # Convert hash to string format used for Java properties file. For example:
+  #   { "foo"=>"bar", "baz"=>"fab" }.to_properties
+  #   => foo=bar
+  #      baz=fab
+  def to_java_properties()
+    keys.sort.map { |key|
+      value = self[key].gsub(/[\t\r\n\f\\]/) { |escape| "\\" + {"\t"=>"t", "\r"=>"r", "\n"=>"n", "\f"=>"f", "\\"=>"\\"}[escape] }
+      "#{key}=#{value}"
+    }.join("\n")
+  end
+
 end
 
 
@@ -44,17 +75,75 @@ module Buildr
   #   options.java_args = "-Xmx512M"
   class Options
 
+    # We use this to present environment variable as arrays.
+    class EnvArray < Array #:nodoc:
+    
+      def initialize(name)
+        @name = name.upcase
+        replace((ENV[@name] || ENV[@name.downcase] || "").split(/\s*,\s*/).reject(&:empty?))
+      end
+
+      (Array.instance_methods - Object.instance_methods - Enumerable.instance_methods).sort.each do |method|
+        class_eval %{def #{method}(*args, &block) ; result = super ; write ; result ; end}
+      end
+
+    private
+
+      def write()
+        ENV[@name.downcase] = nil
+        ENV[@name] = map(&:to_s).join(",")
+      end
+
+    end
+
+    # Wraps around the proxy environment variables:
+    # * :http -- HTTP_PROXY
+    # * :exclude -- NO_PROXY
+    class Proxies
+
+      # Returns the HTTP_PROXY URL.
+      def http()
+        ENV["HTTP_PROXY"] || ENV["http_proxy"]
+      end
+
+      # Sets the HTTP_PROXY URL.
+      def http=(url)
+        ENV["http_proxy"] = nil
+        ENV["HTTP_PROXY"] = url
+      end
+   
+      # Returns list of hosts to exclude from proxying (NO_PROXY). 
+      def exclude()
+        @exclude ||= EnvArray.new("NO_PROXY")
+      end
+
+      # Sets list of hosts to exclude from proxy (NO_PROXY). Accepts host name, array of names,
+      # or nil to clear the list.
+      def exclude=(url)
+        exclude.clear
+        exclude.concat [url].flatten if url
+        exclude
+      end
+
+    end
+
     # :call-seq:
     #   proxy() => options
     #
     # Returns the proxy options. Currently supported options are:
     # * :http -- HTTP proxy for use when downloading.
+    # * :exclude -- Do not use proxy for these hosts/domains.
     #
     # For example:
     #   options.proxy.http = "http://proxy.acme.com:8080"
     # You can also set it using the environment variable HTTP_PROXY.
+    #
+    # You can exclude individual hosts from being proxied, or entire domains, for example:
+    #   options.proxy.exclude = "optimus"
+    #   options.proxy.exclude = ["optimus", "prime"]
+    #   options.proxy.exclude << "*.internal"
     def proxy()
-      @proxy ||= Struct.new(:http).new(ENV['HTTP_PROXY'] || ENV['http_proxy'])
+      @proxy ||= Proxies.new
     end
 
   end
@@ -191,26 +280,45 @@ module Buildr
   # Without any mapping, the filter simply copies files from the source directory into the target
   # directory.
   #
+  # A filter has one target directory, but you can specify any number of source directories,
+  # either when creating the filter or calling #from. Include/exclude patterns are specified
+  # relative to the source directories, so:
+  #   filter.include "*.png"
+  # will only include PNG files from any of the source directories.
+  #
   # See Buildr#filter.
   class Filter
 
     def initialize() #:nodoc:
       @include = []
       @exclude = []
+      @sources = []
     end
 
-    # The source directory as a file task.
-    attr_accessor :source
+    # Returns the list of source directories (each being a file task).
+    attr_reader :sources
+
+    # *Deprecated* Use #sources instead.
+    def source()
+      warn_deprecated "Please use sources instead."
+      @sources.first
+    end
 
+    # *Deprecated* Use #from instead.
+    def source=(dir)
+      warn_deprecated "Please use from instead."
+      from(dir)
+    end
+    
     # :call-seq:
-    #   from(dir) => self
+    #   from(*sources) => self
     #
-    # Sets the source directory from which files are copied and returns self.
+    # Adds additional directories from which to copy resources.
     #
     # For example:
     #   filter.from("src").into("target").using("build"=>Time.now)
-    def from(dir)
-      @source = file(File.expand_path(dir.to_s))
+    def from(*sources)
+      @sources |= sources.flatten.map { |dir| file(File.expand_path(dir.to_s)) }
       self
     end
 
@@ -277,35 +385,40 @@ module Buildr
     #
     # Runs the filter.
     def run()
-      raise "No source directory specified, where am I going to find the files to filter?" if source.nil?
-      raise "Source directory #{source} doesn't exist" unless File.exist?(source.to_s)
+      raise "No source directory specified, where am I going to find the files to filter?" if sources.empty?
+      sources.each { |source| raise "Source directory #{source} doesn't exist" unless File.exist?(source.to_s) }
       raise "No target directory specified, where am I going to copy the files to?" if target.nil?
 
-      includes = @include.empty? ? ["*"] : @include
-      src_base = Pathname.new(source.to_s)
-      copy_map = Dir[File.join(source.to_s, "**/*")].reject { |file| File.directory?(file) }.
-        map { |src| Pathname.new(src).relative_path_from(src_base).to_s }.
-        select { |file| includes.any? { |pattern| File.fnmatch(pattern, file) } }.
-        reject { |file| @exclude.any? { |pattern| File.fnmatch(pattern, file) } }.
-        map { |file| [File.expand_path(file, target.to_s), File.expand_path(file, source.to_s)] }.
-        select { |dest, src| !File.exist?(dest) || File.stat(src).mtime > File.stat(dest).mtime }
+      copy_map = sources.flatten.map(&:to_s).inject({}) do |map, source|
+        base = Pathname.new(source)
+        files = FileList[File.join(source, "**/*")].reject { |file| File.directory?(file) }.
+          map { |file| Pathname.new(file).relative_path_from(base).to_s }.
+          select { |file| @include.empty? || @include.any? { |pattern| File.fnmatch(pattern, file) } }.
+          reject { |file| @exclude.any? { |pattern| File.fnmatch(pattern, file) } }
+        files.each do |file|
+          src, dest = File.expand_path(file, source), File.expand_path(file, target.to_s)
+          map[file] = src if !File.exist?(dest) || File.stat(src).mtime > File.stat(dest).mtime
+        end
+        map
+      end
+        
       return false if copy_map.empty?
 
       verbose(Rake.application.options.trace || false) do
         mkpath target.to_s
-        copy_map.each do |dest, src|
+        copy_map.each do |path, source|
+          dest = File.expand_path(path, target.to_s)
           mkpath File.dirname(dest) rescue nil
           case mapping
           when Proc, Method # Call on input, accept output.
-            relative = Pathname.new(src).relative_path_from(src_base).to_s
-            mapped = mapping.call(relative, File.open(src, "rb") { |file| file.read })
+            mapped = mapping.call(path, File.open(source, "rb") { |file| file.read })
             File.open(dest, "wb") { |file| file.write mapped }
           when Hash # Map ${key} to value
-            mapped = File.open(src, "rb") { |file| file.read }.
+            mapped = File.open(source, "rb") { |file| file.read }.
               gsub(/\$\{[^}]*\}/) { |str| mapping[str[2..-2]] || str }
             File.open(dest, "wb") { |file| file.write mapped }
           when nil # No mapping.
-            cp src, dest
+            cp source, dest
           else
             fail "Filter can be a hash (key=>value), or a proc/method; I don't understand #{mapping}"
           end
@@ -323,9 +436,9 @@ module Buildr
   end
 
   # :call-seq:
-  #   filter(source) => Filter
+  #   filter(*source) => Filter
   #
-  # Creates a filter that will copy files from the source directory into the target directory.
+  # Creates a filter that will copy files from the source directory(ies) into the target directory.
   # You can extend the filter to modify files by mapping <tt>${key}</tt> into values in each
   # of the copied files, and by including or excluding specific files.
   #
@@ -336,8 +449,8 @@ module Buildr
   # To include only the text files, and replace each instance of <tt>${build}</tt> with the current
   # date/time:
   #   filter("src/files").into("target/classes").include("*.txt").using("build"=>Time.now).run
-  def filter(source)
-    Filter.new.from(source)
+  def filter(*sources)
+    Filter.new.from(*sources)
   end
 
 end

data/lib/core/transports.rb

@@ -56,7 +56,6 @@ module URI
     #   File.open("image.jpg", "w") { |file| file.write URI.read("http://example.com/image.jpg") }
     #
     # Supported options:
-    # * :proxy -- Collection of proxy settings, accessed by scheme.
     # * :modified -- Only download if file modified since this timestamp. Returns nil if not modified.
     # * :progress -- Show the progress bar while reading.
     def read(uri, options = nil, &block)
@@ -94,7 +93,6 @@ module URI
     #   write "sftp://localhost/jars/killer-app.jar", File.read("killer-app.jar")
     #
     # Supported options:
-    # * :proxy -- Collection of proxy settings, accessed by scheme.
     # * :progress -- Show the progress bar while reading.
     def write(uri, *args, &block)
       uri = URI.parse(uri.to_s) unless URI === uri
@@ -176,7 +174,19 @@ module URI
     #
     # For options, see URI::write.
     def write(*args, &block)
-      fail "This protocol doesn't support writing (yet, how about helping by implementing it?)"
+      options = args.pop if Hash === args.last
+      options ||= {}
+      if String === args.first
+        ios = StringIO.new(args.first, "r")
+        write(options.merge(:size=>args.first.size)) { |bytes| ios.read(bytes) }
+      elsif args.first.respond_to?(:read)
+        size = args.first.size rescue nil
+        write({:size=>size}.merge(options)) { |bytes| args.first.read(bytes) }
+      elsif args.empty? && block
+        write_internal options, &block
+      else
+        raise ArgumentError, "Either give me the content, or pass me a block, otherwise what would I upload?"
+      end
     end
 
     # :call-seq:
@@ -274,8 +284,26 @@ module URI
       end
     end
 
+    # :call-seq:
+    #   proxy_uri() => URI?
+    #
+    # Returns the proxy server to use. Obtains the proxy from the relevant environment variable (e.g. HTTP_PROXY).
+    # Supports exclusions based on host name and port number from environment variable NO_PROXY.
+    def proxy_uri()
+      proxy = ENV["#{scheme.upcase}_PROXY"]
+      proxy = URI.parse(proxy) if String === proxy
+      excludes = (ENV["NO_PROXY"] || "").split(/\s*,\s*/).compact
+      excludes = excludes.map { |exclude| exclude =~ /:\d+$/ ? exclude : "#{exclude}:*" }
+      return proxy unless excludes.any? { |exclude| File.fnmatch(exclude, "#{host}:#{port}") }
+    end
+
+    def write_internal(options, &block) #:nodoc:
+      fail "This protocol doesn't support writing (yet, how about helping by implementing it?)"
+    end
+
   end
 
+
   class HTTP #:nodoc:
 
     # See URI::Generic#read
@@ -322,8 +350,7 @@ module URI
         end
       end
 
-      proxy = options[:proxy] && options[:proxy].http
-      if proxy
+      if proxy = proxy_uri
         proxy = URI.parse(proxy) if String === proxy
         Net::HTTP.start(host, port, proxy.host, proxy.port, proxy.user, proxy.password) { |http| request[http] }
       else
@@ -334,6 +361,7 @@ module URI
 
   end
 
+
   class SFTP #:nodoc:
 
     class << self
@@ -343,65 +371,53 @@ module URI
       end
     end
 
-    # See URI::Generic#write
-    def write(*args, &block)
-      options = args.pop if Hash === args.last
-      options ||= {}
-      if String === args.first
-        ios = StringIO.new(args.first, "r")
-        write(options.merge(:size=>args.first.size)) { |bytes| ios.read(bytes) }
-      elsif args.first.respond_to?(:read)
-        size = args.first.size rescue nil
-        write({:size=>size}.merge(options)) { |bytes| args.first.read(bytes) }
-      elsif args.empty? && block
+  protected
 
-        # SSH options are based on the username/password from the URI.
-        ssh_options = { :port=>port, :username=>user }.merge(options[:ssh_options] || {})
-        ssh_options[:password] ||= SFTP.passwords[host]
-        begin
-          puts "Connecting to #{host}" if Rake.application.options.trace
-          session = Net::SSH.start(host, ssh_options)
-          SFTP.passwords[host] = ssh_options[:password]
-        rescue Net::SSH::AuthenticationFailed=>ex
-          # Only if running with console, prompt for password.
-          if !ssh_options[:password] && $stdout.isatty
-            password = HighLine.new.ask("Password for #{host}:") { |q| q.echo = "*" }
-            ssh_options[:password] = password
-            retry
-          end
-          raise
+    def write_internal(options, &block) #:nodoc:
+      # SSH options are based on the username/password from the URI.
+      ssh_options = { :port=>port, :username=>user }.merge(options[:ssh_options] || {})
+      ssh_options[:password] ||= SFTP.passwords[host]
+      begin
+        puts "Connecting to #{host}" if Rake.application.options.trace
+        session = Net::SSH.start(host, ssh_options)
+        SFTP.passwords[host] = ssh_options[:password]
+      rescue Net::SSH::AuthenticationFailed=>ex
+        # Only if running with console, prompt for password.
+        if !ssh_options[:password] && $stdout.isatty
+          password = HighLine.new.ask("Password for #{host}:") { |q| q.echo = "*" }
+          ssh_options[:password] = password
+          retry
         end
+        raise
+      end
 
-        session.sftp.connect do |sftp|
-          puts "connected" if Rake.application.options.trace
+      session.sftp.connect do |sftp|
+        puts "connected" if Rake.application.options.trace
 
-          # To create a path, we need to create all its parent. We use realpath to determine if
-          # the path already exists, otherwise mkdir fails.
-          puts "Creating path #{@base_path}" if Rake.application.options.trace
-          path.split("/").inject("") do |base, part|
-            combined = base + part
-            sftp.realpath combined rescue sftp.mkdir combined, {}
-            "#{combined}/"
-          end
+        # To create a path, we need to create all its parent. We use realpath to determine if
+        # the path already exists, otherwise mkdir fails.
+        puts "Creating path #{@base_path}" if Rake.application.options.trace
+        path.split("/").inject("") do |base, part|
+          combined = base + part
+          sftp.realpath combined rescue sftp.mkdir combined, {}
+          "#{combined}/"
+        end
 
-          with_progress_bar options[:progress] && options[:size], path.split("/"), options[:size] || 0 do |progress|
-            puts "Uploading to #{path}" if Rake.application.options.trace
-            sftp.open_handle(path, "w") do |handle|
-              # Writing in chunks gives us the benefit of a progress bar,
-              # but also require that we maintain a position in the file,
-              # since write() with two arguments always writes at position 0.
-              pos = 0
-              while chunk = yield(32 * 4096)
-                sftp.write(handle, chunk, pos)
-                pos += chunk.size
-                progress << chunk
-              end
-              sftp.setstat(target_path, :permissions => options[:permissions]) if options[:permissions]
+        with_progress_bar options[:progress] && options[:size], path.split("/"), options[:size] || 0 do |progress|
+          puts "Uploading to #{path}" if Rake.application.options.trace
+          sftp.open_handle(path, "w") do |handle|
+            # Writing in chunks gives us the benefit of a progress bar,
+            # but also require that we maintain a position in the file,
+            # since write() with two arguments always writes at position 0.
+            pos = 0
+            while chunk = yield(32 * 4096)
+              sftp.write(handle, chunk, pos)
+              pos += chunk.size
+              progress << chunk
             end
+            sftp.setstat(path, :permissions => options[:permissions]) if options[:permissions]
           end
         end
-      else
-        raise ArgumentError, "Either give me the content, or pass me a block, otherwise what would I upload?"
       end
     end
 
@@ -452,38 +468,6 @@ module URI
       end
     end
 
-    # See URI::Generic#write
-    def write(*args, &block)
-      options = args.pop if Hash === args.last
-      options ||= {}
-      raise ArgumentError, "Either you're attempting to write a file to another host (which we don't support), or you used two slashes by mistake, where you should have file:///<path>." unless host.blank?
-
-      if String === args.first
-        ios = StringIO.new(args.first, "r")
-        write(options.merge(:size=>args.first.size)) { |bytes| ios.read(bytes) }
-      elsif args.first.respond_to?(:read)
-        size = args.first.size rescue nil
-        write({:size=>size}.merge(options)) { |bytes| args.first.read(bytes) }
-      elsif args.empty? && block
-        temp = nil
-        Tempfile.open File.basename(path) do |temp|
-          temp.binmode
-          with_progress_bar options[:progress] && options[:size], path.split("/"), options[:size] || 0 do |progress|
-            while chunk = yield(32 * 4096)
-              temp.write chunk
-              progress << chunk
-            end
-          end
-        end
-        real_path.tap do |path|
-          mkpath File.dirname(path)
-          File.move temp.path, path
-        end
-      else
-        raise ArgumentError, "Either give me the content, or pass me a block, otherwise what would I upload?"
-      end
-    end
-
     def to_s()
       "file://#{host}#{path}"
     end
@@ -495,6 +479,26 @@ module URI
       RUBY_PLATFORM =~ /win32/ && path =~ /^\/[a-zA-Z]:\// ? path[1..-1] : path
     end
 
+  protected
+
+    def write_internal(options, &block) #:nodoc:
+      raise ArgumentError, "Either you're attempting to write a file to another host (which we don't support), or you used two slashes by mistake, where you should have file:///<path>." unless host.blank?
+      temp = nil
+      Tempfile.open File.basename(path) do |temp|
+        temp.binmode
+        with_progress_bar options[:progress] && options[:size], path.split("/"), options[:size] || 0 do |progress|
+          while chunk = yield(32 * 4096)
+            temp.write chunk
+            progress << chunk
+          end
+        end
+      end
+      real_path.tap do |path|
+        mkpath File.dirname(path)
+        File.move temp.path, path
+      end
+    end
+
     @@schemes["FILE"] = FILE
 
   end

data/lib/java/artifact.rb

@@ -100,7 +100,7 @@ module Buildr
     # In the first form, uses the upload options specified by repositories.release_to.
     # In the second form, uses a URL that includes all the relevant information.
     # In the third form, uses a hash with the options :url, :username, :password,
-    # :proxy and :permissions. All but :url are optional.
+    # and :permissions. All but :url are optional.
     def upload(upload_to = nil)
       # Where do we release to?
       upload_to ||= Buildr.repositories.release_to
@@ -117,7 +117,7 @@ module Buildr
       # Upload artifact relative to base URL, need to create path before uploading.
       puts "Deploying #{to_spec}" if verbose
       path = group.gsub(".", "/") + "/#{id}/#{version}/#{File.basename(name)}"
-      URI.upload uri + path, name, :proxy=>Buildr.options.proxy, :permissions=>upload_to[:permissions]
+      URI.upload uri + path, name, :permissions=>upload_to[:permissions]
     end
 
   protected
@@ -275,7 +275,7 @@ module Buildr
         begin
           path = group.gsub(".", "/") + "/#{id}/#{version}/#{File.basename(name)}"
           mkpath File.dirname(name), :verbose=>false
-          URI.download repo_url + path, name, :proxy=>Buildr.options.proxy
+          URI.download repo_url + path, name
           true
         rescue URI::NotFoundError
           false
@@ -396,8 +396,8 @@ module Buildr
           mkpath File.dirname(filename), :verbose=>false
           # We absolutely need the POM, so make sure we download it before the artifact
           # (unless the artifact is a POM).
-          URI.download repo_url + path.ext("pom"), name.ext("pom"), :proxy=>Buildr.options.proxy unless type == :pom
-          URI.download repo_url + path, filename, :proxy=>Buildr.options.proxy
+          URI.download repo_url + path.ext("pom"), filename.ext("pom")  unless type == :pom
+          URI.download repo_url + path, filename
           true
         rescue URI::NotFoundError
           false
@@ -584,13 +584,13 @@ module Buildr
         puts "Deploying #{arg.to_spec}" if verbose
         spec = arg.to_spec_hash
         path = spec[:group].gsub(".", "/") + "/#{spec[:id]}/#{spec[:version]}/" + Artifact.hash_to_file_name(spec)
-        URI.upload uri + path, arg.to_s, :proxy=>Buildr.options.proxy, :permissions=>deploy_to[:permissions]
+        URI.upload uri + path, arg.to_s, :permissions=>deploy_to[:permissions]
       else
         # Upload file to URL.
         puts "Deploying #{arg}" if verbose
         path = File.basename(args.to_s)
         path = File.join(options[:path], path) if options[:path]
-        URI.upload uri + path, arg.to_s, :proxy=>Buildr.options.proxy, :permissions=>deploy_to[:permissions]
+        URI.upload uri + path, arg.to_s, :permissions=>deploy_to[:permissions]
       end
     end
   end

data/lib/java/compile.rb

@@ -255,7 +255,7 @@ module Buildr
       def initialize(*args) #:nodoc:
         super
         @filter = Buildr::Filter.new
-        enhance { filter.run if filter.source && filter.target }
+        enhance { filter.run unless filter.sources.empty? }
       end
 
       # :call-seq:
@@ -277,13 +277,28 @@ module Buildr
       end
 
       # :call-seq:
-      #   source() => task
+      #   from(*sources) => self
+      #
+      # Adds additional directories from which to copy resources.
       #
-      # Returns the filter's source directory as a file task.
+      # For example:
+      #   resources.from _("src/etc")
+      def from(*sources)
+        filter.from *sources
+        self
+      end
+
+      # *Deprecated* Use #sources instead.
       def source()
+        warn_deprecated "Please use sources instead."
         filter.source
       end
 
+      # Returns the list of source directories (each being a file task).
+      def sources()
+        filter.sources
+      end
+
       # :call-seq:
       #   target() => task
       #
@@ -293,7 +308,7 @@ module Buildr
       end
 
       def prerequisites() #:nodoc:
-        super + [filter.source].compact
+        super + filter.sources.flatten
       end
 
     end
@@ -499,7 +514,7 @@ module Buildr
     # can access by calling resources.filter (see Buildr::Filter).
     #
     # For example:
-    #   resources.filter.include "config.xml"
+    #   resources.from _("src/etc")
     #   resources.filter.using "Copyright"=>"Acme Inc, 2007"
     def resources(*prereqs, &block)
       task("resources").enhance prereqs, &block
@@ -528,7 +543,7 @@ module Buildr
     prepare = task("prepare")
     # Resources task is a filter.
     resources = Java::ResourcesTask.define_task("resources")
-    project.path_to("src/main/resources").tap { |dir| resources.filter.from dir if File.exist?(dir) }
+    project.path_to("src/main/resources").tap { |dir| resources.from dir if File.exist?(dir) }
     # Compile task requires prepare and performs resources, if anything compiled.
     compile = Java::CompileTask.define_task("compile"=>[prepare, resources])
     project.path_to("src/main/java").tap { |dir| compile.from dir if File.exist?(dir) }
@@ -552,18 +567,21 @@ module Buildr
 
   class Options
 
-    # Runs the compile in debugging mode when true (default).
+    # Returns the debug option (environment variable DEBUG).
+    def debug()
+      (ENV["DEBUG"] || ENV["debug"]) !~ /(no|off|false)/
+    end
+
+    # Sets the debug option (environment variable DEBUG).
     #
     # You can turn this option off directly, or by setting the environment variable
     # DEBUG to "no". For example:
     #   buildr build DEBUG=no
     #
     # The release tasks runs a build with <tt>DEBUG=no</tt>.
-    attr_accessor :debug
-
-    def debug() #:nodoc:
-      @debug = (ENV["DEBUG"] || ENV["debug"]) !~ /(no|off|false)/ if @debug.nil?
-      @debug
+    def debug=(flag)
+      ENV["debug"] = nil
+      ENV["DEBUG"] = flag.to_s
     end
 
   end

data/lib/java/idea.rb

@@ -36,7 +36,7 @@ module Buildr
       excludes = [ '**/.svn/', '**/CVS/' ].join('|')
 
       # Only for projects that are packageable.
-      task_name = project.path_to("#{project.name.sub(':', '-')}.iml")
+      task_name = project.path_to("#{project.name.gsub(':', '-')}.iml")
       idea.enhance [ file(task_name) ]
 
       # The only thing we need to look for is a change in the Buildfile.
@@ -123,7 +123,7 @@ module Buildr
 
       # Root project aggregates all the subprojects.
       if project.parent == nil
-        task_name = project.path_to("#{project.name.sub(':', '-')}.ipr")
+        task_name = project.path_to("#{project.name.gsub(':', '-')}.ipr")
         idea.enhance [ file(task_name) ]
 
         file(task_name=>sources) do |task|
@@ -136,7 +136,8 @@ module Buildr
             xml.modules do
               project.projects.each do |subp|
                 module_name = subp.name.gsub(":", "-")
-                module_path = subp.name[/:(.*)/][1..-1]
+                module_path = subp.name.split(":"); module_path.shift
+                module_path = module_path.join("/")
                 path = "#{module_path}/#{module_name}.iml"
                 xml.module :fileurl=>"file://$PROJECT_DIR$/#{path}", :filepath=>"$PROJECT_DIR$/#{path}"
               end

data/lib/java/test.rb

@@ -586,7 +586,7 @@ module Buildr
     #project.recursive_task("test")
     # Similar to the regular resources task but using different paths.
     resources = Java::ResourcesTask.define_task("test:resources")
-    project.path_to("src/test/resources").tap { |dir| resources.filter.from dir if File.exist?(dir) }
+    project.path_to("src/test/resources").tap { |dir| resources.from dir if File.exist?(dir) }
     # Similar to the regular compile task but using different paths.
     compile = Java::CompileTask.define_task("test:compile"=>[project.compile, task("test:prepare"), project.test.resources])
     project.path_to("src/test/java").tap { |dir| compile.from dir if File.exist?(dir) }
@@ -620,26 +620,37 @@ module Buildr
     # Set to false to not run any test cases. Set to :all to run all test cases, ignoring failures.
     #
     # This option is set from the environment variable "test", so you can also do:
-    #   buildr            # With tests
-    #   buildr test=no  # Without tests
-    #   buildr test=all   # Ignore failures
-    attr_accessor :test
-
-    def test() #:nodoc:
-      if @test.nil?
-        case value = ENV["TEST"] || ENV["test"]
-        when /^(no|off|false|skip)$/i
-          @test = false
-        when /^all$/i
-          @test = :all
-        when /^(yes|on|true)$/i, nil
-          @test = true
-        else
-          warn "Expecting the environment variable test to be 'no' or 'all', not sure what to do with #{value}, so I'm just going to run all the test cases and stop at failure."
-          @test = true
-        end
+
+    # Returns the test option (environment variable TEST). Possible values are:
+    # * :false -- Do not run any test cases (also accepts "no" and "skip").
+    # * :true -- Run all test cases, stop on failure (default if not set).
+    # * :all -- Run all test cases, ignore failures.
+    def test()
+      case value = ENV["TEST"] || ENV["test"]
+      when /^(no|off|false|skip)$/i
+        false
+      when /^all$/i
+        :all
+      when /^(yes|on|true)$/i, nil
+        true
+      else
+        warn "Expecting the environment variable test to be 'no' or 'all', not sure what to do with #{value}, so I'm just going to run all the test cases and stop at failure."
+        true
       end
-      @test
+    end
+
+    # Sets the test option (environment variable TEST). Possible values are true, false or :all.
+    #
+    # You can also set this from the environment variable, e.g.:
+    #
+    #   buildr          # With tests
+    #   buildr test=no  # Without tests
+    #   buildr test=all # Ignore failures
+    #   set TEST=no
+    #   buildr          # Without tests
+    def test=(flag)
+      ENV["test"] = nil
+      ENV["TEST"] = flag.to_s
     end
 
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: buildr
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
-date: 2007-07-06 00:00:00 -07:00
+  version: 1.2.1
+date: 2007-07-12 00:00:00 -07:00
 summary: A build system that doesn't suck
 require_paths: 
 - lib