buildr 1.2.5 → 1.2.6

data/CHANGELOG

@@ -1,3 +1,23 @@
+1.2.6 (9/26/2007)
+* Added: Option for setting environment name (-e) and attribute accessor (Buildr.environment).  Default taken from BUILDR_ENV environment variable.
+* Added: AAR packaging for Axis2 service archives (Alex Boisvert)
+* Added: Environment variable for JUnit tests (test.using :environment=>).
+* Added: tar method similar to zip method.
+* Added: Experimental transitive method.  Looks like artifacts, quacks like artifacts, but returns artifacts by the boat load. (Credit, Daniel Roop)
+* Changed: Now accepting JAVA_OPTS in addition to JAVA_OPTIONS.
+* Changed: TarTask is now based on ArchiveTask, same API as ZipTask.
+* Changed: Javadoc array arguments now passed as multiple command line options (e.g. :link=>['foo', 'bar'] becomes --link foo --link bar). (Daniel Roop)
+* Changed: Jetty task now uses SLF4J instead of commons-logging + log4j for better hot-swap capability and plugability (Alex Boisvert)
+* Removed: Turns out --verbose command line option is useless.  Removed.
+* Fixed: Jetty task now uses WebAppContextClassLoader to support hot-swapping webapps (Alex Boisvert)
+* Fixed: "release" task now works with SVN URLs ending with /branches/*/ (Alex Boisvert)
+* Fixed: Resources not included in JAR/WAR unless there's a src/main/java directory (Olexandr Zakordonskyy).
+* Fixed: Files starting with dot (e.g. .config) not copied over as resource files, and not included in ZIP (Olexandr Zakordonskyy).
+* Fixed: Empty directories not copied over as resources (Olexandr Zakordonskyy).
+* Fixed: JAVA_OPTS and test.options[:java_args] not passed to JUnit task (Staube).
+* Fixed: archive.exclude doesn't work when including a directory using :from/:as option.
+* Fixed: JUnit/TestNG no longer run inner classes as test classes (Mark Feeney).
+
 1.2.5 (8/13/2007)
 * Fixed: Buildr not finding buildfile in parent directory, or switching to parent directory.
 * Fixed: checks.rb:103: warning: multiple values for a block parameter (2 for 1)

data/Rakefile

@@ -6,7 +6,6 @@ require "spec/rake/spectask"
 
 # Gem specification comes first, other tasks rely on it.
 spec = Gem::Specification.new do |spec|
-
   spec.name         = "buildr"
   spec.version      = File.read(__FILE__.pathmap("%d/lib/buildr.rb")).scan(/VERSION\s*=\s*(['"])(.*)\1/)[0][1]
   spec.author       = "Assaf Arkin"
@@ -32,10 +31,10 @@ spec = Gem::Specification.new do |spec|
   spec.add_dependency "net-ssh",              "= 1.1.2"
   spec.add_dependency "net-sftp",             "= 1.1.0"
   spec.add_dependency "rubyzip",              "= 0.9.1"
-  spec.add_dependency "highline",             "= 1.2.9"
+  spec.add_dependency "highline",             "= 1.4.0"
   spec.add_dependency "rjb",                  "= 1.0.6"
   spec.add_dependency "Antwrap",              "= 0.6.0"
-  spec.add_dependency "rspec",                "= 1.0.5"
+  spec.add_dependency "rspec",                "= 1.0.8"
   spec.add_dependency "xml-simple",           "= 1.0.11"
   spec.add_dependency "archive-tar-minitar",  "= 0.5.1"
 end
@@ -171,8 +170,37 @@ namespace :upload do
   end
 end
 
+namespace :release do
+  task :ready? do
+    require 'highline'
+    require 'highline/import'
+
+    puts "This version: #{spec.version}"
+    puts
+    puts "Top 4 lines form CHANGELOG:"
+    puts File.readlines("CHANGELOG")[0..3].map { |l| "  #{l}" }
+    puts
+    ask("Top-entry in CHANGELOG file includes today's date?") =~ /yes/i or
+      fail "Please update CHANGELOG to include the right date"
+  end
+
+  task :post do
+    # Practical example of functional read but not comprehend code:
+    next_version = spec.version.to_ints.zip([0, 0, 1]).map { |a| a.inject(0) { |t,i| t + i } }.join(".")
+    puts "Updating lib/buildr.rb to next version number: #{next_version}"
+    buildr_rb = File.read(__FILE__.pathmap("%d/lib/buildr.rb")).
+      sub(/(VERSION\s*=\s*)(['"])(.*)\2/) { |line| "#{$1}#{$2}#{next_version}#{$2}" } 
+    File.open(__FILE__.pathmap("%d/lib/buildr.rb"), "w") { |file| file.write buildr_rb }
+    puts "Adding entry to CHANGELOG"
+    changelog = File.read(__FILE__.pathmap("%d/CHANGELOG"))
+    File.open(__FILE__.pathmap("%d/CHANGELOG"), "w") { |file| file.write "#{next_version} (Pending)\n\n#{changelog}" }
+  end
+
+  task :meat=>["clobber", "svn:clean?", "test", "upload:packages", "upload:docs", "svn:tag"]
+end
+
 desc "Upload release to RubyForge including docs, tag SVN"
-task :release=>[ "clobber", "svn:clean?", "test", "upload:packages", "upload:docs", "svn:tag" ]
+task :release=>[ "release:ready?", "release:meat", "release:post" ]
 
 
 

data/lib/buildr.rb

@@ -24,7 +24,7 @@ require "builder"
 
 
 module Buildr
-  VERSION = "1.2.5".freeze # unless const_defined?(:VERSION)
+  VERSION = "1.2.6".freeze # unless const_defined?(:VERSION)
 end
 
 

data/lib/buildr/jetty.rb

@@ -29,12 +29,15 @@ module Buildr
 
     # Which version of Jetty we're using by default (change with options.jetty.version).
     VERSION = "6.1.3"
-
+    SLF4J_VERSION = "1.4.3"
+    
     # Libraries used by Jetty.
     REQUIRES = [ "org.mortbay.jetty:jetty:jar:#{VERSION}", "org.mortbay.jetty:jetty-util:jar:#{VERSION}",
-      "org.mortbay.jetty:servlet-api-2.5:jar:#{VERSION}", "log4j:log4j:jar:1.2.13", "commons-logging:commons-logging:jar:1.1" ]
+      "org.mortbay.jetty:servlet-api-2.5:jar:#{VERSION}", "org.slf4j:slf4j-api:jar:#{SLF4J_VERSION}", 
+      "org.slf4j:slf4j-simple:jar:#{SLF4J_VERSION}", "org.slf4j:jcl104-over-slf4j:jar:#{SLF4J_VERSION}" ]
+      
     Java.rjb.onload { |rjb| rjb.classpath << REQUIRES << File.join(__DIR__, "jetty") }
-
+    
     # Default URL for Jetty (change with options.jetty.url).
     URL = "http://localhost:8080"
 
@@ -72,6 +75,9 @@ module Buildr
     def start(sync = nil)
       begin
         Java.rjb do
+          puts "RJB classpath #{Java.rjb.classpath.inspect}"
+          props = Rjb::import('java.lang.System').getProperties
+          props.setProperty("log4j.configuration", "file:./log4j.properties")
           port = URI.parse(url).port
           puts "Starting Jetty at http://localhost:#{port}" if verbose
           jetty = Rjb::import("JettyWrapper").new(port)

data/lib/buildr/jetty/JettyWrapper.java

@@ -5,6 +5,7 @@ import org.mortbay.jetty.handler.AbstractHandler;
 import org.mortbay.jetty.handler.ContextHandler;
 import org.mortbay.jetty.handler.ContextHandlerCollection;
 import org.mortbay.jetty.webapp.WebAppContext;
+import org.mortbay.jetty.webapp.WebAppClassLoader;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
@@ -74,6 +75,8 @@ public class JettyWrapper {
                     context.setConfigurationClasses(new String[] {
                         "org.mortbay.jetty.webapp.WebInfConfiguration",
                         "org.mortbay.jetty.webapp.WebXmlConfiguration"});
+                    context.setClassLoader(new WebAppClassLoader(context));
+                    
                     _handlerColl.addHandler(context);
                     context.start();
                     _apps.put(path, context);

data/lib/buildr/scala.rb

@@ -0,0 +1,368 @@
+require "java/java"
+
+# TODO List
+# -Eclipse support
+# -SUnit
+# -Cleanup compiler options
+
+module Buildr
+
+  module Scala
+    class << self
+      def scala_base
+        ENV["SCALA_HOME"] + "/share/scala"
+      end
+
+      def scala_lib
+        scala_lib = scala_base + "/lib/scala-library.jar"
+      end
+
+      def scalac(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :classpath, :sourcepath, :output, :scalac_args, :name
+
+        files = args.flatten.each { |f| f.invoke if f.respond_to?(:invoke) }.map(&:to_s).
+          collect { |arg| File.directory?(arg) ? FileList["#{arg}/**/*.scala"] : arg }.flatten
+        name = options[:name] || Dir.pwd
+        return if files.empty?
+
+        fail "Missing SCALA_HOME environment variable" unless ENV["SCALA_HOME"]
+        fail "Invalid SCALA_HOME environment variable" unless File.directory? ENV["SCALA_HOME"]
+
+        cmd_args = []
+        use_fsc = !(ENV["USE_FSC"] =~ /^(no|off|false)$/i)
+        classpath = classpath_from(options)
+        scala_cp = [ classpath,  FileList["#{scala_base}/lib/*"] ].flatten.join(File::PATH_SEPARATOR)
+        cmd_args << "-cp" << scala_cp unless scala_cp.empty?
+        cmd_args << "-sourcepath" << options[:sourcepath].join(File::PATH_SEPARATOR) if options[:sourcepath]
+        cmd_args << "-d" << options[:output].to_s if options[:output]
+        cmd_args += options[:scalac_args].flatten if options[:scalac_args]
+        cmd_args += files
+        unless Rake.application.options.dryrun
+          puts "Compiling #{files.size} source files in #{name}" if verbose
+          puts (["scalac"] + cmd_args).join(" ") if Rake.application.options.trace
+          if use_fsc
+            system ([ENV["SCALA_HOME"]+"/bin/fsc"] + cmd_args).join(" ")
+            else
+            Java.rjb do |rjb|
+              rjb.import("scala.tools.nsc.Main").main(cmd_args) == 0 or
+              fail "Failed to compile, see errors above"
+            end
+          end
+        end
+      end
+
+    protected
+
+      # :call-seq:
+      #    classpath_from(options) => files
+      #
+      # Extracts the classpath from the options, expands it by calling artifacts, invokes
+      # each of the artifacts and returns an array of paths.
+      def classpath_from(options)
+        classpath = (options[:classpath] || []).collect
+        Buildr.artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+      end
+    end # Scala << self
+
+
+    # !! This is mostly a copy-paste Buildr:Java:CompileTask !!
+    #
+    # Wraps Scalac in a task that does all the heavy lifting.
+    #
+    # Accepts multiple source directories that are invoked as prerequisites before compilation.
+    # You can pass a task as a source directory, e.g. compile.from(apt).
+    #
+    # Likewise, classpath dependencies are invoked before compiling. All classpath dependencies
+    # are evaluated as #artifacts, so you can pass artifact specifications and even projects.
+    #
+    # Creates a file task for the target directory, so executing that task as a dependency will
+    # execute the compile task first.
+    #
+    # Compiler options are inherited form a parent task, e.g. the foo:bar:compile task inherits
+    # its options from the foo:compile task. Even if foo is an empty project that does not compile
+    # any classes itself, you can use it to set compile options for all its sub-projects.
+    #
+    # Normally, the project will take care of setting the source and target directory, and you
+    # only need to set options and classpath dependencies. See Project#compile.
+    class ScalaCompilerTask < Rake::Task
+
+      # Compiler options, accessible from CompileTask#options.
+      #
+      # Supported options are:
+      # - warnings -- Generate warnings if true (opposite of -nowarn).
+      # - deprecation -- Output source locations where deprecated APIs are used.
+      # - source -- Source compatibility with specified release.
+      # - target -- Class file compatibility with specified release.
+      # - lint -- Value to pass to xlint argument. Use true to enable default lint
+      #   options, or pass a specific setting as string or array of strings.
+      # - debug -- Generate debugging info.
+      # - other -- Array of options to pass to the Scalac compiler as is.
+      #
+      # For example:
+      #   compile.options.warnings = true
+      #   compile.options.source = options.target = "1.6"
+      class Options
+
+        include InheritedAttributes
+
+        OPTIONS = [:warnings, :deprecation, :source, :target, :lint, :debug, :other]
+
+        # Generate warnings (opposite of -nowarn).
+        attr_accessor :warnings
+        inherited_attr(:warnings) { verbose }
+        # Output source locations where deprecated APIs are used.
+        attr_accessor :deprecation
+        inherited_attr :deprecation, false
+        # Provide source compatibility with specified release.
+        attr_accessor :source
+        inherited_attr :source
+        # Generate class files for specific VM version.
+        attr_accessor :target
+        inherited_attr :target
+        # Values to pass to Xlint: string or array. Use true to enable
+        # Xlint with no values.
+        attr_accessor :lint
+        inherited_attr :lint, false
+        # Generate all debugging info.
+        attr_accessor :debug
+        inherited_attr(:debug) { Buildr.options.debug }
+        # Array of arguments passed to the Scalac compiler as is.
+        attr_accessor :other
+        inherited_attr :other
+
+        def initialize(parent = nil) #:nodoc:
+          @parent = parent
+        end
+
+        attr_reader :parent # :nodoc:
+
+        # Resets all the options.
+        def clear()
+          OPTIONS.each { |name| send "#{name}=", nil }
+        end
+
+        def to_s() #:nodoc:
+          OPTIONS.inject({}){ |hash, name| hash[name] = send(name) ; hash }.reject{ |name,value| value.nil? }.inspect
+        end
+
+        # Returns Scalac command line arguments from the set of options.
+        def scalac_args()
+          args = []
+          args << "-nowarn" unless warnings
+          args << "-verbose" if Rake.application.options.trace
+          args << "-g" if debug
+          args << "-deprecation" if deprecation
+          args << "-source" << source.to_s if source
+          args << "-target" << target.to_s if target
+          case lint
+          when Array
+            args << "-Xlint:#{lint.join(',')}"
+          when String
+            args << "-Xlint:#{lint}"
+          when true
+            args << "-Xlint"
+          end
+          args.concat(other.to_a) if other
+          args
+        end
+
+      end
+
+
+      def initialize(*args) #:nodoc:
+        super
+        parent = Rake::Task["^scalac"] if name[":"] # Only if in namespace
+        if parent && parent.respond_to?(:options)
+          @options = Options.new(parent.options)
+        else
+          @options = Options.new
+        end
+        @sources = []
+        @classpath = []
+
+        enhance do |task|
+          mkpath target.to_s, :verbose=>false
+          Scala.scalac source_files.keys, :sourcepath=>sources.map(&:to_s).select { |source| File.directory?(source) }.uniq,
+            :classpath=>classpath, :output=>target, :scalac_args=>options.scalac_args, :name=>task.name
+          # By touching the target we let other tasks know we did something,
+          # and also prevent recompiling again for classpath dependencies.
+          touch target.to_s, :verbose=>false
+        end
+      end
+
+      # Source directories and files to compile.
+      attr_accessor :sources
+
+      # :call-seq:
+      #   from(*sources) => self
+      #
+      # Adds source directories and files to compile, and returns self.
+      #
+      # For example:
+      #   compile.from("src/scala").into("classes").with("module1.jar")
+      def from(*sources)
+        @sources |= sources.flatten
+        self
+      end
+
+      # Classpath dependencies.
+      attr_accessor :classpath
+
+      # :call-seq:
+      #   with(*artifacts) => self
+      #
+      # Adds files and artifacts as classpath dependencies, and returns self.
+      #
+      # Calls #artifacts on the arguments, so you can pass artifact specifications,
+      # tasks, projects, etc. Use this rather than setting the classpath directly.
+      #
+      # For example:
+      #   compile.with("module1.jar", "log4j:log4j:jar:1.0", project("foo"))
+      def with(*specs)
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
+        self
+      end
+
+      # The target directory for the generated class files.
+      attr_reader :target
+
+      # :call-seq:
+      #   into(path) => self
+      #
+      # Sets the target directory and returns self. This will also set the compile task
+      # as a prerequisite to a file task on the target directory.
+      #
+      # For example:
+      #   compile(src_dir).into(target_dir).with(artifacts)
+      # Both compile.invoke and file(target_dir).invoke will compile the source files.
+      def into(path)
+        path = File.expand_path(path.to_s)
+        @target = file(path).enhance([self]) unless @target && @target.to_s == path
+        self
+      end
+
+      # Returns the compiler options.
+      attr_reader :options
+
+      # :call-seq:
+      #   using(options) => self
+      #
+      # Sets the compiler options from a hash and returns self.
+      #
+      # For example:
+      #   compile.using(:warnings=>true, :source=>"1.5")
+      def using(*args)
+        args.pop.each { |key, value| options.send "#{key}=", value } if Hash === args.last
+        args.each { |key| options.send "#{key}=", value = true }
+        self
+      end
+
+      def timestamp() #:nodoc:
+        # If we compiled successfully, then the target directory reflects that.
+        # If we didn't, see needed?
+        target ? target.timestamp : Rake::EARLY
+      end
+
+      def needed?() #:nodoc:
+        return false if source_files.empty?
+        return true unless File.exist?(target.to_s)
+        return true if source_files.any? { |j, c| !File.exist?(c) || File.stat(j).mtime > File.stat(c).mtime }
+        oldest = source_files.map { |j, c| File.stat(c).mtime }.min
+        return classpath.any? { |path| application[path].timestamp > oldest }
+      end
+
+      def prerequisites() #:nodoc:
+        super + classpath + sources
+      end
+
+      def invoke_prerequisites() #:nodoc:
+        prerequisites.each { |n| application[n, @scope].invoke }
+      end
+
+      # Returns the files to compile. This list is derived from the list of sources,
+      # expanding directories into files, and includes only source files that are
+      # newer than the corresponding class file. Includes all files if one or more
+      # classpath dependency has been updated.
+      def source_files()
+        @source_files ||= @sources.map(&:to_s).inject({}) do |map, source|
+          raise "Compile task #{name} has source files, but no target directory" unless target
+          target_dir = target.to_s
+          if File.directory?(source)
+            base = Pathname.new(source)
+            FileList["#{source}/**/*.scala"].
+              each { |file| map[file] = File.join(target_dir, Pathname.new(file).relative_path_from(base).to_s.ext(".class")) }
+          else
+            map[source] = File.join(target_dir, File.basename(source).ext(".class"))
+          end
+          map
+        end
+      end
+
+      def scala_lib
+        Scala.scala_lib
+      end
+    end # ScalaCompilerTask
+
+  end # Scala
+
+  # Local task to execute the Scalac compile task of the current project.
+  # This task is not itself a compile task.
+  desc "Compile all scalac projects"
+  Project.local_task("scalac") { |name| "Compiling scala sources for #{name}" }
+
+  class Project
+
+    # :call-seq:
+    #   compile(*sources) => CompileTask
+    #   compile(*sources) { |task| .. } => CompileTask
+    #
+    # The compile task does what its name suggests. This method returns the project's
+    # CompileTask. It also accepts a list of source directories and files to compile
+    # (equivalent to calling CompileTask#from on the task), and a block for any
+    # post-compilation work.
+    #
+    # The compile task will pick all the source files in the src/main/scala directory,
+    # and unless specified, compile them into the target/classes directory. It will pick
+    # the default values for compiler options from the parent project's compile task.
+    #
+    # For example:
+    #   # Force target compatibility.
+    #   compile.options.source = "1.6"
+    #   # Include Apt-generated source files.
+    #   compile.from apt
+    #   # Include Log4J and the api sub-project artifacts.
+    #   compile.with "log4j:log4j:jar:1.2", project("api")
+    #   # Run the OpenJPA bytecode enhancer after compilation.
+    #   compile { open_jpa_enhance }
+    #
+    # For more information, see Scala::ScalaCompilerTask.
+    def scalac(*sources, &block)
+      task("scalac").from(sources).enhance &block
+    end
+
+  end # Project
+
+  Project.on_define do |project|
+    # Scalac runs after compile task (and therefore, after "prepare" and "resources")
+    scalac = Scala::ScalaCompilerTask.define_task("scalac"=>[task("compile")])
+    project.path_to("src/main/scala").tap { |dir| scalac.from dir if File.exist?(dir) }
+    scalac.into project.path_to(:target, "classes")
+    project.recursive_task("scalac")
+
+    project.enhance do |project|
+      # This comes last because the target path may change.
+      project.packages.each do |p|
+        p.with scalac.target if p.type == :jar
+        p.classes = scalac.target if p.type == :war
+      end
+      # Work-in-progress
+      #project.task("eclipse").classpathContainers 'ch.epfl.lamp.sdt.launching.SCALA_CONTAINER'
+
+      project.build project.scalac.target
+      project.clean { verbose(false) { rm_rf project.scalac.target.to_s } }
+    end
+  end
+
+end # Buildr
+