eclipse.rb in buildr-0.19.0

- old
+ new
@@ -1,53 +1,68 @@
 require "pathname"
+require "core/project"
+require "java/artifact"
 
 module Buildr
 
   # Global task "eclipse" generates artifacts for all projects.
   desc "Generate Eclipse artifacts for all projects"
-  Project.local_task task("eclipse"=>"artifacts")
+  Project.local_task "eclipse"=>"artifacts"
 
   Project.on_define do |project|
     eclipse = project.recursive_task("eclipse")
 
     project.enhance do |project|
 
       # We need paths relative to the top project's base directory.
       root_path = lambda { |p| f = lambda { |p| p.parent ? f[p.parent] : p.base_dir } ; f[p] }[project]
-      # We're guessing the Rakefile is there, but keep in mind it might not exist
-      # (most test cases don't create it).
-      sources = []
+      # We want the Eclipse files changed every time the Rakefile changes, but also anything loaded by
+      # the Rakefile (buildr.rb, separate file listing dependencies, etc), so we add anything required
+      # after the Rakefile. So which don't know where Buildr shows up exactly, ignore files that show
+      # in $LOADED_FEATURES that we cannot resolve.
+      sources = ($LOADED_FEATURES - Buildr.instance_eval("@loaded_features_to_ignore")).
+        map { |file| File.expand_path(file) }.select { |file| File.exist?(file) }
       sources << File.expand_path(Rake.application.rakefile, root_path) if Rake.application.rakefile
 
       # Only for projects that are Eclipse packagable.
       if project.packages.detect { |pkg| pkg.type =~ /(jar)|(war)|(rar)|(mar)|(aar)/ }
         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 Rakefile.
         file(project.path_to(".classpath")=>sources) do |task|
           puts "Writing #{task.name}" if verbose
-          
+
           # Find a path relative to the project's root directory.
-          relative = lambda { |path| Pathname.new(path).relative_path_from(Pathname.new(project.path_to)).to_s }
+          relative = lambda do |path|
+            msg = [:to_path, :to_str, :to_s].find { |msg| path.respond_to? msg }
+            path = path.__send__(msg)
+            Pathname.new(path).relative_path_from(Pathname.new(project.path_to)).to_s
+          end
+          m2repo = Buildr::Repositories.instance.local
 
           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 }
+              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] },
-                :output => relative[project.path_to(:java_target_dir)],
-                :con    => "org.eclipse.jdt.launching.JRE_CONTAINER",
-                :lib    => external.map(&:to_s)
+              { :src    => project.compile.sources.map { |src| relative[src] } + generated.map { |src| relative[src] },
+                :output => relative[project.compile.target],
+                :lib    => libs.map(&:to_s),
+                :var    => vars.map { |path| path.to_s.sub(m2repo, 'M2_REPO') }
               }.each do |kind, paths|
-                paths.to_a.each { |path| xml.classpathentry :kind=>kind, :path=>path }
+                paths.sort.uniq.each do |path|
+                  xml.classpathentry :kind=>kind, :path=>path
+                end
               end
-              internal.map(&:name).uniq.each do |prj_name|
+              internal.map(&:name).sort.uniq.each do |prj_name|
                 xml.classpathentry :kind=>"src", :combineaccessrules=>"false", :path=>"/#{prj_name}"
               end
             end
           end
         end