buildr4osgi 0.9.0 → 0.9.2

data/buildr4osgi.gemspec

@@ -16,7 +16,7 @@
 
 Gem::Specification.new do |spec|
   spec.name           = 'buildr4osgi'
-  spec.version        = '0.9.0'
+  spec.version        = '0.9.2'
   spec.author         = 'Antoine Toulme'
   spec.email          = "atoulme@intalio.com"
   spec.homepage       = "http://buildr.apache.org/"
@@ -36,5 +36,5 @@ TEXT
   spec.rdoc_options     = '--title', 'Buildr4osgi', '--main', 'README.rdoc',
                           '--webcvs', 'http://github.com/intalio/buildr4osgi'
   spec.post_install_message = "To get started run buildr --help"
-  spec.add_dependency("manifest", "= 0.0.6")
+  spec.add_dependency("manifest", "= 0.0.7")
 end

data/lib/buildr4osgi/compile/compiler.rb

@@ -21,7 +21,7 @@ module Buildr4OSGi
       OPTIONS = [:warnings, :debug, :deprecation, :source, :target, :lint, :other]
     
       specify :language=>:java, :sources => 'java', :source_ext => 'java',
-              :target=>'classes', :target_ext=>'class', :packaging=>:plugin
+              :target=>'classes', :target_ext=>'class', :packaging=>:jar
               
               
       def compile(sources, target, dependencies) #:nodoc:
@@ -33,16 +33,34 @@ module Buildr4OSGi
         source_paths = sources.select { |source| File.directory?(source) }
         cmd_args << '-sourcepath' << source_paths.join(File::PATH_SEPARATOR) unless source_paths.empty?
         cmd_args << '-d' << File.expand_path(target)
-        cmd_args += javac_args
+        cmd_args += osgic_args
         cmd_args += files_from_sources(sources)
         unless Buildr.application.options.dryrun
           trace((%w[javac -classpath org.eclipse.jdt.internal.compiler.batch.Main] + cmd_args).join(' '))
           Java.load
-          Java.org.eclipse.jdt.internal.compiler.batch.Main.main(cmd_args.
-            to_java(Java.java.lang.String)) == 0 or fail 'Failed to compile, see errors above'
+          Java.org.eclipse.jdt.internal.compiler.batch.Main.compile(cmd_args.join(" ")) or
+              fail 'Failed to compile, see errors above'
         end
       end
-      alias :osgic_args :javac_args 
+
+      private
+      
+      # 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 osgic_args #:nodoc:
+        args = []  
+        args << '-warn:none' unless options[:warnings]
+        args << '-verbose' if Buildr.application.options.trace
+        args << '-g' if options[:debug]
+        args << '-deprecation' if options[:deprecation]
+        args << '-source' << options[:source].to_s if options[:source]
+        args << '-target' << options[:target].to_s if options[:target]
+        case options[:lint]
+        when Array  then args << "-Xlint:#{options[:lint].join(',')}"
+        when String then args << "-Xlint:#{options[:lint]}"
+        when true   then args << '-Xlint'
+        end
+        args + Array(options[:other])
+      end
       
     end
     

data/lib/buildr4osgi/compile.rb

@@ -13,4 +13,4 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-#require 'buildr4osgi/compile/compiler'
+require 'buildr4osgi/compile/compiler'

data/lib/buildr4osgi/eclipse/feature.rb

@@ -17,20 +17,9 @@ module Buildr4OSGi
 
   module FeatureWriter
 
-    attr_accessor :feature_id
-    attr_accessor :version
-    attr_accessor :label
-    attr_accessor :copyright
-    attr_accessor :image
-    attr_accessor :provider
-    attr_accessor :description
-    attr_accessor :changesURL
-    attr_accessor :license
-    attr_accessor :licenseURL
-    attr_accessor :branding_plugin
-
-    attr_accessor :update_sites
-    attr_accessor :discovery_sites
+    VARS = [:feature_id, :version, :label, :copyright, :image, :provider, :description, :changesURL, :license, :licenseURL, :branding_plugin, :update_sites, :discovery_sites]
+    
+    eval(VARS.collect{|field| "attr_accessor :#{field}"}.join("\n"))
     
     # :nodoc:
     # When this module extends an object
@@ -120,61 +109,69 @@ PROPERTIES
     
   end
   
-  
+  #Marker module common to all feature packaging tasks.
+  #Tasks including this module are recognized internally as tasks packaging features.
+  module FeaturePackaging
+    
+  end
   
   class FeatureTask < ::Buildr::Packaging::Java::JarTask
-    
+    include FeaturePackaging
     attr_accessor :plugins
     
     attr_accessor :feature_xml
     attr_accessor :feature_properties
+    
+    FeatureWriter::VARS << :plugins
+    FeatureWriter::VARS << :feature_xml
+    FeatureWriter::VARS << :feature_properties
+    FeatureWriter::VARS << :unjarred
 
     def initialize(*args) #:nodoc:
       super
       @unjarred = {}
       @plugins = ArrayAddWithOptions.new(@unjarred)
+      
     end
     
     def generateFeature(project)
-      feature_id ||= project.id
-      version ||= project.version
-      
       mkpath File.join(project.base_dir, 'target')
-      resolved_plugins = {}
-      unless @plugins.nil? || @plugins.empty?
-        plugins.flatten.each do |plugin|
-          
-          artifact = case 
-            when plugin.is_a?(String)
-              Buildr::artifact(plugin)
-            when plugin.is_a?(Buildr::Project)
-              Buildr::artifact(plugin.package(:plugin))
-            else 
-              plugin
-            end
-          info = adaptPlugin(artifact)
-          info[:unjarred] = @unjarred[plugin]
-          resolved_plugins[info] = artifact
-        end
-      end
+      resolved_plugins = create_resolved_plugins
+      enhance(resolved_plugins.values)
       unless feature_xml
         File.open(File.join(project.base_dir, 'target', 'feature.xml'), 'w') do |f|
           f.write(writeFeatureXml(resolved_plugins.keys, feature_xml.nil? && feature_properties.nil? ))
         end
-        path("eclipse/features/#{project.id}_#{project.version}").include File.join(project.base_dir, 'target/feature.xml')
+        path("eclipse/features/#{feature_id}_#{project.version}").include File.join(project.base_dir, 'target', 'feature.xml')
       else
-        path("eclipse/features/#{project.id}_#{project.version}").include feature_xml
+        path("eclipse/features/#{feature_id}_#{project.version}").include feature_xml
       end
       unless feature_properties || feature_xml
         File.open(File.join(project.base_dir, 'target', 'feature.properties'), 'w') do |f|
           f.write(writeFeatureProperties())
         end
-        path("eclipse/features/#{project.id}_#{project.version}").include File.join(project.base_dir, 'target/feature.properties')
+        path("eclipse/features/#{feature_id}_#{project.version}").include File.join(project.base_dir, 'target', 'feature.properties')
       else
-        path("eclipse/features/#{project.id}_#{project.version}").include feature_properties if feature_properties
+        path("eclipse/features/#{feature_id}_#{project.version}").include feature_properties if feature_properties
       end
       
-      resolved_plugins.each_pair do |info, plugin|  
+      resolved_plugins.each_pair do |info, plugin| 
+        unless info[:manifest].nil?
+          cp plugin.to_s, project.path_to("target/#{plugin.id}_#{plugin.version}.jar")
+          plugin = project.path_to("target/#{plugin.id}_#{plugin.version}.jar")
+          ::Buildr::Packaging::Java::Manifest.update_manifest(plugin) {|manifest|
+            #applies to sources bundles only: if it was the runtime manifest, then remove it altogether:
+            unless manifest.main["Bundle-SymbolicName"].nil?
+              #there was a symbolic name: assume this manifest was the runtime one.
+              #we don't want OSGi to confuse the runtime jar with the sources.
+              #ideally we would want keep an archive of the original
+              #runtime manifest as for example MANIFEST.MF.source
+              manifest.main.clear
+            end
+            manifest.main.merge! info[:manifest]
+          }
+        end
+        
         if info[:unjarred]
           merge(plugin, :path => "eclipse/plugins/#{info[:id]}_#{info[:version]}")
         else
@@ -185,49 +182,75 @@ PROPERTIES
     
     protected
     
-    class ArrayAddWithOptions < Array
-      
-      def initialize(options_hash) 
-        @options_hash = options_hash
-      end
-      
-      def add_with_options(plugin, options = {:unjarred => false})
-        add(plugin)
-        @options_hash[plugin] = options[:unjarred] if options[:unjarred]
+    def create_resolved_plugins
+      resolved_plugins = {}
+      unless @plugins.nil? || @plugins.empty?
+        plugins.flatten.each do |plugin|
+          
+          artifact = case 
+            when plugin.is_a?(String)
+              Buildr::artifact(plugin)
+            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?
+          resolved_plugins[info] = artifact
+        end
       end
-      
-      alias :add :<<
-      alias :<< :add_with_options
-
+      resolved_plugins
     end
     
-    def adaptPlugin(plugin)
+    def adapt_plugin(plugin)
       name = nil
       size = nil
       version = nil
       group = nil
+      repackage = nil
+      sourceBundle = nil
       if plugin.is_a? Buildr::Project
-        plugin.package(:plugin).invoke #make sure it is present.
         size = File.size(plugin.package(:plugin).to_s)
         name = plugin.package(:plugin).manifest.main["Bundle-SymbolicName"]
         version = plugin.package(:plugin).manifest.main["Bundle-Version"]
-        group = plugin.group   
+        group = plugin.group
+        sourceBundle = plugin.package(:plugin).manifest.main["Eclipse-SourceBundle"]
       else
         plugin.invoke
+        if !File.exist?(plugin.to_s) and 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?
+          return nil
+        end
         Zip::ZipFile.open(plugin.to_s) do |zip|
           entry = zip.find_entry("META-INF/MANIFEST.MF")
           unless entry.nil?
             manifest = Manifest.read(zip.read("META-INF/MANIFEST.MF"))
-            bundle = ::OSGi::Bundle.fromManifest(manifest, plugin.to_s)
-            unless bundle.nil?
-              name = bundle.name
-              version = bundle.version
+            sourceBundle = manifest.first["Eclipse-SourceBundle"].keys.first.strip unless manifest.first["Eclipse-SourceBundle"].nil?
+            if !manifest.first["Bundle-SymbolicName"].nil?
+              bundle = ::OSGi::Bundle.fromManifest(manifest, plugin.to_s)
+              unless bundle.nil?
+                name = bundle.name
+                version = bundle.version
+              end
             end
           end
         end
         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?)
+        # 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)
+        manifest = ::OSGi::create_source_bundle_manifest(runtimeManifest)
+        repackage = {}
+        manifest.main.each {|key,value| repackage[key] = value }
+        name = repackage["Bundle-SymbolicName"].split(';').first
+        version = repackage["Bundle-Version"]
+      end
       if (name.nil? || version.nil?)
         raise "The dependency #{plugin} is not an Eclipse plugin: make sure the headers " +
           "Bundle-SymbolicName and Bundle-Version are present in the manifest" 
@@ -237,9 +260,85 @@ PROPERTIES
         size ||= 0
       end
       return {:id => name, :group => group, :version => version, 
-        :"download-size" => size, :"install-size" => size, :unpack => false}
+        :"download-size" => size, :"install-size" => size, :unpack => false, :manifest => repackage}
     end
+    
+    #returns the META-INF/MANIFEST.MF file for something that
+    #is either an artifact either a the package(:jar) of a buildr project.
+    def extraPackagedManifest(plugin)
+      if plugin.is_a? Buildr::Project
+        return plugin.package(:plugin).manifest
+      else #an artifact
+        plugin.invoke
+        javaManifest = ::Buildr::Packaging::Java::Manifest.from_zip(plugin.to_s)
+        hash = {} #need to make it a hash:
+        javaManifest.main.each {|key,value| hash[key] = value }
+        return hash
+      end
+    end
+    
   end
+  
+  class ArrayAddWithOptions < Array
+
+    def initialize(options_hash) 
+      @options_hash = options_hash
+    end
+
+    def add_with_options(*args)
+      plugin = args.shift
+      options = {}
+      while(!args.empty?)
+        option = args.shift
+        case
+        when option.is_a?(Hash)
+          options.merge!(option)
+        when option.is_a?(Symbol)
+          options.merge!({option => true})
+        else
+          raise "Impossible to find what this option means: #{option}"
+        end
+      end
+      add(plugin)
+      @options_hash[plugin] = options
+    end
+
+    alias :add :<<
+    alias :<< :add_with_options
+
+  end
+  
+  
+  module SDKFeatureEnabler
+    
+    def create_resolved_plugins
+      resolved_plugins = {}
+      unless @plugins.nil? || @plugins.empty?
+        plugins.flatten.each do |plugin|
+          
+          artifact = case 
+            when plugin.is_a?(String)
+              Buildr::artifact(plugin)
+            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)
+          if !info.nil? 
+            info[:unjarred] = @unjarred[plugin][:unjarred] unless @unjarred[plugin].nil?
+            resolved_plugins[info] = artifact
+          end
+        end
+      end
+      resolved_plugins
+    end
+    
+    
+  end
+
+  
 
   # Methods added to project to package a project as a feature
   #
@@ -247,17 +346,53 @@ PROPERTIES
     include Extension
 
     protected
+    
+    # returns true if the project defines at least one feature packaging.
+    # We keep this method protected and we will call it using send.
+    def is_packaging_feature()
+      packages.each {|package| return true if package.is_a?(::Buildr4OSGi::FeaturePackaging)}
+      false
+    end
 
     def package_as_feature(file_name)
       task = FeatureTask.define_task(file_name)
       task.extend FeatureWriter
-      task.enhance do |feature|
-        feature.generateFeature(project)
+      task.feature_id ||= project.id
+      task.version ||= project.version
+      task.enhance do |featureTask|
+        featureTask.generateFeature(project)
       end
+      task
     end
     
     def package_as_feature_spec(spec) #:nodoc:
-      spec.merge(:type=>:jar, :classifier=>'feature')
+      spec.merge(:type=>:zip, :id => name.split(":").last)
+    end
+    
+    def package_as_SDK_feature(file_name) #:nodoc:
+      return package_as_sources_before_SDK_feature(file_name) unless is_packaging_feature
+      featurePackage = packages.select {|package| package.is_a?(::Buildr4OSGi::FeaturePackaging)}.first.dup
+      sdkPackage = FeatureTask.define_task(file_name)
+      sdkPackage.enhance do |featureTask|
+        featureTask.generateFeature(project)
+      end
+      sdkPackage.extend FeatureWriter
+      sdkPackage.extend SDKFeatureEnabler
+      
+      FeatureWriter::VARS.each do |ivar|
+        value = featurePackage.instance_variable_get("@#{ivar}")
+        new_value = value.clone rescue value
+        sdkPackage.instance_variable_set("@#{ivar}", new_value)
+      end
+      
+      sdkPackage.feature_id += ".sources"
+      sdkPackage
+    end
+    
+    def package_as_SDK_feature_spec(spec) #:nodoc:
+      spec = package_as_sources_spec_before_SDK_feature(spec)
+      spec.merge!(:type=>:zip, :id => name.split(":").last, :classifier => "sources") if is_packaging_feature
+      spec
     end
   end
 
@@ -267,5 +402,11 @@ end
 module Buildr #:nodoc:
   class Project #:nodoc:
     include Buildr4OSGi::ActAsFeature
+    
+    alias :package_as_sources_before_SDK_feature :package_as_sources
+    alias :package_as_sources :package_as_SDK_feature
+    
+    alias :package_as_sources_spec_before_SDK_feature :package_as_sources_spec
+    alias :package_as_sources_spec :package_as_SDK_feature_spec
   end
 end

data/lib/buildr4osgi/osgi/bundle.rb

@@ -14,8 +14,6 @@
 # the License.
 
 module OSGi #:nodoc:
-
-  OSGI_GROUP_ID = "osgi"
   
   # :nodoc:
   # Module extending projects
@@ -31,7 +29,7 @@ module OSGi #:nodoc:
     #
     def matches(criteria = {:name => "", :version => "", :exports_package => "", :fragment_for => ""})
       if File.exists?(File.join(base_dir, "META-INF", "MANIFEST.MF"))
-        manifest = ::Buildr::Packaging::Java::Manifest.new(File.join(base_dir, "META-INF", "MANIFEST.MF"))
+        manifest = ::Buildr::Packaging::Java::Manifest.new(File.read(File.join(base_dir, "META-INF", "MANIFEST.MF")))
       end
       manifest ||= ::Buildr::Packaging::Java::Manifest.new()
       project.packages.select {|package| package.is_a? ::OSGi::BundlePackaging}.each {|p|
@@ -92,7 +90,7 @@ module OSGi #:nodoc:
     # Creates a bundle out of a project, using the manifest defined in its bundle package
     # and the MANIFEST.MF file present in the project if any.
     def self.fromProject(project)
-      packaging = project.packages.select {|package| package.is_a?(::OSGi::BundlePackaging)}
+      packaging = project.packages.select {|package| package.is_a?(BundlePackaging)}
       raise "More than one bundle packaging is defined over the project #{project.id}, see BOSGI-16." if packaging.size > 1
       return nil if packaging.empty?
       manifest = ::Buildr::Packaging::Java::Manifest.new(File.exists?("META-INF/MANIFEST.MF") ? File.read("META-INF/MANIFEST.MF") : nil) 
@@ -172,7 +170,7 @@ module OSGi #:nodoc:
       @optional = args[:optional]
       @start_level = 4
       @type = "jar" #it's always a jar, even if it is a directory: we will jar it for Maven.
-      @group = OSGI_GROUP_ID
+      @group = GroupMatcher.instance.group(name)
     end
 
     
@@ -183,7 +181,7 @@ module OSGi #:nodoc:
       # Collect the bundle projects, duplicate them so no changes can be applied to them
       # and extend them with the BundleProjectMatcher module
       
-      b_projects = OSGi::BundleProjects::bundle_projects.select {|p|
+      b_projects = BundleProjects::bundle_projects.select {|p|
         unless p == project
           p.extend BundleProjectMatcher
           p.matches(:name => name, :version => version)
@@ -227,7 +225,7 @@ module OSGi #:nodoc:
       when 0 then nil
       when 1 then bundles.first
       else
-        OSGi::BundleResolvingStrategies.send(project.osgi.options.bundle_resolving_strategy, bundles)
+        BundleResolvingStrategies.send(project.osgi.options.bundle_resolving_strategy, bundles)
       end
       if bundle.nil?
         warn "Could not resolve bundle for #{self.to_s}" 

data/lib/buildr4osgi/osgi/bundle_package.rb

@@ -35,9 +35,9 @@ module OSGi #:nodoc:
     def resolve_matching_artifacts(project)
       # Collect the bundle projects
       # and extend them with the BundleProjectMatcher module
-      b_projects = OSGi::BundleProjects::bundle_projects.select {|p|
+      b_projects = BundleProjects::bundle_projects.select {|p|
         unless p == project
-          p.extend OSGi::BundleProjectMatcher 
+          p.extend BundleProjectMatcher 
           p.matches(:exports_package => name, :version => version)
         end
       }

data/lib/buildr4osgi/osgi/container.rb

@@ -136,5 +136,10 @@ module OSGi #:nodoc:
       end
       selected
     end
+    
+    def ==(other)
+      false unless other.is_a? Container
+      return location == other.location
+    end
   end
 end

data/lib/buildr4osgi/osgi/dependencies.rb

@@ -0,0 +1,91 @@
+# 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 OSGi
+#
+# A class to read dependencies.yml, and get a flat array of projects and dependencies for a project.
+#
+class Dependencies
+  
+  attr_accessor :dependencies, :projects
+  
+  def initialize(project = nil)
+    @project = project
+  end
+    
+  def read() 
+    base_dir = find_root(@project).base_dir
+    @dependencies = []
+    @projects = []
+    @deps_yml = {}
+    return unless File.exists? File.join(base_dir, "dependencies.yml")
+    @deps_yml =YAML.load(File.read(File.join(base_dir, "dependencies.yml")))
+    return if @deps_yml[@project.name].nil? || @deps_yml[@project.name]["dependencies"].nil?
+    _read(@project, false)
+    @dependencies = @dependencies.flatten.compact.uniq
+    return @dependencies, @projects
+  end
+  
+  def write(projects)
+    base_dir = find_root(@project).base_dir
+    written_dependencies = YAML.load(File.read(File.join(base_dir, "dependencies.yml"))) if File.exists? File.join(base_dir, "dependencies.yml")
+    written_dependencies ||= {}
+    written_dependencies.extend SortedHash
+    projects.each {|p|
+      p = p.name if p.is_a?(Project) 
+      written_dependencies[p] ||= {}
+      written_dependencies[p].extend SortedHash
+      written_dependencies[p]["dependencies"] ||= []
+      written_dependencies[p]["projects"] ||= []
+      yield written_dependencies, p
+      written_dependencies[p]["dependencies"].sort!
+      written_dependencies[p]["projects"].sort!
+    }
+    Buildr::write File.join(base_dir, "dependencies.yml"), written_dependencies.to_yaml
+  end
+  
+  private
+  
+  def _read(project, add_project = true)
+    projects << project if add_project
+    return unless @deps_yml[project.name] && @deps_yml[project.name]["dependencies"]
+    @dependencies |= @deps_yml[project.name]["dependencies"]
+    @deps_yml[project.name]["projects"].each {|p| subp = Buildr::project(p) ; _read(subp) unless (projects.include?(subp) || subp == @project)}
+  end
+  
+  def find_root(project)
+    project.parent.nil? ? project : find_root(project.parent)
+  end
+  
+  # Copy/pasted from here: http://snippets.dzone.com/posts/show/5811
+  # no author information though.
+  module SortedHash
+    
+    # Replacing the to_yaml function so it'll serialize hashes sorted (by their keys)
+    #
+    # Original function is in /usr/lib/ruby/1.8/yaml/rubytypes.rb
+    def to_yaml( opts = {} )
+      YAML::quick_emit( object_id, opts ) do |out|
+        out.map( taguri, to_yaml_style ) do |map|
+          sort.each do |k, v|   # <-- here's my addition (the 'sort')
+            map.add( k, v )
+          end
+        end
+      end
+    end
+  end
+end
+
+end

data/lib/buildr4osgi/osgi/library_extension.rb

@@ -53,7 +53,7 @@ module Buildr4OSGi #:nodoc:
             manifest = project.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.id # if it was resetted to nil, we force the id to be added back.
+          manifest["Bundle-SymbolicName"] ||= project.id.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].compact
@@ -136,13 +136,15 @@ module Buildr4OSGi #:nodoc:
               lib.invoke # make sure the artifact is present.
               Zip::ZipFile.foreach(lib.to_s) {|entry| entries << entry.name.sub(/(.*)\\/.*.class$/, '\\1').gsub(/\\//, '.') if /.*\\.class$/.match(entry.name)}
             }
-            jar.with :manifest => { 
-              "Export-Package" => entries.uniq.sort.join(","),
+            lib_manifest = { 
               "Bundle-Version" => "#{version}",
               "Bundle-SymbolicName" => project.name,
               "Bundle-Name" => names.join(", "),
               "Bundle-Vendor" => "Intalio, Inc."
-            }.merge(#{options[:manifest].inspect})
+            }
+            lib_manifest["Export-Package"] = entries.uniq.sort.join(",") unless entries.empty?
+            lib_manifest["Bundle-ManifestVersion"] = "2"
+            jar.with :manifest => lib_manifest.merge(#{options[:manifest].inspect})
             
             
           }