buildr 0.20.0 → 0.21.0

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.21 (4/20/2007)
+* Added: Methods to read and write a file (shortcut for File.read/File.open.write).
+* Changed: Filter task now takes a source directory and target directory, and copies all included (sans excluded) files between the two.
+* Changed: Artifact type is now symbol instead of string (so :jar instead of "jar"). You can still specify a string, but the return value from #to_spec or #type is a symbol.
+* Changed: Eclipse task now adds "src/main/resources", "src/test/java", "src/test/resources" to build path, and excludes ".svn" and "CVS" directories from being copied into target directories.
+* Changed: The test task will now run JUnit test cases from classes ending with Test or Suite. And the inclusion pattern is always set.
+* Fixed: Project property not inherited if false.
+
 0.20 (4/18/2007)
 * Added: JavadocTask to generate Javadoc documentation for the project, javadoc method on the project itself to return its javadoc task, and Java.javadoc to do all the heavy lifting.
 * Changed: Release code is now implemented as module instead of class. SVN copy made from working copy instead of double commit.
@@ -22,46 +30,33 @@
 * Added: jetty:start and jetty:stop tasks to start/stop the server from the console.
 * Added: jetty:use to start Jetty inside the build or hook to an existing server.
 * Added: jetty:setup and jetty:teardown to perform tasks around jetty:use.
-* Added: The local build task will now execute the local test task. So building a project (or sub-project)
-  will run the test cases on that project (or sub-project) but not any of its dependencies.
+* Added: The local build task will now execute the local test task. So building a project (or sub-project) will run the test cases on that project (or sub-project) but not any of its dependencies.
 * Added: ZipTask accepts nested path (i.e. calling path inside a path).
-* Added: package(:war) by defaults picks libraries from the compiler classpath. You can always override by
-  passing the :libs option.
-* Changed: Eclipse task now generates library path with M2_REPO variable or project-relative paths
-  where appropriate
-* Changed: compile.target (CompileTask) and resources.target (Filter) are now file tasks, not strings.
-  So passing the target to someone else will hopefully convience them to invoke or enhance it.
+* Added: package(:war) by defaults picks libraries from the compiler classpath. You can always override by passing the :libs option.
+* Changed: Eclipse task now generates library path with M2_REPO variable or project-relative paths where appropriate
+* Changed: compile.target (CompileTask) and resources.target (Filter) are now file tasks, not strings.  So passing the target to someone else will hopefully convience them to invoke or enhance it.
 * Changed: Java related tasks like OpenJPA, XMLBeans, JavaCC all moved to the Buildr::Java module.
 * Changed: Handling of package_as arguments to support JBI packaging.
 * Changed: meta_inf project property is an array accepting filenames (strings) and file tasks.
 * Changed: meta_info by default only includes the LICENSE file from the top-level project.
 * Changed: The WarTask :classes argument is now a directory name, and will include all files in this directory.
 * Changed: WarTask and JarTask accept meta_inf argument.
-* Changed: Behavior of needed? and prerequsities in base Rake::Task. This will probably not affect you,
-  but don't be surprised if it disappears (see lib/core/rake_ext.rb for details).
-* Changed: Were previous the test task would link to test.run, it now executes the entire test lifecycle,
-  and is the major point for extending the test lifecycle.
+* Changed: Behavior of needed? and prerequsities in base Rake::Task. This will probably not affect you, but don't be surprised if it disappears (see lib/core/rake_ext.rb for details).
+* Changed: Were previous the test task would link to test.run, it now executes the entire test lifecycle, and is the major point for extending the test lifecycle.
 * Changed: test.run is now test.junit.
 * Changed: Ant.define is now Ant.declarative, Ant.execute is now Ant.executable.
-* Changed: The filter method now returns a Filter class that can be used to set a filter, but is not itself
-  a task. Instead, it creates a task when setting its target.
-* Changed: Project.resources now returns a ResourceTask that includes, but is not itself a filter, accessed
-  using the accessor filter.
-* Changed: UnzipTask eliminated and replaced with Unzip which you now have to run directly by calling extract.
-  However, unzip method creates a file task and returns an Unzip object that can be used as a reference to
-  that file task.
+* Changed: The filter method now returns a Filter class that can be used to set a filter, but is not itself a task. Instead, it creates a task when setting its target.
+* Changed: Project.resources now returns a ResourceTask that includes, but is not itself a filter, accessed using the accessor filter.
+* Changed: UnzipTask eliminated and replaced with Unzip which you now have to run directly by calling extract.  However, unzip method creates a file task and returns an Unzip object that can be used as a reference to that file task.
 * Changed: Attributes is now InheritedAttributes.
-* Changed: The first call to package configures the package task from the options, the second call only returns
-  the package task.
+* Changed: The first call to package configures the package task from the options, the second call only returns the package task.
 * Removed: :cp argument, always use :classpath.
 * Removed: src_dir, java_src_dir, target_dir, webapp_src_dir and all other premature configuration attributes.
-* Removed: Project tests method deprecated in favor of a single test method; it now accepts an enhancement
-  block, not an instance_eval block.
+* Removed: Project tests method deprecated in favor of a single test method; it now accepts an enhancement block, not an instance_eval block.
 * Removed: FilterTask is dead.
 * Removed: sub_projects method. Is anyone using this?
 * Fixed: Local buildr.rb not loaded from running from inside a sub-project directory.
-* Fixed: Eclipse task now executed whenever a change is made in the Rakefile, or any file it requires,
-  include buildr.rb and task files.
+* Fixed: Eclipse task now executed whenever a change is made in the Rakefile, or any file it requires, include buildr.rb and task files.
 * Fixed: Circular dependency in release task.
 
 0.18 (3/26/2007)

data/lib/buildr.rb

@@ -30,7 +30,7 @@ end
 
 
 module Buildr
-  VERSION = "0.20.0"
+  VERSION = "0.21.0"
 end
 
 

data/lib/core/build.rb

@@ -77,7 +77,7 @@ module Buildr
         fail "Uncommitted SVN files violate the First Principle Of Release!\n#{status}" unless
           status.empty?
       end
-     
+
       # :call-seq:
       #   with_next_version() { |filename| ... } => version
       #
@@ -154,7 +154,7 @@ module Buildr
       # Last, we commit what we currently have in the working copy.
       def commit(version)
         rakefile = File.read(Rake.application.rakefile).
-          gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{version}"}) }.
+          gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{version}"}) }
         File.open(Rake.application.rakefile, "w") { |file| file.write rakefile }
         svn "commit", "-m", "Changed version number to #{version}", Rake.application.rakefile
       end

data/lib/core/common.rb

@@ -0,0 +1,260 @@
+require "tempfile"
+require "pathname"
+require "core/transports"
+
+module Buildr
+
+  # :call-seq:
+  #   write(name, content)
+  #   write(name) { ... }
+  #
+  # Write the contents into a file. The second form calls the block and writes the result.
+  #
+  # For example:
+  #   write "TIMESTAMP", Time.now
+  #   write("TIMESTAMP") { Time.now }
+  #
+  # Yields to the block before writing the file, so you can chain read and write together.
+  # For example:
+  #   write("README") { read("README").sub("${build}", Time.now) }
+  def write(name, content = nil)
+    mkpath File.dirname(name)
+    content = yield if block_given?
+    File.open(name.to_s, "w") { |file| file.write content.to_s }
+    content.to_s
+  end
+
+  # :call-seq:
+  #   read(name) => string
+  #   read(name) { |string| ... } => result
+  #
+  # Reads and returns the contents of a file. The second form yields to the block and returns
+  # the result of the block.
+  #
+  # For example:
+  #   puts read("README")
+  #   read("README") { |text| puts text }
+  def read(name)
+    if block_given?
+      yield File.read(name.to_s)
+    else
+      File.read(name.to_s)
+    end
+  end
+
+  # :call-seq:
+  #    download(url_or_uri) => task
+  #    download(path=>url_or_uri) =>task
+  #
+  # Create a task that will download a file from a URL.
+  #
+  # Takes a single argument, a hash with one pair. The key is the file being
+  # created, the value if the URL to download. The task executes only if the
+  # file does not exist; the URL is not checked for updates.
+  #
+  # The task will show download progress on the console; if there are MD5/SHA1
+  # checksums on the server it will verify the download before saving it.
+  #
+  # For example:
+  #   download "image.jpg"=>"http://example.com/theme/image.jpg"
+  def download(args)
+    if String === args || URI === args
+      # Given only a download URL, download into a temporary file.
+      # You can infer the file from task name.
+      temp = Tempfile.new(File.basename(args.to_s))
+      task = file_create(temp.path) do |task|
+        Transports.download task.source, task.name
+      end
+      task.sources << args
+    else
+      # Download to a file created by the task.
+      fail unless args.keys.size == 1
+      url = args.values.first
+      task = file_create(args.keys.first) do |task|
+        mkpath File.dirname(task.name), :verbose=>false
+        Transports.download task.source, task.name
+      end
+      task.sources << url
+    end
+    task
+  end
+
+  # A filter knows how to copy files from one directory to another, applying mappings to the
+  # contents of these files.
+  #
+  # You can specify the mapping using a Hash, and it will map ${key} fields found in each source
+  # file into the appropriate value in the target file. For example:
+  #   filter.using "version"=>"1.2", "build"=>Time.now
+  # will replace all occurrences of <tt>${version}</tt> with <tt>1.2</tt>, and <tt>${build}</tt>
+  # with the current date/time.
+  #
+  # You can also specify the mapping by passing a proc or a method, that will be called for
+  # each source file, with the file name and content, returning the modified content.
+  #
+  # Without any mapping, the filter simply copies files from the source directory into the target
+  # directory.
+  #
+  # See Buildr#filter.
+  class Filter
+
+    def initialize() #:nodoc:
+      @include = []
+      @exclude = []
+    end
+
+    # The source directory as a file task.
+    attr_accessor :source
+
+    # :call-seq:
+    #   from(dir) => self
+    #
+    # Sets the source directory from which files are copied and returns self.
+    #
+    # For example:
+    #   filter.from("src").into("target").using("build"=>Time.now)
+    def from(dir)
+      @source = file(File.expand_path(dir.to_s))
+      self
+    end
+
+    # The target directory as a file task.
+    attr_reader :target
+
+    # :call-seq:
+    #   into(dir) => self
+    #
+    # Sets the target directory into which files are copied and returns self.
+    #
+    # For example:
+    #   filter.from("src").into("target").using("build"=>Time.now)
+    def into(dir)
+      @target = file(File.expand_path(dir.to_s))
+      self
+    end
+
+    # :call-seq:
+    #   include(*files) => self
+    #
+    # Specifies files to include and returns self. See FileList#include.
+    #
+    # By default all files are included. You can use this method to only include specific
+    # files form the source directory.
+    def include(*files)
+      @include += files
+      self
+    end
+    alias :add :include 
+
+    # :call-seq:
+    #   exclude(*files) => self
+    #
+    # Specifies files to exclude and returns self. See FileList#exclude.
+    def exclude(*files)
+      @exclude += files
+      self
+    end
+
+    # The mapping. See #using.
+    attr_accessor :mapping
+
+    # :call-seq:
+    #   using(mapping) => self
+    #   using() { |file_name, contents| ... } => self
+    #
+    # Specifies the mapping to use and returns self.
+    #
+    # The mapping can be a proc or a method called with the file name and content, returning
+    # the modified content. Or the mapping can be a Hash for mapping each ${key} into a value.
+    # Without any mapping, all files are copied as is.
+    #
+    # For example:
+    #   filter.using "version"=>"1.2"
+    # will replace all occurrences of "${version}" with "1.2".
+    def using(mapping, &block)
+      self.mapping = mapping || block
+      self
+    end
+
+    # Runs the filter.
+    def run()
+      if needed?
+        unless copy_map.empty?
+          verbose(Rake.application.options.trace || false) do
+            mkpath target.to_s
+            copy_map do |dest, src|
+              mkpath File.dirname(dest) rescue nil
+              case mapping
+              when Proc, Method # Call on input, accept output.
+                mapped = mapping.call(src, File.open(src, "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 }.
+                  gsub(/\$\{.*\}/) { |str| mapping[str[2..-2]] || str }
+                File.open(dest, "wb") { |file| file.write mapped }
+              when nil # No mapping.
+                cp src, dest
+              else
+                fail "Filter can be a hash (key=>value), or a proc/method; I don't understand #{mapping}"
+              end
+            end
+            touch target.to_s
+          end
+        end
+      end
+    end
+
+    # Returns the target directory. 
+    def to_s()
+      @target.to_s
+    end    
+    
+  private
+
+    def needed?()
+      return false if target.nil? || source.nil? || !File.exist?(source.to_s)
+      return true unless File.exist?(target.to_s)
+      !copy_map.empty?
+    end
+
+    # Return a copy map of all the files that need copying: the key is the file to copy to,
+    # the value is the source file. If called with a block, yields with each dest/source pair.
+    def copy_map(&block)
+      unless @copy_map
+        @include = ["*"] if @include.empty?
+        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(base).to_s }.
+          select { |file| @include.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 }
+      end
+      if block_given?
+        @copy_map.each(&block)
+      else
+        @copy_map
+      end
+    end
+
+  end
+
+  # :call-seq:
+  #   filter(target=>source) => Filter
+  #
+  # Creates a filter that will copy files from the source directory 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.
+  #
+  # A filter is not a task, you must call the Filter#run method to execute it.
+  #
+  # For example, to copy all files from one directory to another:
+  #   filter("target/classes"=>"src/files")
+  # To include only the text files, and replace each instance of <tt>${build}</tt> with the current
+  # date/time:
+  #   filter("target/classes"=>"src/files").include("*.txt").using("build"=>Time.now)
+  def filter(args)
+    target, source = Rake.application.resolve_args(args)
+    Filter.new.into(target).tap { |filter| filter.from(source) if source }
+  end
+
+end

data/lib/core/project.rb

@@ -31,7 +31,8 @@ module Buildr
       block ||= proc { default }
       attr_accessor symbol
       define_method "#{symbol}_with_inheritence" do
-        unless value = send("#{symbol}_without_inheritence")
+        value = send("#{symbol}_without_inheritence")
+        if value.nil?
           value = parent ? parent.send(symbol) : self.instance_eval(&block)
           send "#{symbol}=", value
         end
@@ -454,6 +455,7 @@ module Buildr
     end
 
     def execute() #:nodoc:
+      # Reset the namespace, so all tasks are automatically defined in the project's namespace.
       Rake.application.in_namespace ":#{name}" do
         # Everything we do inside the project is relative to its working directory.
         Dir.chdir(base_dir) { super }

data/lib/java/artifact.rb

@@ -29,7 +29,7 @@ module Buildr
     attr_reader :id
     # The group identifier.
     attr_reader :group
-    # The file type.
+    # The file type. (Symbol)
     attr_reader :type
     # The version number.
     attr_reader :version
@@ -44,7 +44,7 @@ module Buildr
     # becomes:
     #   { :group=>"com.example",
     #     :id=>"app",
-    #     :type=>"jar",
+    #     :type=>:jar,
     #     :version=>"1.2" }
     def to_spec_hash()
       base = { :group=>group, :id=>id, :type=>type, :version=>version }
@@ -68,8 +68,8 @@ module Buildr
     # 
     # Convenience method that returns a POM artifact.
     def pom()
-      return self if type.to_s == "pom"
-      artifact(:group=>group, :id=>id, :version=>version, :type=>"pom", :classifier=>classifier)
+      return self if type == :pom
+      artifact(:group=>group, :id=>id, :version=>version, :type=>:pom, :classifier=>classifier)
     end
 
   protected
@@ -94,8 +94,8 @@ module Buildr
   # a site that doesn't have a remote repository structure, copy it from a different disk, etc.
   class Artifact < Rake::FileCreationTask
 
-    # The default file type for artifacts, if not specified.
-    DEFAULT_FILE_TYPE = "jar"
+    # The default artifact type.
+    DEFAULT_TYPE = :jar
 
     include ActsAsArtifact
 
@@ -142,7 +142,7 @@ module Buildr
           fail "Missing group identifier for #{spec.inspect}" if spec[:group].blank?
           fail "Missing artifact identifier for #{spec.inspect}" if spec[:id].blank?
           fail "Missing version for #{spec.inspect}" if spec[:version].blank?
-          spec[:type] = DEFAULT_FILE_TYPE if spec[:type].blank?
+          spec[:type] = spec[:type].blank? ? DEFAULT_TYPE : spec[:type].to_sym
           spec
         elsif String === spec
           group, id, type, version, *rest = spec.split(":")
@@ -166,7 +166,7 @@ module Buildr
         hash = to_hash(hash) unless Hash === hash
         version = ":#{hash[:version]}" unless hash[:version].blank?
         classifier = ":#{hash[:classifier]}" unless hash[:classifier].blank?
-        "#{hash[:group]}:#{hash[:id]}:#{hash[:type] || DEFAULT_FILE_TYPE}#{classifier}#{version}"
+        "#{hash[:group]}:#{hash[:id]}:#{hash[:type] || DEFAULT_TYPE}#{classifier}#{version}"
       end
 
       # :call-seq:
@@ -176,7 +176,7 @@ module Buildr
       def hash_to_file_name(hash)
         version = "-#{hash[:version]}" unless hash[:version].blank?
         classifier = "-#{hash[:classifier]}" unless hash[:classifier].blank?
-        "#{hash[:id]}#{version}#{classifier}.#{hash[:type] || DEFAULT_FILE_TYPE}"
+        "#{hash[:id]}#{version}#{classifier}.#{hash[:type] || DEFAULT_TYPE}"
       end
 
     end

data/lib/java/compile.rb

@@ -1,8 +1,8 @@
 require "core/project"
 require "core/build"
+require "core/common"
 require "java/artifact"
 require "java/java"
-require "tasks/filter"
 
 module Buildr
   module Java
@@ -253,7 +253,7 @@ module Buildr
 
       def initialize(*args) #:nodoc:
         super
-        @filter = Buildr::filter
+        @filter = Buildr::Filter.new
         enhance { filter.run }
       end
 
@@ -275,8 +275,24 @@ module Buildr
         self
       end
 
+      # :call-seq:
+      #   source() => task
+      #
+      # Returns the filter's source directory as a file task.
+      def source()
+        filter.source
+      end
+
+      # :call-seq:
+      #   target() => task
+      #
+      # Returns the filter's target directory as a file task.
+      def target()
+        filter.target
+      end
+
       def prerequisites() #:nodoc:
-        super + filter.sources
+        super + [filter.source].compact
       end
 
     end
@@ -520,7 +536,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.include project.path_to(dir, "*") if File.exist?(dir) }
+    resources.filter.from project.path_to("src/main/resources")
     # Compile task requires prepare and performs resources, if anything compiled.
     compile = Java::CompileTask.define_task("compile"=>[prepare, resources]) { |task| project.resources.invoke }
     project.path_to("src/main/java").tap { |dir| compile.from dir if File.exist?(dir) }

data/lib/java/eclipse.rb

@@ -37,32 +37,71 @@ module Buildr
             path = path.__send__(msg)
             Pathname.new(path).relative_path_from(Pathname.new(project.path_to)).to_s
           end
+
           m2repo = Buildr::Repositories.instance.local
+          excludes = [ '**/.svn/', '**/CVS/' ].join('|')
 
           File.open(task.name, "w") do |file|
             xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
             xml.classpath do
-              # Internal: projects that create artifacts we find on the classpath.
-              # External: other artifacts, typically from the local repository.
-              internal, external = project.compile.classpath.map(&:to_s).
-                map { |path| projects.detect { |prj| prj.packages.detect { |pkg| pkg.to_s == path } } || path }.
-                partition { |path| path.is_a?(Project) }
-              vars, libs = external.partition { |path| path.to_s.index(m2repo) == 0 }
-              generated, libs = libs.partition { |path| path.to_s.index(project.path_to.to_s) == 0 }
+              # Note: Use the test classpath since Eclipse compiles both "main" and "test" classes using the same classpath
+              cp = project.test.compile.classpath.map(&:to_s) - [ project.compile.target.to_s ]
+
+              # Convert classpath elements into applicable Project objects
+              cp.collect! { |path| projects.detect { |prj| prj.packages.detect { |pkg| pkg.to_s == path } } || path }
+
+              # project_libs: artifacts created by other projects
+              project_libs, others = cp.partition { |path| path.is_a?(Project) }
+
+              # Separate artifacts from Maven2 repository
+              m2_libs, others = others.partition { |path| path.to_s.index(m2repo) == 0 }
+
+              # Generated: classpath elements in the project are assumed to be generated
+              generated, libs = others.partition { |path| path.to_s.index(project.path_to.to_s) == 0 }
+
               xml.classpathentry :kind=>'con', :path=>'org.eclipse.jdt.launching.JRE_CONTAINER'
-              # Collect all the classpaths, key is the kind, value is
-              # string or array (or anything responding to to_a).
-              { :src    => project.compile.sources.map { |src| relative[src] } + generated.map { |src| relative[src] },
-                :output => relative[project.compile.target],
+
+              srcs = project.compile.sources.map { |src| relative[src] } + generated.map { |src| relative[src] }
+              srcs.sort.uniq.each do |path|
+                xml.classpathentry :kind=>'src', :path=>path, :excluding=>excludes
+              end
+
+              { :output => relative[project.compile.target],
                 :lib    => libs.map(&:to_s),
-                :var    => vars.map { |path| path.to_s.sub(m2repo, 'M2_REPO') }
+                :var    => m2_libs.map { |path| path.to_s.sub(m2repo, 'M2_REPO') }
               }.each do |kind, paths|
                 paths.sort.uniq.each do |path|
                   xml.classpathentry :kind=>kind, :path=>path
                 end
               end
-              internal.map(&:name).sort.uniq.each do |prj_name|
-                xml.classpathentry :kind=>"src", :combineaccessrules=>"false", :path=>"/#{prj_name}"
+
+              # Classpath elements from other projects
+              project_libs.map(&:name).sort.uniq.each do |prj_name|
+                xml.classpathentry :kind=>'src', :combineaccessrules=>"false", :path=>"/#{prj_name}"
+              end
+
+              # Main resources implicitly copied into project.compile.target
+              # TODO: find solution that uses project.test.resources.filter.sources
+              [ "src/main/resources" ].each do |path|
+                if File.exist? project.path_to(path)
+                  xml.classpathentry :kind=>'src', :path=>path, :excluding=>excludes
+                end
+              end
+
+              # Test classes are generated in a separate output directory
+              test_sources = project.test.compile.sources.map { |src| relative[src] }
+              test_sources.each do |paths|
+                paths.sort.uniq.each do |path|
+                  xml.classpathentry :kind=>'src', :path=>path, :output => relative[project.test.compile.target], :excluding=>excludes
+                end
+              end
+
+              # Test resources go in separate output directory as well
+              # TODO: find solution that uses project.test.resources.filter.sources
+              [ "src/test/resources" ].each do |path|
+                if File.exist? project.path_to(path)
+                  xml.classpathentry :kind=>'src', :path=>path, :output => relative[project.test.compile.target], :excluding=>excludes
+                end
               end
             end
           end

data/lib/java/packaging.rb

@@ -23,6 +23,7 @@ module Buildr
       # * A hash of manifest properties (name/value pairs).
       # * An array of hashes, one for each section of the manifest.
       # * A string providing the name of an existing manifest file.
+      # * A file task can be used the same way.
       # * Proc or method called to return the contents of the manifest file.
       # * False to not generate a manifest file.
       #
@@ -50,7 +51,7 @@ module Buildr
           if key.to_sym == :manifest
             self.manifest = value
           elsif key.to_sym == :meta_inf
-            self.meta_inf = value
+            self.meta_inf = [value].flatten
           else
             super key, value
           end
@@ -59,32 +60,30 @@ module Buildr
 
         def prerequisites() #:nodoc:
           super + [ String === manifest ? file(manifest) : nil ].compact +
-            meta_inf.map { |file| String === file ? file(file) : file }
+            [meta_inf].flatten.map { |file| String === file ? file(file) : file }
         end
 
       protected
 
         def create(zip) #:nodoc:
-          meta_inf.map(&:to_s).uniq.each { |file| zip.add "META-INF/#{File.basename(file)}", file }
+          [meta_inf].flatten.map(&:to_s).uniq.each { |file| zip.add "META-INF/#{File.basename(file)}", file }
           unless manifest == false
             zip.file.open("META-INF/MANIFEST.MF", "w") do |output|
-              output.write MANIFEST_HEADER
+              output << MANIFEST_HEADER
               if manifest
                 case manifest
                 when Hash
-                  output.write manifest.map { |pair| pair.join(": ") }.sort.join("\n")
+                  output << manifest.map { |pair| pair.map(&:to_s).join(": ") }.sort.join("\n")
                 when Array
-                  manifest.each do |section|
-                    output.write "\n"
-                    output.write section.map { |pair| pair.join(": ") }.sort.join("\n")
-                  end
+                  output << manifest.reject { |section| section.empty? }.map { |section|
+                      section.map { |pair| pair.join(": ") }.sort.join("\n").concat("\n")
+                    }.join("\n")
                 when Proc, Method
-                  output.write manifest.call 
-                when String
-                  output.write File.read(manifest)
+                  output << manifest.call 
+                when String, Task
+                  output << File.read(manifest.to_s)
                 end
               end
-              output.write "\n"
             end
           end
           super zip
@@ -124,21 +123,35 @@ module Buildr
 
   class Project
 
+    # Options accepted by #package method for all package types.
+    PACKAGE_OPTIONS = [:group, :id, :version, :type, :classifier]
+
+    # The project's identifier. Same as the project name, with colons replaced by dashes.
+    # The ID for project foo:bar is foo-bar.
+    attr_reader :id
+    def id()
+      name.gsub(":", "-")
+    end
+
     # Group used for packaging. Inherited from parent project. Defaults to the top-level project name.
     attr_accessor :group
     inherited_attr(:group) { |project| project.name }
+
     # Version used for packaging. Inherited from parent project.
     attr_accessor :version
     inherited_attr :version
-    # Manifest used for packaging. Inherited from parent project. The default value
-    # is a hash that includes the Build-By, Build-Jdk and Implementation-Version values.
-    # The later is taken from the project's version number.
+
+    # Manifest used for packaging. Inherited from parent project. The default value is a hash that includes
+    # the Build-By, Build-Jdk, Implementation-Title and Implementation-Version values.
+    # The later are taken from the project's comment (or name) and version number.
     attr_accessor :manifest
     inherited_attr :manifest do |project|
       manifest = { "Build-By"=>ENV['USER'], "Build-Jdk"=>Java.version }
+      manifest["Implementation-Title"] = self.comment || self.name
       manifest["Implementation-Version"] = project.version if project.version
       manifest
     end
+
     # Files to always include in the package META-INF directory. The default value include
     # the LICENSE file if one exists in the project's base directory.
     attr_accessor :meta_inf
@@ -147,13 +160,6 @@ module Buildr
       File.exist?(license.to_s) ? [license] : []
     end
 
-    # The project's identifier. Same as the project name, with colons replaced by dashes.
-    # The ID for project foo:bar is foo-bar.
-    attr_reader :id
-    def id()
-      name.gsub(":", "-")
-    end
-
     # :call-seq:
     #   package(type, options?) => task
     #
@@ -221,7 +227,7 @@ module Buildr
     # that accepts two arguments, the file name and a hash of options. The method must yield to the
     # block with the package only when first called to define the package, and must return the package
     # from each call.
-    def package(type, options = nil)
+    def package(type = :jar, options = nil)
       options = options.nil? ? {} : options.dup
       options[:id] ||= self.id
       options[:group] ||= self.group
@@ -230,7 +236,7 @@ module Buildr
       file_name = path_to("target", Artifact.hash_to_file_name(options))
 
       packager = method("package_as_#{type}") rescue
-        fail("Do not know how to create a package of type #{:type}")
+        fail("Don't know how to create a package of type #{type}")
       packager.call(file_name, options) do |package|
         # Make it an artifact using the specifications, and tell it how to create a POM.
         package.extend ActsAsArtifact
@@ -299,8 +305,9 @@ module Buildr
 
     def package_as_jar(file_name, options) #:nodoc:
       unless Rake::Task.task_defined?(file_name)
+        fu_check_options options, *PACKAGE_OPTIONS + [:manifest, :meta_inf, :include]
         Java::Packaging::JarTask.define_task(file_name).tap do |jar|
-          jar.manifest = options[:manifest] || manifest.merge("Implementation-Title"=>self.comment)
+          jar.manifest = options.has_key?(:manifest) ? options[:manifest] : manifest
           jar.meta_inf = options[:meta_inf] || meta_inf
           if options[:include]
             jar.include options[:include]
@@ -310,14 +317,17 @@ module Buildr
           end
           yield jar
         end
+      else
+        fu_check_options options, *PACKAGE_OPTIONS
       end
       file(file_name)
     end
 
     def package_as_war(file_name, options) #:nodoc:
       unless Rake::Task.task_defined?(file_name)
+        fu_check_options options, *PACKAGE_OPTIONS + [:manifest, :meta_inf, :classes, :libs, :include]
         Java::Packaging::WarTask.define_task(file_name).tap do |war|
-          war.manifest = options[:manifest] || manifest.merge("Implementation-Title"=>self.comment)
+          war.manifest = options.has_key?(:manifest) ? options[:manifest] : manifest
           war.meta_inf = options[:meta_inf] || meta_inf
           # Add libraries in WEB-INF lib, and classes in WEB-INF classes
           if options[:classes]
@@ -340,18 +350,23 @@ module Buildr
           end
           yield war
         end
+      else
+        fu_check_options options, *PACKAGE_OPTIONS
       end
       file(file_name)
     end
 
     def package_as_zip(file_name, options) #:nodoc:
       unless Rake::Task.task_defined?(file_name)
+        fu_check_options options, *PACKAGE_OPTIONS + [:include]
         ZipTask.define_task(file_name).tap do |zip|
           if options[:include]
             zip.include options[:include]
           end
           yield zip
         end
+      else
+        fu_check_options options, *PACKAGE_OPTIONS
       end
       file(file_name)
     end

data/lib/java/test.rb

@@ -19,7 +19,7 @@ module Buildr
         super
         @classpath = []
         @paths = []
-        @include = []
+        @include = ["*Test", "*Suite"]
         @exclude = []
         enhance do |task|
           unless test_cases.empty?
@@ -43,10 +43,9 @@ module Buildr
       #   test.include "com.example.Module*"
       #   test.include "*.{First,Second}Test"
       #
-      # If you do not specify any inclusion pattern explicitly, the default pattern is used.
-      # This pattern picks up all classes with a name ending with Test (same as test.include "*Test").
-      # Use the Test suffix to specify test case classes, and avoid the Test suffix for classes
-      # that do not implement test cases (e.g. mock objects, helpers, etc).
+      # By default, all classes that have a name ending with Test or Suite are included.
+      # Use these suffixes for your test and test suite classes respectively, to distinguish them
+      # from stubs, helper classes, etc. 
       def include(*classes)
         @include += classes
         self
@@ -85,7 +84,6 @@ module Buildr
 
       def test_cases()
         unless @cases
-          @include << "*Test" if @include.empty?
           @cases = @paths.map do |path|
             base = Pathname.new(path.to_s)
             FileList["#{path}/**/*.class"].
@@ -164,9 +162,9 @@ module Buildr
       # Returns the JUnit task. This task executes JUnit test cases, from classes compiled by
       # the test task.
       #
-      # By default it includes all classes with the suffix Test, and excludes all other classes.
-      # Use the Test suffix for classes that implement test cases, avoid this suffix for other
-      # classes (e.g. mocks, helper objects).
+      # By default it includes all classes with the suffix Test or Suite, and excludes all other classes.
+      # Use the Test/Suite suffix for classes that implement test cases, avoid this suffix for other
+      # classes (e.g. stubs, helper objects).
       #
       # You can also include only specific test cases, or exclude otherwise included test cases
       # using #include and #exclude.
@@ -267,7 +265,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.include project.path_to(dir, "*") if File.exist?(dir) }
+    resources.filter.from project.path_to("src/test/resources")
     # Similar to the regular compile task but using different paths.
     compile = Java::CompileTask.define_task("test:compile"=>[project.compile, project.test.prepare, project.test.resources])
     compile.enhance { project.test.resources.invoke }

data/lib/tasks/zip.rb

@@ -312,7 +312,7 @@ module Buildr
     # Or:
     #   package(:jar)[:manifest] = "MANIFEST_MF"
     def []=(key, value)
-      fail "#{self.class} does not support the attribute #{key}"
+      raise ArgumentError, "#{self.class} does not support the option #{key}"
     end
 
     def prerequisites() #:nodoc:

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: buildr
 version: !ruby/object:Gem::Version 
-  version: 0.20.0
-date: 2007-04-18 00:00:00 -07:00
+  version: 0.21.0
+date: 2007-04-20 00:00:00 -07:00
 summary: A build system that doesn't suck
 require_paths: 
 - lib
@@ -33,14 +33,13 @@ files:
 - lib/core
 - lib/buildr.rb
 - lib/java
-- lib/tasks/download.rb
-- lib/tasks/filter.rb
 - lib/tasks/concat.rb
 - lib/tasks/zip.rb
 - lib/core/transports.rb
 - lib/core/build.rb
 - lib/core/project.rb
 - lib/core/rake_ext.rb
+- lib/core/common.rb
 - lib/java/test.rb
 - lib/java/eclipse.rb
 - lib/java/jetty.rb
@@ -68,6 +67,7 @@ rdoc_options:
 - --main
 - README
 - --line-numbers
+- -inline-source
 extra_rdoc_files: 
 - README
 - CHANGELOG

data/lib/tasks/download.rb

@@ -1,43 +0,0 @@
-require "tempfile"
-require "core/transports"
-
-module Buildr
-
-  # :call-seq:
-  #    download(url_or_uri) => task
-  #    download(path=>url_or_uri) =>task
-  #
-  # Create a task that will download a file from a URL.
-  #
-  # Takes a single argument, a hash with one pair. The key is the file being
-  # created, the value if the URL to download. The task executes only if the
-  # file does not exist; the URL is not checked for updates.
-  #
-  # The task will show download progress on the console; if there are MD5/SHA1
-  # checksums on the server it will verify the download before saving it.
-  #
-  # For example:
-  #   download "image.jpg"=>"http://example.com/theme/image.jpg"
-  def download(args)
-    if String === args || URI === args
-      # Given only a download URL, download into a temporary file.
-      # You can infer the file from task name.
-      temp = Tempfile.new(File.basename(args.to_s))
-      task = file_create(temp.path) do |task|
-        Transports.download task.source, task.name
-      end
-      task.sources << args
-    else
-      # Download to a file created by the task.
-      fail unless args.keys.size == 1
-      url = args.values.first
-      task = file_create(args.keys.first) do |task|
-        mkpath File.dirname(task.name), :verbose=>false
-        Transports.download task.source, task.name
-      end
-      task.sources << url
-    end
-    task
-  end
-
-end

data/lib/tasks/filter.rb

@@ -1,159 +0,0 @@
-module Buildr
-
-  # A filter knows how to copy a set of source files into a target directory, and apply
-  # mapping to these files.
-  #
-  # You can specify the mapping using a Hash, and it will map ${key} fields found in each
-  # source file into the appropriate value. For example:
-  #   filter.using "version"=>"1.2"
-  # will replace all occurrences of "${version}" with "1.2".
-  #
-  # You can also specify the mapping by passing a proc or a method, that will be called for
-  # each source file, with the file name and content, returning the modified content.
-  #
-  # Without any mapping, the filter simply copies the source files into the target directory.
-  #
-  # See Buildr#filter.
-  class Filter
-
-    # The target directory.
-    attr_reader :target
-    # The mapping. See #using.
-    attr_accessor :mapping
-    # The source files and directories.
-    attr_accessor :sources
-
-    def initialize() #:nodoc:
-      @sources = FileList[]
-    end
-
-    # :call-seq:
-    #   include(*files) => self
-    #
-    # Specifies files to include and returns self. See FileList#include.
-    def include(*files)
-      @sources.include *files
-      self
-    end
-    alias :add :include 
-
-    # :call-seq:
-    #   exclude(*files) => self
-    #
-    # Specifies files to exclude and returns self. See FileList#exclude.
-    def exclude(*files)
-      @sources.exclude *files
-      self
-    end
-
-    # :call-seq:
-    #   into(dir) => self
-    #
-    # Specifies the target directory and return self. This tells the filter task where
-    # to copy the source files to.
-    #
-    # For example:
-    #   filter.include("*.HTML").into("docs").run
-    def into(dir)
-      @target = File.expand_path(dir.to_s)
-      self
-    end
-
-    # :call-seq:
-    #   using(mapping) => self
-    #   using() { |file_name, contents| ... } => self
-    #
-    # Specifies the mapping to use and returns self.
-    #
-    # The mapping can be a proc or a method called with the file name and content, returning
-    # the modified content. Or the mapping can be a Hash for mapping each ${key} into a value.
-    # Without any mapping, all files are copied as is.
-    #
-    # For example:
-    #   filter.using "version"=>"1.2"
-    # will replace all occurrences of "${version}" with "1.2".
-    def using(mapping, &block)
-      self.mapping = mapping || block
-      self
-    end
-
-    # Run the filter.
-    def run()
-      #@sources.each { |src| Rake.application[src, Rake.application.current_scope].invoke }
-      if needed?
-        fail "No target directory specified" if !target || (File.exist?(target.to_s) && !File.directory?(target.to_s))
-        unless copy_map.empty?
-          verbose(Rake.application.options.trace || false) do
-            mkpath target.to_s
-            copy_map do |dest, src|
-              mkpath File.dirname(dest) rescue nil
-              case mapping
-              when Proc, Method # Call on input, accept output.
-                mapped = mapping.call(src, File.read(src))
-                File.open(dest, "w") { |file| file.write mapped }
-              when Hash # Map ${key} to value
-                mapped = File.read(src).gsub(/\$\{.*\}/) { |str| mapping[str[2..-2]] || str }
-                File.open(dest, "w") { |file| file.write mapped }
-              when nil # No mapping.
-                cp src, dest
-              else
-                fail "Filter can be a hash (key=>value), or a proc/method; I don't understand #{mapping}"
-              end
-            end
-            touch target.to_s
-          end
-        end
-      end
-    end
-
-    # Returns the target directory. 
-    def to_s()
-      @target.to_s
-    end    
-    
-  private
-
-    def needed?()
-      return false if target.nil? || copy_map.empty?
-      return true unless File.exist?(target.to_s)
-      return true if copy_map.any? { |dest, src| !File.exist?(dest) || File.mtime(src) > File.mtime(dest) }
-      false
-    end
-
-    # Return a copy map of all the files that need copying: the key is the file to copy to,
-    # the value is the source file. If called with a block, yields with each dest/source pair.
-    def copy_map(&block)
-      # Create a map between the source file and the similarly named file in the target directory,
-      # including all files nested inside directories.
-      @copy_map ||= @sources.map(&:to_s).inject({}) do |map, path|
-        if File.directory?(path)
-          Dir["#{path}/**/*"].each do |file|
-            map[file.sub(File.dirname(path), target.to_s)] = file unless
-              File.directory?(file) || @sources.exclude?(file)
-          end
-        elsif File.exist?(path)
-          map[File.join(target.to_s, File.basename(path))] = path
-        end
-        map
-      end.reject do |dest, src|
-        # ... while ignoring that which does not need updating.
-        File.exist?(dest) && File.stat(dest).mtime > File.stat(src).mtime
-      end
-      if block_given?
-        @copy_map.each(&block)
-      else
-        @copy_map
-      end
-    end
-
-  end
-
-  # :call-seq:
-  #   filter(*files) => Filter
-  #
-  # Creates a filter task to operate on all the specified files.
-  def filter(*files)
-    Filter.new.include *files
-  end
-
-end