buildr4osgi 0.9.0

data/lib/buildr4osgi/osgi/bundle_package.rb

@@ -0,0 +1,80 @@
+# 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 #:nodoc:
+
+  # A class to represent an OSGi bundle package.
+  # Created from the Import-Package or Provide-Package (Export-Package) header.
+  #
+  class BundlePackage
+    attr_accessor :name, :version, :bundles, :imports, :is_export
+    
+    def initialize(name, version, args = {}) #:nodoc:
+      @name= name
+      @is_export = args[:is_export]
+      @version = (is_export ? version.gsub(/\"/, '') : VersionRange.parse(version, true)) if version
+      @bundles = args[:bundles] || []
+      @imports = args[:imports] || []
+    end
+
+    #
+    # Resolves the matching artifacts associated with the project.
+    #
+    def resolve_matching_artifacts(project)
+      # Collect the bundle projects
+      # and extend them with the BundleProjectMatcher module
+      b_projects = OSGi::BundleProjects::bundle_projects.select {|p|
+        unless p == project
+          p.extend OSGi::BundleProjectMatcher 
+          p.matches(:exports_package => name, :version => version)
+        end
+      }
+      return b_projects unless b_projects.empty?
+      
+      resolved = project.osgi.registry.resolved_containers.collect {|i| i.find(:exports_package => name, :version => version)}
+      resolved.flatten.compact.collect{|b| b.dup}
+    end
+    
+    # Resolves the bundles that export this package.
+    #
+    def resolve(project, bundles = resolve_matching_artifacts(project))
+      bundles = case bundles.size
+      when 0 then []
+      when 1 then bundles
+      else
+        bundles = OSGi::PackageResolvingStrategies.send(project.osgi.options.package_resolving_strategy, name, bundles)
+      end
+      warn "No bundles found exporting the package #{name}; version=#{version}" if (bundles.empty?)
+      bundles
+      
+    end
+    
+    def to_s #:nodoc:
+      "Package #{name}; version #{version}"
+    end
+    
+    # We just test the name and version as we want to be able to see if an unresolved package and a resolved one represent the same
+    # bundle package.
+    def ==(other)
+      return false unless other.is_a? BundlePackage
+      eql = name == other.name
+      eql |= version.nil? ? other.version.nil? : version == other.version
+      eql
+    end
+    
+    alias :eql? :==
+  end
+  
+end

data/lib/buildr4osgi/osgi/container.rb

@@ -0,0 +1,140 @@
+# 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 "manifest"
+
+module OSGi #:nodoc:
+  
+  # This class represents an OSGi container.
+  # It contains the bundles, fragments, and the location of the OSGi container.
+  # A typical OSGi container is an Eclipse instance.
+  #
+  class Container
+
+    # bundles: the bundles of the eclipse instance loaded on startup
+    # location: the location of the Eclipse instance
+    attr_reader :bundles, :fragments, :location
+
+    # Default constructor for a Container
+    # 
+    # location: the location of the Eclipse instance
+    # plugin_locations, default value is ["dropins", "plugins"] 
+    # create_bundle_info, default value is true
+    def initialize(location, plugin_locations = ["dropins", "plugins"])
+      @location = location
+      @bundles = []
+      @fragments = []
+      plugin_locations.each do |p_loc|
+        p_loc_complete = File.join(@location, p_loc)
+        warn "Folder #{p_loc_complete} not found!" if !File.exists? p_loc_complete 
+        parse(p_loc_complete) if File.exists? p_loc_complete
+      end
+    end
+
+    # Parses the directory and grabs the plugins, adding the created bundle objects to @bundles.
+    def parse(dir)
+      Dir.open(dir) do |plugins|
+        plugins.entries.each do |plugin|
+          absolute_plugin_path = "#{plugins.path}#{File::SEPARATOR}#{plugin}"
+          if (/.*\.jar$/.match(plugin)) 
+            zipfile = Zip::ZipFile.open(absolute_plugin_path)
+            entry =  zipfile.find_entry("META-INF/MANIFEST.MF")
+            if (entry != nil)
+              manifest = Manifest.read(zipfile.read("META-INF/MANIFEST.MF"))
+              bundle = Bundle.fromManifest(manifest, absolute_plugin_path) 
+              if bundle.nil?
+              elsif bundle.fragment? 
+                @fragments << bundle
+              else
+                @bundles << bundle
+              end
+            end
+            zipfile.close
+          else
+            # take care of the folder
+            if (File.directory?(absolute_plugin_path) && !(plugin == "." || plugin == ".."))
+              if (!File.exists? ["#{absolute_plugin_path}", "META-INF", "MANIFEST.MF"].join(File::SEPARATOR))
+                #recursive approach: we have a folder wih no MANIFEST.MF, we should look into it.
+                parse(absolute_plugin_path)
+              else
+                next if File.exists? "#{absolute_plugin_path}/feature.xml" # avoid parsing features.
+                begin
+                  manifest = Manifest.read((file = File.open("#{absolute_plugin_path}/META-INF/MANIFEST.MF")).read)
+                rescue
+                  file.close
+                end
+                bundle = Bundle.fromManifest(manifest, absolute_plugin_path)
+                if bundle.nil?
+                elsif bundle.fragment?
+                  @fragments << bundle
+                else
+                  @bundles << bundle
+                end
+              end
+            end
+          end
+        end
+      end
+      @bundles = @bundles.compact
+      @fragments = @fragments.compact
+    end
+    
+    # Return the list of bundles and fragments that match the criteria passed as arguments
+    # Possible criterias:
+    #  name: the name of the bundle
+    #  version: the version of the bundle
+    #  exports_package: a package exported by the bundle
+    def find(criteria = {})
+      selected = bundles + fragments
+      
+      if (criteria[:name])
+        selected = selected.select {|b| b.name == criteria[:name]}
+      end
+      if (criteria[:exports_package])
+        selected = selected.select {|b| 
+          !(b.exported_packages.select {|package| 
+            package.name == criteria[:exports_package] &&
+            (criteria[:version].nil? || criteria[:version].in_range(package.version))
+          }.empty?)
+        }
+      else
+        if (criteria[:version])
+          if criteria[:version].is_a?(VersionRange)
+            selected = selected.select {|b| criteria[:version].in_range(b.version)}
+          else
+            selected = selected.select {|b| b.version == criteria[:version]}
+          end
+        end
+      end
+      selected
+    end
+    
+    # Return the list of fragments that match the criteria passed as arguments
+    # Possible criterias:
+    #  host: the name of the host bundle
+    #  version: the version of the bundle
+    #
+    def find_fragments(criteria = {:host => "", :version => ""})
+      selected = fragments
+      if (criteria[:host])
+        selected = selected.select {|b| b.fragment.name == criteria[:host]}
+      end
+      if (criteria[:version])
+        selected = selected.select {|b| b.fragment.version == criteria[:version]}
+      end
+      selected
+    end
+  end
+end

data/lib/buildr4osgi/osgi/library_extension.rb

@@ -0,0 +1,174 @@
+# 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 Buildr4OSGi #:nodoc:
+  
+  # A module dedicated to building jars into OSGi bundles to serve as libraries.
+  #
+  module BuildLibraries
+    
+    # A small extension contributed to projects that are library projects
+    # so we can walk the libraries we pass to them.
+    #
+    module LibraryProject
+      
+      #
+      # Walks the libraries passed in parameter, passing each library to the block.
+      #
+      def walk_libs(lib, &block)
+        if (lib.is_a?(Struct) || lib.is_a?(Array))
+          lib.each {|structdep|
+            walk_libs(structdep, &block)
+          }
+          return
+        end
+        lib_artifact = case 
+        when lib.is_a?(Artifact)  then lib
+        when lib.is_a?(String) then Buildr::artifact(lib)
+        else
+          raise "Don't know how to interpret lib #{lib}"
+        end
+        block.call(lib_artifact)
+      end
+      
+      def package_as_library_project(file_name)
+        ::OSGi::BundleTask.define_task(file_name).tap do |plugin|
+
+          manifest_location = File.join(project.base_dir, "META-INF", "MANIFEST.MF")
+          manifest = project.manifest
+          if File.exists?(manifest_location)
+            read_m = ::Buildr::Packaging::Java::Manifest.parse(File.read(manifest_location)).main
+            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.
+
+          plugin.with :manifest=> manifest, :meta_inf=>meta_inf
+          plugin.with [compile.target, resources.target].compact
+        end
+
+      end
+
+      def package_as_library_project_spec(spec) #:nodoc:
+        spec.merge(:type=>:jar)
+      end
+    end
+
+    # Monkey-patching the artifact so that it warns instead of failing
+    # when it cannot download the source
+    module SkipSourceDownload
+      def fail_download(remote_uris)
+        warn "Failed to download the sources #{to_spec}, tried the following repositories:\n#{remote_uris.join("\n")}"
+      end
+    end
+    
+    #
+    # Returns the main section of the manifest of the bundle.
+    #
+    def manifest(lib)
+      artifact = Buildr.artifact(lib)
+      artifact.invoke # download it if needed.
+      
+      m = nil
+      Zip::ZipFile.open(artifact.to_s) do |zip|
+        raise "No manifest contained in #{lib}" if zip.find_entry("META-INF/MANIFEST.MF").nil?
+        m = zip.read("META-INF/MANIFEST.MF")
+      end
+      manifest = ::Buildr::Packaging::Java::Manifest.new(m)
+      manifest.main
+    end
+  end
+  
+  module LibraryProjectExtension
+    include Extension
+    
+    #
+    #
+    # Defines a project as the merge of the dependencies.
+    # group: the group of the project to define
+    # name: the name of the project to define
+    # version: the version of the project to define
+    #
+    def library_project(dependencies, group, name, version, options = {:exclude => ["META-INF/MANIFEST.MF"], :include => [], :manifest => {}})
+      options[:manifest] ||= {} 
+      deps_as_str = []
+      # We create an object and we extend with the module so we can get access to the walk_libs method.
+      walker = Object.new 
+      walker.extend Buildr4OSGi::BuildLibraries::LibraryProject
+      walker.walk_libs(dependencies) {|lib|
+        deps_as_str << lib.to_spec
+      }
+      deps_as_str = deps_as_str.flatten.inspect
+      exclusion = options[:exclude].collect {|exclusion| ".exclude(#{exclusion.inspect})"}.join if options[:exclude]
+      inclusion = options[:include].collect {|inclusion| ".include(#{inclusion.inspect})"}.join if options[:include]
+      exclusion ||= ""
+      inclusion ||= ""
+      eval %{
+        desc "#{name}"
+        define "#{name}" do
+          project.extend Buildr4OSGi::LibraryProject
+          #{"project.version = \"#{version}\"" if version}
+          #{"project.group = \"#{group}\"" if group}
+
+          package(:library_project).tap {|jar|
+            jar.enhance {|task|
+              walk_libs(#{deps_as_str}) {|lib|
+                lib.invoke # make sure the artifact is present.
+                task.merge(lib)#{exclusion}#{inclusion}
+              }
+            }
+            entries = []
+            names = []
+            walk_libs(#{deps_as_str}) {|lib|
+              names << lib.to_spec 
+              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(","),
+              "Bundle-Version" => "#{version}",
+              "Bundle-SymbolicName" => project.name,
+              "Bundle-Name" => names.join(", "),
+              "Bundle-Vendor" => "Intalio, Inc."
+            }.merge(#{options[:manifest].inspect})
+            
+            
+          }
+          package(:sources).tap do |task|
+            task.enhance do
+              walk_libs(#{deps_as_str}) {|lib|
+                lib_src = Buildr::artifact(lib.to_hash.merge(:classifier => "sources"))
+                lib_src.extend Buildr4OSGi::SkipSourceDownload
+                lib_src.invoke # make sure the artifact is present.
+                
+                task.merge(lib_src)#{exclusion}#{inclusion} if File.exist?(lib_src.to_s)
+              }
+            end
+          end
+        end
+      }
+    end
+  end
+end
+
+module Buildr4OSGi
+  include Buildr4OSGi::BuildLibraries
+  include Buildr4OSGi::LibraryProjectExtension
+end
+
+class Buildr::Project
+  include Buildr4OSGi::LibraryProjectExtension
+end
+

data/lib/buildr4osgi/osgi/packaging.rb

@@ -0,0 +1,129 @@
+# 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
+  
+  #:nodoc:
+  # This module is used to identify the packaging task
+  # that represent a bundle packaging.
+  #
+  # Tasks representing bundle packaging should include this module
+  # to be used by the buildr system properly.
+  #
+  module BundlePackaging
+    
+  end
+    
+  
+  #
+  # The task to package a project
+  # as a OSGi bundle.
+  #
+  class BundleTask < ::Buildr::Packaging::Java::JarTask
+    include BundlePackaging
+    # Artifacts to include under /lib.
+    attr_accessor :libs
+    
+    def initialize(*args) #:nodoc:
+      super
+      @libs = []
+      prepare do
+        unless @libs.nil? || @libs.empty?
+          artifacts = Buildr.artifacts(@libs)
+          path('lib').include artifacts
+          manifest["Bundle-Classpath"] = [".", artifacts.collect {|a| "lib/#{File.basename(a.to_s)}"}].flatten.join(",")
+          
+        end
+      end
+    end
+    
+  end
+  
+  module ActAsOSGiBundle
+    include Extension
+    
+    protected
+    
+    # returns true if the project defines at least one bundle packaging.
+    # We keep this method protected and we will call it using send.
+    def is_packaging_osgi_bundle()
+      packages.each {|package| return true if package.is_a?(::OSGi::BundlePackaging)}
+      return false
+    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
+        # of a complex project.
+        # 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")
+        
+        manifest_location = File.join(project.base_dir, "META-INF", "MANIFEST.MF")
+        manifest = project.manifest
+        if File.exists?(manifest_location)
+          read_m = ::Buildr::Packaging::Java::Manifest.parse(File.read(manifest_location)).main
+          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.
+        
+        plugin.with :manifest=> manifest, :meta_inf=>meta_inf
+        plugin.with [compile.target, resources.target, p_r.target].compact
+      end
+    end
+    
+    def package_as_bundle_spec(spec) #:nodoc:
+      spec.merge(:type=>:jar)
+    end
+    
+    before_define do |project|
+      project.manifest["Bundle-SymbolicName"] = project.id
+      project.manifest["Bundle-Name"] = project.comment || project.name
+      project.manifest["Bundle-Version"] = project.version
+    end
+  end
+  
+  module BundleProjects #:nodoc
+    
+    # Returns the projects
+    # that define an OSGi bundle packaging.
+    #
+    def bundle_projects
+      
+      Buildr.projects.flatten.select {|project|
+        project.send :is_packaging_osgi_bundle
+      }
+    end
+    
+    module_function :bundle_projects
+  end
+  
+end
+
+class Buildr::Project
+  include OSGi::ActAsOSGiBundle
+end
+
+module Buildr4OSGi
+  include OSGi::BundleProjects
+end