buildr4osgi 0.9.3 → 0.9.4

data/buildr4osgi.gemspec

@@ -16,7 +16,7 @@
 
 Gem::Specification.new do |spec|
   spec.name           = 'buildr4osgi'
-  spec.version        = '0.9.3'
+  spec.version        = '0.9.4'
   spec.author         = 'Antoine Toulme'
   spec.email          = "atoulme@intalio.com"
   spec.homepage       = "http://buildr.apache.org/"

data/lib/buildr4osgi/compile/external.rb

@@ -32,12 +32,14 @@ module Buildr4OSGi
         cmd_args << '-sourcepath' << source_paths.join(File::PATH_SEPARATOR) unless source_paths.empty?
         cmd_args << '-d' << File.expand_path(target)
         cmd_args += externalc_args
-        cmd_args += files_from_sources(sources)
+        Tempfile.open("external") {|tmp|
+          tmp.write files_from_sources(sources).join(' ')
+          cmd_args << "@#{tmp.path}"
+        }
         unless Buildr.application.options.dryrun
           fail "ENV['EXTERNAL_COMPILER'] is not defined" if ENV['EXTERNAL_COMPILER'].nil?
-          javac_path = "#{ENV['EXTERNAL_COMPILER']}#{File::SEPARATOR}bin#{File::SEPARATOR}java"
-          ecj_path = File.expand_path(File.join(File.dirname(__FILE__), "ecj-#{Buildr4OSGi::CompilerSupport::OSGiC::CURRENT_JDT_COMPILER}.jar"))
-          final_args = ([javac_path,"-classpath", ecj_path, "org.eclipse.jdt.internal.compiler.batch.Main"] + cmd_args).join(' ')
+          javac_path = File.join(ENV['EXTERNAL_COMPILER'], "bin", "javac")
+          final_args = cmd_args.insert(0, javac_path).push('2>&1').join(' ')
           trace(final_args)
           info %x[#{final_args}]
           fail 'Failed to compile, see errors above' unless $?.success?
@@ -49,7 +51,7 @@ module Buildr4OSGi
       # See arg list here: http://publib.boulder.ibm.com/infocenter/rsahelp/v7r0m0/index.jsp?topic=/org.eclipse.jdt.doc.isv/guide/jdt_api_compile.htm
       def externalc_args #:nodoc:
         args = []  
-        args << '-warn:none' unless options[:warnings]
+        args << '-nowarn' unless options[:warnings]
         args << '-verbose' if Buildr.application.options.trace
         args << '-g' if options[:debug]
         args << '-deprecation' if options[:deprecation]

data/lib/buildr4osgi/eclipse/feature.rb

@@ -189,14 +189,18 @@ PROPERTIES
           
           artifact = case 
             when plugin.is_a?(String)
-              Buildr::artifact(plugin)
+              if plugin.match /.*:.*:.*/ # is it an artifact string representation ?
+                Buildr::artifact(plugin)
+              else # treat it as a .jar
+                file(plugin)
+              end
             when plugin.is_a?(Buildr::Project)
               Buildr::artifact(plugin.package(:plugin))
             else 
               plugin
             end
-          info = adapt_plugin(artifact)
-          info[:unjarred] = @unjarred[plugin][:unjarred] unless @unjarred[plugin].nil?
+          info, as_dir = adapt_plugin(artifact)
+          info[:unjarred] = as_dir || @unjarred[plugin][:unjarred] unless @unjarred[plugin].nil?
           resolved_plugins[info] = artifact
         end
       end
@@ -211,14 +215,19 @@ PROPERTIES
       repackage = nil
       sourceBundle = nil
       if plugin.is_a? Buildr::Project
+        manifest = plugin.package(:plugin).manifest.main
+        if File.exists? plugin.path_to("META-INF/MANIFEST.MF")
+          manifest = ::Buildr::Packaging::Java::Manifest.parse(File.read(plugin.path_to("META-INF/MANIFEST.MF"))).main.merge(manifest)
+        end
         size = File.size(plugin.package(:plugin).to_s)
-        name = plugin.package(:plugin).manifest.main["Bundle-SymbolicName"]
-        version = plugin.package(:plugin).manifest.main["Bundle-Version"]
+        name = manifest["Bundle-SymbolicName"]
+        version = manifest["Bundle-Version"]
         group = plugin.group
-        sourceBundle = plugin.package(:plugin).manifest.main["Eclipse-SourceBundle"]
+        sourceBundle = manifest["Eclipse-SourceBundle"]
+        as_dir = "dir" == manifest["Eclipse-BundleShape"].strip
       else
         plugin.invoke
-        if !File.exist?(plugin.to_s) and plugin.classifier.to_s == 'sources'
+        if !File.exist?(plugin.to_s) && plugin.classifier.to_s == 'sources'
           #make sure the artifact was downloaded.
           #if the artifact is for the sources feature and it could not be located,
           #don't crash. should we put something in the manifest?
@@ -229,6 +238,7 @@ PROPERTIES
           unless entry.nil?
             manifest = Manifest.read(zip.read("META-INF/MANIFEST.MF"))
             sourceBundle = manifest.first["Eclipse-SourceBundle"].keys.first.strip unless manifest.first["Eclipse-SourceBundle"].nil?
+            as_dir = "dir" == manifest.first["Eclipse-BundleShape"].keys.first.strip unless manifest.first["Eclipse-BundleShape"].nil?
             if !manifest.first["Bundle-SymbolicName"].nil?
               bundle = ::OSGi::Bundle.fromManifest(manifest, plugin.to_s)
               unless bundle.nil?
@@ -238,10 +248,10 @@ PROPERTIES
             end
           end
         end
-        group = plugin.to_hash[:group]
+        #group = plugin.to_hash[:group]
         size = File.size(plugin.to_s)
       end
-      if plugin.classifier.to_s == 'sources' and (sourceBundle.nil? || name.nil? || version.nil?)
+      if plugin.is_a?(Artifact) && plugin.classifier.to_s == 'sources' && (sourceBundle.nil? || name.nil? || version.nil?)
         # Try, if possible, to get the name and the version from the original binaries then.
         runtimeArtifact = Buildr::artifact(plugin.to_hash.merge(:classifier => nil, :type => :jar))
         runtimeManifest = extraPackagedManifest(runtimeArtifact)
@@ -259,8 +269,8 @@ PROPERTIES
         warn "Could not determine the size of #{plugin}"
         size ||= 0
       end
-      return {:id => name, :group => group, :version => version, 
-        :"download-size" => size, :"install-size" => size, :unpack => false, :manifest => repackage}
+      return {:id => name, :version => version, 
+        :"download-size" => size, :"install-size" => size, :unpack => false, :manifest => repackage}, as_dir
     end
     
     #returns the META-INF/MANIFEST.MF file for something that
@@ -318,16 +328,20 @@ PROPERTIES
           
           artifact = case 
             when plugin.is_a?(String)
-              Buildr::artifact(plugin)
+               if plugin.match /.*:.*:.*/ # is it an artifact string representation ?
+                  Buildr::artifact(plugin)
+                else # treat it as a .jar
+                  file(plugin)
+                end
             when plugin.is_a?(Buildr::Project)
               Buildr::artifact(plugin.package(:sources))
             else 
               plugin
             end
           artifact = Buildr::artifact(artifact.to_hash.merge(:classifier => "sources")) if artifact.is_a?(Buildr::Artifact)
-          info = adapt_plugin(artifact)
+          info, as_dir = adapt_plugin(artifact)
           if !info.nil? 
-            info[:unjarred] = @unjarred[plugin][:unjarred] unless @unjarred[plugin].nil?
+            info[:unjarred] = as_dir || (!@unjarred[plugin].nil? && @unjarred[plugin][:unjarred])
             resolved_plugins[info] = artifact
           end
         end

data/lib/buildr4osgi/eclipse/p2.rb

@@ -22,7 +22,7 @@ module Buildr4OSGi
     def package_as_p2_from_site(file_name)
       task = UpdateSitePublisherTask.define_task(file_name)
       task.send :associate_with, self
-      return task
+      task
     end
     
     def package_as_p2_from_site_spec(spec)
@@ -32,76 +32,41 @@ module Buildr4OSGi
     class UpdateSitePublisherTask < ::Buildr::Packaging::Java::JarTask
 
       attr_accessor :site
-      attr_reader :project
-
+      
       def initialize(*args) #:nodoc:
         super
-        enhance do
-#          Buildr.ant('org.eclipse.equinox.p2.publisher.UpdateSitePublisher') do |ant|
-#            work_dir = File.join(project.base_dir, "target", "generated", "update-site")
-#            ant.java :fork => true, :failonerror => true, :classname=>'org.eclipse.equinox.p2.publisher.UpdateSitePublisher' do
-#              ant.arg :value => "metadataRepository" 
-#              ant.arg :value => work_dir
-#              ant.arg :value => "artifactRepository"
-#              ant.arg :value => work_dir
-#              ant.arg :value => "compress"
-#              ant.arg :value => "publishArtifacts"
-#            end
-#          end
-# http://wiki.eclipse.org/Equinox/p2/Publisher
-#the p2.installer and the p2.agent don't work. currently debugging with a local eclipse sdk.
-# download the app here: "org.eclipse.equinox.p2:installer:3.6M2-linux.gtk.x86:tgz"
-# unzip it wherever it is.
-# then invoke it on the cmd line `java -jar #{launcherLocation} -application ... -source #{siteLocation}`
-#we need to give the ability to define an eclipse home that could be invoked as a replacement to this.
-#          p2installer = Buildr::artifact("org.eclipse.platform:eclipse-platform:tgz:3.6M3-linux-gtk")
-#          p2installer.invoke
-#          p2installerHome = File.join(project.base_dir, "target", "p2installer")
-#          Buildr::unzip(p2installerHome => p2installer).extract
-#          p2installerHome = File.join(p2installerHome, "eclipse")
-          
-          #add the missing publisher plugin:
-#          p2publisher = Buildr::artifact("org.eclipse.equinox.p2:org.eclipse.equinox.p2.publisher:jar:1.1.0.v20090831")
-#          p2publisher.invoke
-#          cp p2publisher.to_s, File.join(p2installerHome, "plugins/#{p2publisher.id}_#{p2publisher.version}.jar")
+        
+        enhance do |p2_task|
+          fail "The p2 task needs to be associated with a site " unless site
+          p2_task.enhance [site]
+          #add a prerequisite to the list of prerequisites, gives a chance
+          #for other prerequisites to be placed before this block is executed.
+          p2_task.enhance do 
+            targetP2Repo = File.join(project.base_dir, "target", "p2repository")
+            mkpath targetP2Repo
+            Buildr::unzip(targetP2Repo=>project.package(:site).to_s).extract
+            eclipseSDK = Buildr::artifact("org.eclipse:eclipse-SDK:zip:3.6M3-win32")
+            eclipseSDK.invoke
+            Buildr::unzip(File.dirname(eclipseSDK.to_s) => eclipseSDK.to_s).extract
+
+            launcherPlugin = Dir.glob("#{File.dirname(eclipseSDK.to_s)}/eclipse/plugins/org.eclipse.equinox.launcher_*")[0]
 
-          siteWithoutP2 = project.package(:site)
-          siteWithoutP2.invoke
+            cmdline <<-CMD
+            java -jar #{launcherPlugin} -application org.eclipse.equinox.p2.publisher.UpdateSitePublisher
+            -metadataRepository file:#{targetP2Repo} 
+            -artifactRepository file:#{targetP2Repo}
+            -metadataRepositoryName #{project.name}_#{project.version}
+            -artifactRepositoryName #{project.name}_#{project.version} 
+            -source #{targetP2Repo} 
+            -configs gtk.linux.x86 
+            -publishArtifacts 
+            -clean -consoleLog
+            CMD
+            info "Invoking P2's metadata generation: #{cmdline}"
+            system cmdline
 
-          targetDir = File.join(project.base_dir, "target")
-          targetP2Repo = File.join(project.base_dir, "target", "p2repository");
-          mkpath targetP2Repo
-          Buildr::unzip(targetP2Repo=>siteWithoutP2.to_s).extract
-          eclipseSDK = Buildr::artifact("org.eclipse:eclipse-SDK:zip:3.6M3-win32")
-          eclipseSDK.invoke
-          p2installerHome = File.dirname eclipseSDK.to_s#"~/proj/eclipses/eclipse-SDK-3.6M3"
-          Buildr::unzip( p2installerHome => eclipseSDK.to_s ).extract
-          p2installerHome += "/eclipse"
-          launcherPlugin = Dir.glob("#{p2installerHome}/plugins/org.eclipse.equinox.launcher_*")[0]
-          
-          application = "org.eclipse.equinox.p2.publisher.UpdateSitePublisher"
-          #this is where the artifacts are published.
-          metadataRepository_url = "file:#{targetP2Repo}"
-          artifactRepository_url = metadataRepository_url
-          metadataRepository_name = project.id + "_" + project.version
-          artifactRepository_name = project.id + "_" + project.version
-          source_absolutePath = targetP2Repo
-          
-          cmdline = "java -jar #{launcherPlugin} -application #{application} \
--metadataRepository #{metadataRepository_url} \
--artifactRepository #{artifactRepository_url} \
--metadataRepositoryName #{metadataRepository_name} \
--artifactRepositoryName #{artifactRepository_name} \
--source #{source_absolutePath} \
--configs gtk.linux.x86 \
--publishArtifacts \
--clean -consoleLog"
-          puts "Invoking P2's metadata generation: #{cmdline}"
-          result = `#{cmdline}`
-          puts result
-          
-          include targetP2Repo, :as=>"."
-          
+            include targetP2Repo, :as => "."
+          end
         end
       end
 
@@ -123,6 +88,8 @@ module Buildr4OSGi
 
       private 
 
+      attr_reader :project
+      
       def associate_with(project)
         @project = project
       end

data/lib/buildr4osgi/osgi/packaging.rb

@@ -103,6 +103,23 @@ module OSGi
     # Artifacts to include under /lib.
     attr_accessor :libs
     
+    # Calls to this method will make the bundle use
+    # the bundle manifest version if defined.
+    # An exception will be raised if no manifest file is present or no Bundle-Version is present in it.
+    #
+    #
+    def use_bundle_version
+      manifest_location = File.join(@project.base_dir, "META-INF", "MANIFEST.MF")
+      if File.exists?(manifest_location)
+        read_m = ::Buildr::Packaging::Java::Manifest.parse(File.read(manifest_location)).main
+        raise "Cannot use use_bundle_version if no Bundle-Version header is specified in the manifest" if read_m["Bundle-Version"].nil?
+        manifest["Bundle-Version"] = read_m["Bundle-Version"]
+      else
+        raise "Cannot use use_bundle_version if no manifest is present in the project"
+      end
+      process_qualifier
+    end
+    
     def initialize(*args) #:nodoc:
       super
       @libs = []
@@ -116,6 +133,89 @@ module OSGi
       end
     end
     
+    def process_qualifier
+      if manifest["Bundle-Version"].match /\.qualifier$/
+        manifest["Bundle-Version"] = "#{$~.pre_match}.#{Time.now.strftime("%y%m%d%H%M%S")}"
+      end
+    end
+    
+    private
+    
+    def associate_with(project)
+      @project = project
+    end
+    
+  end
+  
+  class RootFilter < Buildr::Filter
+    
+    def pattern_match(file, pattern)
+      case
+      when pattern.is_a?(Regexp)
+        return file.match(pattern)
+      when pattern.is_a?(String)
+        return File.fnmatch(pattern, file)
+      when pattern.is_a?(Proc)
+        return pattern.call(file)
+      else
+        raise "Cannot interpret pattern #{pattern}"
+      end
+    end
+    # :call-seq:
+    #    run => boolean
+    #
+    # Runs the filter.
+    def run
+      sources.each { |source| raise "Source directory #{source} doesn't exist" unless File.exist?(source.to_s) }
+      raise 'No target directory specified, where am I going to copy the files to?' if target.nil?
+
+      copy_map = sources.flatten.map(&:to_s).inject({}) do |map, source|
+        files = Util.recursive_with_dot_files(source).
+          map { |file| Util.relative_path(file, source) }.
+          select { |file| @include.empty? || @include.any? { |pattern| pattern_match(file, pattern) } }.
+          reject { |file| @exclude.any? { |pattern| pattern_match(file, pattern) } }
+        files.each do |file|
+          src, dest = File.expand_path(file, source), File.expand_path(file, target.to_s)
+          map[file] = src if !File.exist?(dest) || File.stat(src).mtime >= File.stat(dest).mtime
+        end
+        map
+      end
+        
+      mkpath target.to_s
+      return false if copy_map.empty?
+
+      copy_map.each do |path, source|
+        dest = File.expand_path(path, target.to_s)
+        if File.directory?(source)
+          mkpath dest
+        else
+          mkpath File.dirname(dest)
+          if @mapper.mapper_type
+            mapped = @mapper.transform(File.open(source, 'rb') { |file| file.read }, path)
+            File.open(dest, 'wb') { |file| file.write mapped }
+          else # no mapping
+            cp source, dest
+            File.chmod(0664, dest)
+          end
+        end
+      end
+      touch target.to_s
+      true
+    end
+    
+  end
+  
+  # A copy/paste of the ResourcesTask specifically modified for the job
+  # of including resources located at the root of the project.
+  #
+  class RootResourcesTask < Buildr::ResourcesTask
+
+    def initialize(*args) #:nodoc:
+      super
+      @filter = RootFilter.new
+      @filter.using Buildr.settings.profile['filter'] if Hash === Buildr.settings.profile['filter']
+    end
+
   end
   
   module ActAsOSGiBundle
@@ -131,6 +231,7 @@ module OSGi
     end    
     
     def package_as_bundle(file_name)
+      
       task = BundleTask.define_task(file_name).tap do |plugin|
         # Custom resource task to grab everything located at the root of the project
         # while leaving the user also specify a resources directory, in case we are in face
@@ -138,30 +239,55 @@ module OSGi
         # This is a bit hacky and not fully respecting the project layout, so we might find some alternative later
         # to do the job by extending the layout object, and maybe making this resource task available as a subclass
         # of ResourcesTask.
-        p_r = ResourcesTask.define_task
-        p_r.send :associate_with, project, :main
-        p_r.from("#{project.base_dir}").exclude("**/.*").exclude("**/*.jar").exclude("**/*.java")
-        p_r.exclude("src/**").exclude("*src").exclude("*src/**").exclude("build.properties")
-        p_r.exclude("bin").exclude("bin/**")
-        p_r.exclude("target/**").exclude("target")
+        p_r = RootResourcesTask.define_task(:resources_root)
+        p_r.send :associate_with, self, :root
+        p_r.filter.from(base_dir).exclude(/^\..*/).exclude("*.jar").exclude("*.java").exclude("build.properties")
+        p_r.exclude(lambda {|file|
+          binaries_base_folder = project.compile.target.to_s.match(Regexp.escape(project.base_dir + File::SEPARATOR)) ? $~.post_match : project.compile.target.to_s
+          file.match(Regexp.new(Regexp.escape binaries_base_folder)) || project.compile.sources.detect {|src_folder|
+            relative_folder = src_folder.match(Regexp.escape(project.base_dir)) ? $~.post_match : src_folder
+            true if file.match(Regexp.new(Regexp.escape(relative_folder.scan(/\w+/).first)))
+          }
+        })
+        p_r.filter.exclude(/target/)
+        p_r.filter.exclude(/report/)
         
+        properties = ResourcesTask.define_task(:resources_src)
+        properties.send :associate_with, self, :resources_src
         
-        properties = ResourcesTask.define_task
-        properties.send :associate_with, project, :main
-        properties.from(File.join(project.base_dir, project.layout[:source, :main, :java])).
-          exclude("**/.*").exclude("**/*.java") if File.exists? File.join(project.base_dir, project.layout[:source, :main, :java])
+        unless compile.nil?
+          compile.sources.each {|src_folder|
+            properties.from(src_folder).exclude(".*").exclude("*.java")
+          }
+        end
         
         manifest_location = File.join(project.base_dir, "META-INF", "MANIFEST.MF")
-        manifest = project.manifest
+        manifest = self.manifest
         if File.exists?(manifest_location)
           read_m = ::Buildr::Packaging::Java::Manifest.parse(File.read(manifest_location)).main
-          manifest = project.manifest.merge(read_m)
+          manifest = self.manifest.merge(read_m)
         end
-        manifest["Bundle-Version"] = project.version # the version of the bundle packaged is ALWAYS the version of the project.
-        manifest["Bundle-SymbolicName"] ||= project.name.split(":").last # if it was resetted to nil, we force the id to be added back.
+        
+        manifest["Bundle-Version"] = self.version # the version of the bundle packaged is ALWAYS the version of the project.
+        # You can override it later with use_bundle_version
+        
+        
+        manifest["Bundle-SymbolicName"] ||= self.name.split(":").last # if it was resetted to nil, we force the id to be added back.
+        
         plugin.with :manifest=> manifest, :meta_inf=>meta_inf
-        plugin.with [compile.target, resources.target, p_r.target, properties.target].compact
+        unless manifest["Bundle-Classpath"].nil? || compile.target.nil?
+          entry = manifest["Bundle-Classpath"].split(",").first
+          plugin.path(entry).include compile.target, :as=>'.'
+          plugin.path(entry).include properties.target, :as=>'.' unless properties.target.nil?
+          plugin.with [resources.target, p_r.target].compact
+        else
+          plugin.with [compile.target, resources.target, p_r.target, properties.target].compact
+        end
+        
+        plugin.process_qualifier
       end
+      task.send :associate_with, self
+      task
     end
     
     def package_as_bundle_spec(spec) #:nodoc: