mguymon-buildr 1.4.5-java

data/lib/buildr/groovy.rb

@@ -0,0 +1,20 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/groovy/compiler'
+require 'buildr/groovy/bdd'
+require 'buildr/groovy/doc'
+require 'buildr/groovy/shell'

data/lib/buildr/groovy/bdd.rb

@@ -0,0 +1,106 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+module Buildr::Groovy
+
+  # EasyB is a Groovy based BDD framework.
+  # To use in your project:
+  #
+  #   test.using :easyb
+  #
+  # This framework will search in your project for:
+  #   src/spec/groovy/**/*Story.groovy
+  #   src/spec/groovy/**/*Specification.groovy
+  #
+  # Support the following options:
+  # * :format -- Report format :txt or :xml, default is :txt
+  # * :properties -- Hash of properties passed to the test suite.
+  # * :java_args -- Arguments passed to the JVM.
+  class EasyB < TestFramework::JavaBDD
+    @lang = :groovy
+    @bdd_dir = :spec
+
+    VERSION = "0.9"
+    TESTS_PATTERN = [ /(Story|Specification).groovy$/ ]
+    OPTIONS = [:format, :properties, :java_args]
+
+    class << self
+      def version
+        Buildr.settings.build['jbehave'] || VERSION
+      end
+
+      def dependencies
+        @dependencies ||= ["org.easyb:easyb:jar:#{version}",
+          'org.codehaus.groovy:groovy:jar:1.5.3','asm:asm:jar:2.2.3',
+          'commons-cli:commons-cli:jar:1.0','antlr:antlr:jar:2.7.7']
+      end
+
+      def applies_to?(project) #:nodoc:
+        %w{
+          **/*Specification.groovy **/*Story.groovy
+        }.any? { |glob| !Dir[project.path_to(:source, bdd_dir, lang, glob)].empty? }
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use JBehave.dependencies/.version instead of JBehave::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+
+    def tests(dependencies) #:nodoc:
+      Dir[task.project.path_to(:source, bdd_dir, lang, "**/*.groovy")].
+        select { |name| TESTS_PATTERN.any? { |pat| pat === name } }
+    end
+
+    def run(tests, dependencies) #:nodoc:
+      options = { :format => :txt }.merge(self.options).only(*OPTIONS)
+
+      if :txt == options[:format]
+        easyb_format, ext = 'txtstory', '.txt'
+      elsif :xml == options[:format]
+        easyb_format, ext = 'xmlbehavior', '.xml'
+      else
+        raise "Invalid format #{options[:format]} expected one of :txt :xml"
+      end
+
+      cmd_args = [ 'org.disco.easyb.BehaviorRunner' ]
+      cmd_options = { :properties => options[:properties],
+                      :java_args => options[:java_args],
+                      :classpath => dependencies }
+
+      tests.inject([]) do |passed, test|
+        name = test.sub(/.*?groovy[\/\\]/, '').pathmap('%X')
+        report = File.join(task.report_to.to_s, name + ext)
+        mkpath report.pathmap('%d')
+        begin
+          Java::Commands.java cmd_args,
+             "-#{easyb_format}", report,
+             test, cmd_options.merge(:name => name)
+        rescue => e
+          passed
+        else
+          passed << test
+        end
+      end
+    end
+
+  end # EasyB
+
+end
+
+Buildr::TestFramework << Buildr::Groovy::EasyB

data/lib/buildr/groovy/compiler.rb

@@ -0,0 +1,153 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+module Buildr::Groovy
+
+  REQUIRES = ArtifactNamespace.for(self) do |ns|
+    ns.jansi! 'org.fusesource.jansi:jansi:jar:1.2.1'
+    ns.jline! 'jline:jline:jar:0.9.94'
+  end
+
+  class << self
+    def dependencies #:nodoc:
+      REQUIRES.artifacts + Groovyc.dependencies
+    end
+  end
+
+  # Groovyc compiler:
+  #  compile.using(:groovyc)
+  #
+  # You need to require 'buildr/groovy/compiler' if you need to use this compiler.
+  #
+  # Used by default if .groovy files are found in the src/main/groovy directory (or src/test/groovy)
+  # and sets the target directory to target/classes (or target/test/classes).
+  #
+  # Groovyc is a joint compiler, this means that when selected for a project, this compiler is used
+  # to compile both groovy and java sources. It's recommended that Groovy sources are placed in the
+  # src/main/groovy directory, even though this compiler also looks in src/main/java
+  #
+  # Groovyc accepts the following options:
+  #
+  # * :encoding          -- Encoding of source files
+  # * :verbose           -- Asks the compiler for verbose output, true when running in verbose mode.
+  # * :fork              -- Whether to execute groovyc using a spawned instance of the JVM; defaults to no
+  # * :memoryInitialSize -- The initial size of the memory for the underlying VM, if using fork mode; ignored otherwise.
+  #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
+  # * :memoryMaximumSize -- The maximum size of the memory for the underlying VM, if using fork mode; ignored otherwise.
+  #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
+  # * :listfiles         -- Indicates whether the source files to be compiled will be listed; defaults to no
+  # * :stacktrace        -- If true each compile error message will contain a stacktrace
+  # * :warnings          -- Issue warnings when compiling.  True when running in verbose mode.
+  # * :debug             -- Generates bytecode with debugging information.  Set from the debug
+  #                                     environment variable/global option.
+  # * :deprecation       -- If true, shows deprecation messages.  False by default.
+  # * :optimise          -- Generates faster bytecode by applying optimisations to the program.
+  # * :source            -- Source code compatibility.
+  # * :target            -- Bytecode compatibility.
+  # * :javac             -- Hash of options passed to the ant javac task
+  #
+  class Groovyc < Compiler::Base
+
+    # The groovyc compiler jars are added to classpath at load time,
+    # if you want to customize artifact versions, you must set them on the
+    #
+    #      artifact_ns(Buildr::Groovy::Groovyc).groovy = '1.7.1'
+    #
+    # namespace before this file is required.
+    REQUIRES = ArtifactNamespace.for(self) do |ns|
+      ns.groovy!       'org.codehaus.groovy:groovy:jar:>=1.7.5'
+      ns.commons_cli!  'commons-cli:commons-cli:jar:>=1.2'
+      ns.asm!          'asm:asm:jar:>=3.2'
+      ns.antlr!        'antlr:antlr:jar:>=2.7.7'
+    end
+
+    ANT_TASK = 'org.codehaus.groovy.ant.Groovyc'
+    GROOVYC_OPTIONS = [:encoding, :verbose, :fork, :memoryInitialSize, :memoryMaximumSize, :listfiles, :stacktrace]
+    JAVAC_OPTIONS = [:optimise, :warnings, :debug, :deprecation, :source, :target, :javac]
+    OPTIONS = GROOVYC_OPTIONS + JAVAC_OPTIONS
+
+    class << self
+      def dependencies #:nodoc:
+        REQUIRES.artifacts
+      end
+
+      def applies_to?(project, task) #:nodoc:
+        paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
+        paths.flatten!
+        # Just select if we find .groovy files
+        paths.any? { |path| !Dir["#{path}/**/*.groovy"].empty? }
+      end
+    end
+
+    # Groovy dependencies don't need to go into JVM's system classpath.
+    # In fact, if they end up there it causes trouble because Groovy has issues
+    # loading other classes such as test frameworks (e.g. JUnit).
+    #
+    # Java.classpath << lambda { dependencies }
+
+    specify :language => :groovy, :sources => [:groovy, :java], :source_ext => [:groovy, :java],
+            :target => 'classes', :target_ext => 'class', :packaging => :jar
+
+    def initialize(project, options) #:nodoc:
+      super
+      options[:debug] = Buildr.options.debug if options[:debug].nil?
+      options[:deprecation] ||= false
+      options[:optimise] ||= false
+      options[:verbose] ||= trace?(:groovyc) if options[:verbose].nil?
+      options[:warnings] = verbose if options[:warnings].nil?
+      options[:javac] = OpenObject.new if options[:javac].nil?
+    end
+
+    # http://groovy.codehaus.org/The+groovyc+Ant+Task
+    def compile(sources, target, dependencies) #:nodoc:
+      return if Buildr.application.options.dryrun
+      Buildr.ant 'groovyc' do |ant|
+        classpath = dependencies
+        ant.taskdef :name => 'groovyc', :classname => ANT_TASK, :classpath => classpath.join(File::PATH_SEPARATOR)
+        ant.groovyc groovyc_options(sources, target) do
+          sources.each { |src| ant.src :path => src }
+          ant.classpath do
+            classpath.each { |dep| ant.pathelement :path => dep }
+          end
+          ant.javac(javac_options)
+        end
+      end
+    end
+
+   private
+    def groovyc_options(sources, target)
+      check_options options, OPTIONS
+      groovyc_options = options.to_hash.only(*GROOVYC_OPTIONS)
+      groovyc_options[:destdir] = File.expand_path(target)
+      groovyc_options
+    end
+
+    def javac_options
+      check_options options, OPTIONS
+      javac_options = options.to_hash.only(*JAVAC_OPTIONS)
+      javac_options[:optimize] = (javac_options.delete(:optimise) || false)
+      javac_options[:nowarn] = (javac_options.delete(:warnings) || verbose).to_s !~ /^(true|yes|on)$/i
+      other = javac_options.delete(:javac) || {}
+      javac_options.merge!(other)
+      javac_options
+    end
+
+  end
+end
+
+# Groovy compiler comes first, ahead of Javac, this allows it to pick
+# projects that mix Groovy and Java code by spotting Groovy code first.
+Buildr::Compiler.compilers.unshift Buildr::Groovy::Groovyc

data/lib/buildr/groovy/doc.rb

@@ -0,0 +1,76 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'buildr/core/doc'
+require 'buildr/groovy/compiler'   # ensure Groovy dependencies are ready
+
+module Buildr
+  module Doc
+
+    module GroovydocDefaults
+      include Extension
+
+      # Default groovydoc -doc-title to project's comment or name
+      after_define(:groovydoc => :doc) do |project|
+        if project.doc.engine? Groovydoc
+          options = project.doc.options
+          options[:windowtitle] = (project.comment || project.name) unless options[:windowtitle]
+        end
+      end
+    end
+
+    class Groovydoc < Base
+      specify :language => :groovy, :source_ext => ['java', 'groovy']
+
+      def generate(sources, target, options = {})
+        mkdir_p target
+        cmd_args = [ '-d', target, trace?(:groovydoc) ? '-verbose' : nil ].compact
+        options.reject { |key, value| [:sourcepath, :classpath].include?(key) }.
+          each { |key, value| value.invoke if value.respond_to?(:invoke) }.
+          each do |key, value|
+            case value
+            when true, nil
+              cmd_args << "-#{key}"
+            when false
+              cmd_args << "-no#{key}"
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
+            end
+          end
+        [:sourcepath, :classpath].each do |option|
+          Array(options[option]).flatten.tap do |paths|
+            cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+          end
+        end
+        cmd_args += sources.flatten.uniq
+        unless Buildr.application.options.dryrun
+          info "Generating Groovydoc for #{project.name}"
+          trace (['groovydoc'] + cmd_args).join(' ')
+          result = Java::Commands.java('org.codehaus.groovy.tools.groovydoc.Main', cmd_args,
+                                        :classpath => Buildr::Groovy.dependencies)
+        end
+      end
+    end
+  end
+
+  class Project
+    include GroovydocDefaults
+  end
+end
+
+Buildr::Doc.engines << Buildr::Doc::Groovydoc
+

data/lib/buildr/groovy/shell.rb

@@ -0,0 +1,57 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'buildr/shell'
+
+module Buildr
+  module Groovy
+    class GroovySH < Buildr::Shell::Base
+      include JRebel
+
+      SUFFIX = if Util.win_os? then '.bat' else '' end
+
+      specify :name => :groovy, :languages => [:groovy]
+
+      def launch(task)
+        cp = Groovy.dependencies +
+             project.compile.dependencies +
+             [ project.path_to(:target, :classes) ] +
+             task.classpath
+        props = jrebel_props(project).merge(task.properties)
+        java_args = jrebel_args + task.java_args
+
+        groovy_home = nil
+        if groovy_home
+          cmd_args = " -classpath '#{cp.join(File::SEPARATOR)}'"
+          trace "groovysh #{cmd_args}"
+          system(File.expand_path("bin#{File::SEPARATOR}groovysh#{SUFFIX}", groovy_home) + cmd_args)
+        else
+          Java::Commands.java 'org.codehaus.groovy.tools.shell.Main', {
+            :properties => props,
+            :classpath => cp,
+            :java_args => java_args
+          }
+        end
+      end
+
+    private
+      def groovy_home
+        @home ||= ENV['GROOVY_HOME']
+      end
+    end
+  end
+end
+
+Buildr::Shell.providers << Buildr::Groovy::GroovySH

data/lib/buildr/ide.rb

@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/ide/eclipse'
+require 'buildr/ide/idea'
+

data/lib/buildr/ide/eclipse.rb

@@ -0,0 +1,427 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/core/project'
+require 'buildr/packaging'
+
+
+module Buildr
+  module Eclipse #:nodoc:
+    include Extension
+
+    class Eclipse
+
+      attr_reader :options
+      attr_writer :name
+
+      def initialize(project)
+        @project = project
+        @options = Options.new(project)
+      end
+
+      def name
+        return @name if @name
+        return @project.id.split('-').last if @options.short_names
+        @project.id
+      end
+
+      # :call-seq:
+      #   classpath_variables :VAR => '/path/to/location'
+      # Sets classpath variables to be used for library path substitution
+      # on the project.
+      #
+      def classpath_variables(*values)
+        fail "eclipse.classpath_variables expects a single hash argument" if values.size > 1
+        if values.size == 1
+          fail "eclipse.classpath_variables expects a Hash argument" unless values[0].is_a? Hash
+          # convert keys to strings
+          values = values[0].inject({}) { |h, (k,v)| h[k.to_s] = @project.path_to(v); h }
+          @variables = values.merge(@variables || {})
+        end
+        @variables || (@project.parent ? @project.parent.eclipse.classpath_variables : default_classpath_variables)
+      end
+
+      def default_classpath_variables
+        vars = {}
+        vars[:SCALA_HOME] = ENV['SCALA_HOME'] if ENV['SCALA_HOME']
+        vars[:JAVA_HOME]  = ENV['JAVA_HOME']  if ENV['JAVA_HOME']
+        vars
+      end
+
+      # :call-seq:
+      #   natures=(natures)
+      # Sets the Eclipse project natures on the project.
+      #
+      def natures=(var)
+        @natures = arrayfy(var)
+      end
+
+      # :call-seq:
+      #   natures() => [n1, n2]
+      # Returns the Eclipse project natures on the project.
+      # They may be derived from the parent project if no specific natures have been set
+      # on the project.
+      #
+      # An Eclipse project nature is used internally by Eclipse to determine the aspects of a project.
+      def natures(*values)
+        if values.size > 0
+          @natures ||= []
+          @natures += values.flatten
+        else
+          @natures || (@project.parent ? @project.parent.eclipse.natures : [])
+        end
+      end
+
+      # :call-seq:
+      #   classpath_containers=(cc)
+      # Sets the Eclipse project classpath containers on the project.
+      #
+      def classpath_containers=(var)
+        @classpath_containers = arrayfy(var)
+      end
+
+      # :call-seq:
+      #   classpath_containers() => [con1, con2]
+      # Returns the Eclipse project classpath containers on the project.
+      # They may be derived from the parent project if no specific classpath containers have been set
+      # on the project.
+      #
+      # A classpath container is an Eclipse pre-determined ensemble of dependencies made available to
+      # the project classpath.
+      def classpath_containers(*values)
+        if values.size > 0
+          @classpath_containers ||= []
+          @classpath_containers += values.flatten
+        else
+          @classpath_containers || (@project.parent ? @project.parent.eclipse.classpath_containers : [])
+        end
+      end
+
+      # :call-seq:
+      #   exclude_libs() => [lib1, lib2]
+      # Returns the an array of libraries to be excluded from the generated Eclipse classpath
+      def exclude_libs(*values)
+        if values.size > 0
+          @exclude_libs ||= []
+          @exclude_libs += values.flatten
+        else
+          @exclude_libs || (@project.parent ? @project.parent.eclipse.exclude_libs : [])
+        end
+      end
+
+      # :call-seq:
+      #   exclude_libs=(lib1, lib2)
+      # Sets libraries to be excluded from the generated Eclipse classpath
+      #
+      def exclude_libs=(libs)
+        @exclude_libs = arrayfy(libs)
+      end
+
+      # :call-seq:
+      #   builders=(builders)
+      # Sets the Eclipse project builders on the project.
+      #
+      def builders=(var)
+        @builders = arrayfy(var)
+      end
+
+      # :call-seq:
+      #   builders() => [b1, b2]
+      # Returns the Eclipse project builders on the project.
+      # They may be derived from the parent project if no specific builders have been set
+      # on the project.
+      #
+      # A builder is an Eclipse background job that parses the source code to produce built artifacts.
+      def builders(*values)
+        if values.size > 0
+          @builders ||= []
+          @builders += values.flatten
+        else
+          @builders || (@project.parent ? @project.parent.eclipse.builders : [])
+        end
+      end
+
+      private
+
+      def arrayfy(obj)
+        obj.is_a?(Array) ? obj : [obj]
+      end
+    end
+
+    class Options
+
+      attr_writer :m2_repo_var, :short_names
+
+      def initialize(project)
+        @project = project
+      end
+
+      # The classpath variable used to point at the local maven2 repository.
+      # Example:
+      #   eclipse.options.m2_repo_var = 'M2_REPO'
+      def m2_repo_var(*values)
+        fail "m2_repo_var can only accept one value: #{values}" if values.size > 1
+        if values.size > 0
+          @m2_repo_var = values[0]
+        else
+          @m2_repo_var || (@project.parent ? @project.parent.eclipse.options.m2_repo_var : 'M2_REPO')
+        end
+      end
+
+      def short_names
+        @short_names || (@project.parent ? @project.parent.eclipse.options.short_names : false)
+      end
+    end
+
+    def eclipse
+      @eclipse ||= Eclipse.new(self)
+      @eclipse
+    end
+
+    first_time do
+      # Global task "eclipse" generates artifacts for all projects.
+      desc 'Generate Eclipse artifacts for all projects'
+      Project.local_task('eclipse'=>'artifacts') { |name|  "Generating Eclipse project for #{name}" }
+    end
+
+    before_define do |project|
+      project.recursive_task('eclipse')
+    end
+
+    after_define(:eclipse => :package) do |project|
+      # Need to enhance because using project.projects during load phase of the
+      # buildfile has harmful side-effects on project definition order
+      project.enhance do
+        eclipse = project.task('eclipse')
+        # We don't create the .project and .classpath files if the project contains projects.
+        if project.projects.empty?
+
+          eclipse.enhance [ file(project.path_to('.classpath')), file(project.path_to('.project')) ]
+
+          # The only thing we need to look for is a change in the Buildfile.
+          file(project.path_to('.classpath')=>Buildr.application.buildfile) do |task|
+            if (project.eclipse.natures.reject { |x| x.is_a?(Symbol) }.size > 0)
+              info "Writing #{task.name}"
+
+              m2repo = Buildr::Repositories.instance.local
+
+              File.open(task.name, 'w') do |file|
+                classpathentry = ClasspathEntryWriter.new project, file
+                classpathentry.write do
+                  # Note: Use the test classpath since Eclipse compiles both "main" and "test" classes using the same classpath
+                  cp = project.test.compile.dependencies.map(&:to_s) - [ project.compile.target.to_s, project.resources.target.to_s ]
+                  cp = cp.uniq
+
+                  # Convert classpath elements into applicable Project objects
+                  cp.collect! { |path| Buildr.projects.detect { |prj| prj.packages.detect { |pkg| pkg.to_s == path } } || path }
+
+                  # Remove excluded libs
+                  cp -= project.eclipse.exclude_libs.map(&:to_s)
+
+                  # project_libs: artifacts created by other projects
+                  project_libs, others = cp.partition { |path| path.is_a?(Project) }
+
+                  # Separate artifacts under known classpath variable paths
+                  # including artifacts located in local Maven2 repository
+                  vars = []
+                  project.eclipse.classpath_variables.merge(project.eclipse.options.m2_repo_var => m2repo).each do |name, path|
+                    matching, others = others.partition { |f| File.expand_path(f.to_s).index(path) == 0 }
+                    matching.each do |m|
+                      vars << [m, name, path]
+                    end
+                  end
+
+                  # Generated: Any non-file classpath elements in the project are assumed to be generated
+                  libs, generated = others.partition { |path| File.file?(path.to_s) }
+
+                  classpathentry.src project.compile.sources + generated
+                  classpathentry.src project.resources
+
+                  if project.test.compile.target
+                    classpathentry.src project.test.compile
+                    classpathentry.src project.test.resources
+                  end
+
+                  # Classpath elements from other projects
+                  classpathentry.src_projects project_libs
+
+                  classpathentry.output project.compile.target if project.compile.target
+                  classpathentry.lib libs
+                  classpathentry.var vars
+
+                  project.eclipse.classpath_containers.each { |container|
+                    classpathentry.con container
+                  }
+                end
+              end
+            end
+          end
+
+          # The only thing we need to look for is a change in the Buildfile.
+          file(project.path_to('.project')=>Buildr.application.buildfile) do |task|
+            info "Writing #{task.name}"
+            File.open(task.name, 'w') do |file|
+              xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
+              xml.projectDescription do
+                xml.name project.eclipse.name
+                xml.projects
+                unless project.eclipse.builders.empty?
+                  xml.buildSpec do
+                    project.eclipse.builders.each { |builder|
+                      xml.buildCommand do
+                        xml.name builder
+                      end
+                    }
+                  end
+                end
+                unless project.eclipse.natures.empty?
+                  xml.natures do
+                    project.eclipse.natures.each { |nature|
+                      xml.nature nature unless nature.is_a? Symbol
+                    }
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+
+    # Writes 'classpathentry' tags in an xml file.
+    # It converts tasks to paths.
+    # It converts absolute paths to relative paths.
+    # It ignores duplicate directories.
+    class ClasspathEntryWriter #:nodoc:
+      def initialize project, target
+        @project = project
+        @xml = Builder::XmlMarkup.new(:target=>target, :indent=>2)
+        @excludes = [ '**/.svn/', '**/CVS/' ].join('|')
+        @paths_written = []
+      end
+
+      def write &block
+        @xml.classpath &block
+      end
+
+      def con path
+        @xml.classpathentry :kind=>'con', :path=>path
+      end
+
+      def lib libs
+        libs.map(&:to_s).sort.uniq.each do |path|
+          @xml.classpathentry :kind=>'lib', :path=>relative(path)
+        end
+      end
+
+      # Write a classpathentry of kind 'src'.
+      # Accept an array of absolute paths or a task.
+      def src arg
+        if [:sources, :target].all? { |message| arg.respond_to?(message) }
+          src_from_task arg
+        else
+          src_from_absolute_paths arg
+        end
+      end
+
+      # Write a classpathentry of kind 'src' for dependent projects.
+      # Accept an array of projects.
+      def src_projects project_libs
+        project_libs.map { |project| project.eclipse.name }.sort.uniq.each do |eclipse_name|
+          @xml.classpathentry :kind=>'src', :combineaccessrules=>'false', :path=>"/#{eclipse_name}"
+        end
+      end
+
+      def output target
+        @xml.classpathentry :kind=>'output', :path=>relative(target)
+      end
+
+      # Write a classpathentry of kind 'var' (variable) for a library in a local repo.
+      # * +libs+ is an array of library paths.
+      # * +var_name+ is a variable name as defined in Eclipse (e.g., 'M2_REPO').
+      # * +var_value+ is the value of this variable (e.g., '/home/me/.m2').
+      # E.g., <tt>var([lib1, lib2], 'M2_REPO', '/home/me/.m2/repo')</tt>
+      def var(libs)
+        libs.each do |lib_path, var_name, var_value|
+          lib_artifact = file(lib_path)
+
+          attribs = { :kind => 'var', :path => lib_path }
+
+          if lib_artifact.respond_to? :sources_artifact
+            attribs[:sourcepath] = lib_artifact.sources_artifact
+          end
+
+          if lib_artifact.respond_to? :javadoc_artifact
+            attribs[:javadocpath] = lib_artifact.javadoc_artifact
+          end
+
+          # make all paths relative
+          attribs.each_key do |k|
+            attribs[k] = attribs[k].to_s.sub(var_value, var_name.to_s) if k.to_s =~ /path/
+          end
+
+          @xml.classpathentry attribs
+        end
+      end
+
+    private
+
+      # Find a path relative to the project's root directory if possible. If the
+      # two paths do not share the same root the absolute path is returned. This
+      # can happen on Windows, for instance, when the two paths are not on the
+      # same drive.
+      def relative path
+        path or raise "Invalid path '#{path.inspect}'"
+        msg = [:to_path, :to_str, :to_s].find { |msg| path.respond_to? msg }
+        path = path.__send__(msg)
+        begin
+          Util.relative_path(File.expand_path(path), @project.path_to)
+        rescue ArgumentError
+          File.expand_path(path)
+        end
+      end
+
+      def src_from_task task
+        src_from_absolute_paths task.sources, task.target
+      end
+
+      def src_from_absolute_paths absolute_paths, output=nil
+        relative_paths = absolute_paths.map { |src| relative(src) }
+        relative_paths.sort.uniq.each do |path|
+          unless @paths_written.include?(path)
+            attributes = { :kind=>'src', :path=>path, :excluding=>@excludes }
+            attributes[:output] = relative(output) if output
+            @xml.classpathentry attributes
+            @paths_written << path
+          end
+        end
+      end
+    end
+
+  end
+
+end # module Buildr
+
+class Buildr::Project
+  include Buildr::Eclipse
+end
+
+# Order is significant for auto-detection, from most specific to least
+require 'buildr/ide/eclipse/plugin'
+require 'buildr/ide/eclipse/scala'
+require 'buildr/ide/eclipse/java'
+