autoproj 1.9.6 → 1.9.7.rc1

data/lib/autoproj/metapackage.rb

@@ -0,0 +1,51 @@
+module Autoproj
+    # A set of packages that can be referred to by name
+    class Metapackage
+        # The metapackage name
+        attr_reader :name
+        # The packages listed in this metapackage
+        attr_reader :packages
+        # The normal dependency handling behaviour is to generate an error if a
+        # metapackage is selected for the build but some of its dependencies
+        # cannot be built. This modifies the behaviour to simply ignore the
+        # problematic packages.
+        attr_writer :weak_dependencies
+
+        # @return [Boolean] whether the dependencies from this metapackage are
+        #   weak or not
+        # @see #weak_dependencies
+        def weak_dependencies?
+            !!@weak_dependencies
+        end
+
+        def initialize(name)
+            @name = name
+            @packages = []
+            @weak_dependencies = false
+        end
+
+        # Adds a package to this metapackage
+        #
+        # @param [Autobuild::Package] pkg
+        def add(pkg)
+            @packages << pkg
+        end
+
+        # Lists the packages contained in this metapackage
+        #
+        # @yieldparam [Autobuild::Package] pkg
+        def each_package(&block)
+            @packages.each(&block)
+        end
+
+        # Tests if the given package is included in this metapackage
+        #
+        # @param [String,#name] pkg the package or package name
+        def include?(pkg)
+            if !pkg.respond_to?(:to_str)
+                pkg = pkg.name
+            end
+            @packages.any? { |p| p.name == pkg }
+        end
+    end
+end

data/lib/autoproj/options.rb

@@ -1,6 +1,20 @@
 module Autoproj
     class InputError < RuntimeError; end
 
+    class << self
+        # Programatically overriden autoproj options
+        #
+        # @see override_option
+        attr_reader :option_overrides
+    end
+    @option_overrides = Hash.new
+
+    # Programatically override a user-selected option without changing the
+    # configuration file
+    def self.override_option(option_name, value)
+        @option_overrides[option_name] = value
+    end
+
     class BuildOption
         attr_reader :name
         attr_reader :type

data/lib/autoproj/osdeps.rb

@@ -88,11 +88,11 @@ module Autoproj
                         end
                     end
                 end
-
-
+                
+                sudo = Autobuild.tool_in_path('sudo')
                 Tempfile.open('osdeps_sh') do |io|
                     io.puts "#! /bin/bash"
-                    io.puts GAIN_ROOT_ACCESS
+                    io.puts GAIN_ROOT_ACCESS % [sudo]
                     io.write script
                     io.flush
                     Autobuild::Subprocess.run 'autoproj', 'osdeps', '/bin/bash', io.path
@@ -102,7 +102,7 @@ module Autoproj
             GAIN_ROOT_ACCESS = <<-EOSCRIPT
 # Gain root access using sudo
 if test `id -u` != "0"; then
-    exec sudo /bin/bash $0 "$@"
+    exec %s /bin/bash $0 "$@"
 
 fi
             EOSCRIPT
@@ -214,6 +214,15 @@ fi
             end
         end
 
+        #Package manger for OpenSuse and Suse (untested)
+        class ZypperManager < ShellScriptManager
+            def initialize
+                super(['zypper'], true,
+                        "zypper -n install '%s'",
+                        "zypper -n install '%s'")
+            end
+        end
+
         # Package manager interface for systems that use yum
         class YumManager < ShellScriptManager
             def initialize
@@ -389,10 +398,18 @@ fi
                 end
             end
 
+            def reinstall
+                base_cmdline = [Autobuild.tool_in_path('ruby'), '-S', Autobuild.tool('gem')]
+                Autobuild::Subprocess.run 'autoproj', 'osdeps', 'reinstall', *base_cmdline,
+                    'clean'
+                Autobuild::Subprocess.run 'autoproj', 'osdeps', 'reinstall', *base_cmdline,
+                    'pristine', '--all', '--extensions'
+            end
+
             def install(gems)
                 guess_gem_program
 
-                base_cmdline = [Autobuild.tool('gem'), 'install']
+                base_cmdline = [Autobuild.tool_in_path('ruby'), '-S', Autobuild.tool('gem'), 'install']
                 if !GemManager.with_doc
                     base_cmdline << '--no-rdoc' << '--no-ri'
                 end
@@ -690,6 +707,7 @@ fi
             PackageManagers::PacmanManager,
             PackageManagers::YumManager,
             PackageManagers::PortManager,
+            PackageManagers::ZypperManager,
             PackageManagers::PipManager]
         OS_PACKAGE_HANDLERS = {
             'debian' => 'apt-dpkg',
@@ -697,7 +715,8 @@ fi
             'arch' => 'pacman',
             'manjarolinux' => 'pacman',
             'fedora' => 'yum',
-            'darwin' => 'port'
+            'darwin' => 'port',
+            'opensuse' => 'zypper'
         }
 
         # The information contained in the OSdeps files, as a hash
@@ -888,6 +907,8 @@ fi
                         @operating_system = [[lsb_name, "debian"], lsb_versions]
                     elsif lsb_name != 'arch' && File.exists?("/etc/arch-release")
                         @operating_system = [[lsb_name, "arch"], lsb_versions]
+                    elsif lsb_name != 'opensuse' && File.exists?("/etc/SuSE-release")
+                        @operating_system = [[lsb_name, "opensuse"], lsb_versions]
                     elsif lsb_name != 'debian'
                         # Debian unstable cannot be detected with lsb_release,
                         # so debian has its own detection logic
@@ -925,6 +946,11 @@ fi
                         [['darwin'], [version.strip]]
                     elsif Autobuild.windows?
                         [['windows'], []]
+                    elsif File.exists?('/etc/SuSE-release')
+                        version = File.read('/etc/SuSE-release').strip
+                        version =~/.*VERSION\s+=\s+([^\s]+)/
+                        version = $1
+                        [['opensuse'], [version.strip]]
                     end
             end
 
@@ -1466,8 +1492,18 @@ So, what do you want ? (all, none or a comma-separated list of: os gem pip)
         # The set of packages that have already been installed
         attr_reader :installed_packages
 
-        # Requests the installation of the given set of packages
-        def install(packages, options = Hash.new)
+        # Set up the registered package handlers according to the specified osdeps mode
+        #
+        # It enables/disables package handlers based on either the value
+        # returned by {#osdeps_mode} or the value passed as option (the latter
+        # takes precedence). Moreover, sets the handler's silent flag using
+        # {#silent?}
+        #
+        # @option options [Array<String>] the package handlers that should be
+        #   enabled. The default value is returned by {#osdeps_mode}
+        # @return [Array<PackageManagers::Manager>] the set of enabled package
+        #   managers
+        def setup_package_handlers(options = Hash.new)
             options =
                 if Kernel.respond_to?(:validate_options)
                     Kernel.validate_options options, :osdeps_mode => osdeps_mode
@@ -1495,10 +1531,26 @@ So, what do you want ? (all, none or a comma-separated list of: os gem pip)
                 v.silent = self.silent?
             end
 
+            enabled_handlers = []
+            if os_package_handler.enabled?
+                enabled_handlers << os_package_handler
+            end
+            package_handlers.each_value do |v|
+                if v.enabled?
+                    enabled_handlers << v
+                end
+            end
+            enabled_handlers
+        end
+
+        # Requests the installation of the given set of packages
+        def install(packages, options = Hash.new)
             # Remove the set of packages that have already been installed 
             packages = packages.to_set - installed_packages
             return false if packages.empty?
 
+            setup_package_handlers(options)
+
             packages = resolve_os_dependencies(packages)
             packages = packages.map do |handler, list|
                 if filter_uptodate_packages? && handler.respond_to?(:filter_uptodate_packages)

data/lib/autoproj/package_definition.rb

@@ -0,0 +1,58 @@
+module Autoproj
+    # Autoproj-specific information about a package definition
+    #
+    # This stores the information that goes in addition to the autobuild package
+    # definitions
+    class PackageDefinition
+        # @return [Autobuild::Package] the autobuild package definitins
+        attr_reader :autobuild
+        # @return [Array<#call>] the set of blocks that should be called to
+        #   prepare the package. These are called before any operation has been
+        #   performed on the package iself.
+        attr_reader :user_blocks
+        # @return [PackageSet] the package set that defined this package
+        attr_reader :package_set
+        # @return [String] path to the file that contains this package's
+        #   definition
+        attr_reader :file
+        # Whether this package is completely setup
+        #
+        # If the package is set up, its importer as well as all target
+        # directories are properly set, and all {user_blocks} have been called.
+        def setup?; !!@setup end
+
+        # Sets the {setup?} flag
+        attr_writer :setup
+
+        # @return [VCSDefinition] the version control information associated
+        #   with this package
+        attr_accessor :vcs
+
+        def initialize(autobuild, package_set, file)
+            @autobuild, @package_set, @file =
+                autobuild, package_set, file
+            @user_blocks = []
+        end
+
+        # The package name
+        # @return [String]
+        def name
+            autobuild.name
+        end
+
+        # Registers a setup block
+        #
+        # The block will be called when the setup phase is finished, or
+        # immediately if it is already finished (i.e. if {setup?} returns true)
+        #
+        # @param [#call] block the block that should be registered
+        # @yieldparam [Autobuild::Package] pkg the autobuild package object
+        # @see {user_blocks}
+        def add_setup_block(block)
+            user_blocks << block
+            if setup?
+                block.call(autobuild)
+            end
+        end
+    end
+end

data/lib/autoproj/package_manifest.rb

@@ -0,0 +1,155 @@
+module Autoproj
+    # Access to the information contained in a package's manifest.xml file
+    #
+    # Use PackageManifest.load to create
+    class PackageManifest
+        # Load a manifest.xml file and returns the corresponding
+        # PackageManifest object
+        def self.load(package, file)
+            doc =
+                begin REXML::Document.new(File.read(file))
+                rescue REXML::ParseException => e
+                    raise Autobuild::PackageException.new(package.name, 'prepare'), "invalid #{file}: #{e.message}"
+                end
+
+            PackageManifest.new(package, doc)
+        end
+
+        # The Autobuild::Package instance this manifest applies on
+        attr_reader :package
+        # The raw XML data as a Nokogiri document
+        attr_reader :xml
+
+        # The list of tags defined for this package
+        #
+        # Tags are defined as multiple <tags></tags> blocks, each of which can
+        # contain multiple comma-separated tags 
+        def tags
+            result = []
+            xml.elements.each('package/tags') do |node|
+                result.concat((node.text || "").strip.split(','))
+            end
+            result
+        end
+
+        def documentation
+            xml.elements.each('package/description') do |node|
+                doc = (node.text || "").strip
+                if !doc.empty?
+                    return doc
+                end
+            end
+            return short_documentation
+        end
+
+        def short_documentation
+            xml.elements.each('package/description') do |node|
+                doc = node.attributes['brief']
+                if doc
+                    doc = doc.to_s.strip
+                end
+                if doc && !doc.empty?
+                    return doc.to_s
+                end
+            end
+            "no documentation available for #{package.name} in its manifest.xml file"
+        end
+
+        def initialize(package, doc = REXML::Document.new)
+            @package = package
+            @xml = doc
+        end
+
+        def each_dependency(&block)
+            if block_given?
+                each_os_dependency(&block)
+                each_package_dependency(&block)
+            else
+                enum_for(:each_dependency, &block)
+            end
+        end
+
+        def each_os_dependency
+            if block_given?
+                xml.elements.each('package/rosdep') do |node|
+                    yield(node.attributes['name'], false)
+                end
+                package.os_packages.each do |name|
+                    yield(name, false)
+                end
+            else
+                enum_for :each_os_dependency
+            end
+        end
+
+        def each_package_dependency
+            if block_given?
+                depend_nodes = xml.elements.to_a('package/depend') +
+                    xml.elements.to_a('package/depend_optional')
+
+                depend_nodes.each do |node|
+                    dependency = node.attributes['package']
+                    optional = (node.attributes['optional'].to_s == '1' || node.name == "depend_optional")
+
+                    if dependency
+                        yield(dependency, optional)
+                    else
+                        raise ConfigError.new, "manifest of #{package.name} has a <depend> tag without a 'package' attribute"
+                    end
+                end
+            else
+                enum_for :each_package_dependency
+            end
+        end
+
+        # Enumerates the name and email of each author. If no email is present,
+        # yields (name, nil)
+        def each_author
+            if !block_given?
+                return enum_for(:each_author)
+            end
+
+            xml.elements.each('package/author') do |author|
+                (author.text || "").strip.split(',').each do |str|
+                    name, email = str.split('/').map(&:strip)
+                    email = nil if email && email.empty?
+                    yield(name, email)
+                end
+            end
+        end
+
+        # If +name+ points to a text element in the XML document, returns the
+        # content of that element. If no element matches +name+, or if the
+        # content is empty, returns nil
+        def text_node(name)
+            xml.elements.each(name) do |str|
+                str = (str.text || "").strip
+                if !str.empty?
+                    return str
+                end
+            end
+            nil
+        end
+
+        # The package associated URL, usually meant to direct to a website
+        #
+        # Returns nil if there is none
+        def url
+            return text_node('package/url')
+        end
+
+        # The package license name
+        #
+        # Returns nil if there is none
+        def license
+            return text_node('package/license')
+        end
+
+        # The package version number
+        #
+        # Returns 0 if none is declared
+        def version
+            return text_node("version")
+        end
+    end
+end

data/lib/autoproj/package_selection.rb

@@ -0,0 +1,153 @@
+module Autoproj
+        # Exception raised by
+        # PackageSelection#filter_excluded_and_ignored_packages when a given
+        # selection is completely excluded
+        class ExcludedSelection < ConfigError
+            attr_reader :selection
+            def initialize(selection)
+                @selection = selection
+            end
+        end
+
+        # Class holding information about which packages have been selected, and
+        # why. It is used to decide whether some non-availability of packages
+        # are errors or simply warnings (i.e. if the user really wants a given
+        # package, or merely might be adding it by accident)
+        class PackageSelection
+            # The set of matches, i.e. a mapping from a user-provided string to
+            # the set of packages it selected
+            attr_reader :matches
+            # The set of selected packages, as a hash of the package name to the
+            # set of user-provided strings that caused that package to be
+            # selected
+            attr_reader :selection
+            # The set of osdeps matches, i.e. a mapping from a user-provided string to
+            # the set of packages it selected
+            attr_reader :osdeps_matches
+            # The set of selected osdeps packages, as a hash of the package name
+            # to the set of user-provided strings that caused that package to be
+            # selected
+            attr_reader :osdeps_selection
+            # A flag that tells #filter_excluded_and_ignored_packages whether
+            # the a given package selection is weak or not.
+            #
+            # If true, a selection that have some excluded packages will not
+            # generate an error. Otherwise (the default), an error is generated
+            attr_reader :weak_dependencies
+            # After a call to #filter_excluded_and_ignored_packages, this
+            # contains the set of package exclusions that have been ignored
+            # because the corresponding metapackage has a weak dependency policy
+            attr_reader :exclusions
+            # After a call to #filter_excluded_and_ignored_packages, this
+            # contains the set of package ignores that have been ignored because
+            # the corresponding metapackage has a weak dependency policy
+            attr_reader :ignores
+
+            def initialize
+                @selection = Hash.new { |h, k| h[k] = Set.new }
+                @matches = Hash.new { |h, k| h[k] = Set.new }
+                @osdeps_matches = Hash.new { |h, k| h[k] = Set.new }
+                @osdeps_selection = Hash.new { |h, k| h[k] = Set.new }
+                @weak_dependencies = Hash.new
+                @ignores = Hash.new { |h, k| h[k] = Set.new }
+                @exclusions = Hash.new { |h, k| h[k] = Set.new }
+            end
+
+            # The set of packages that have been selected
+            def packages
+                selection.keys
+            end
+
+            # The set of packages that have been selected
+            def osdeps_packages
+                osdeps_selection.keys
+            end
+
+            def include?(pkg_name)
+                selection.has_key?(pkg_name) || osdeps_selection.has_key?(pkg_name)
+            end
+
+            def empty?
+                selection.empty?
+            end
+
+            def each(&block)
+                selection.each_key(&block)
+            end
+
+            def select(sel, packages, weak = false)
+                packages = Array(packages)
+                matches[sel] |= packages.to_set.dup
+                packages.each do |pkg_name|
+                    selection[pkg_name] << sel
+                end
+                weak_dependencies[sel] = weak
+            end
+
+            def initialize_copy(old)
+                old.selection.each do |pkg_name, set|
+                    @selection[pkg_name] = set.dup
+                end
+                old.matches.each do |sel, set|
+                    @matches[sel] = set.dup
+                end
+            end
+
+            def has_match_for?(sel)
+                matches.has_key?(sel)
+            end
+
+            # Remove packages that are explicitely excluded and/or ignored
+            #
+            # Raise an error if an explicit selection expands only to an
+            # excluded package, and display a warning for ignored packages
+            def filter_excluded_and_ignored_packages(manifest)
+                matches.each do |sel, expansion|
+                    excluded, other = expansion.partition { |pkg_name| manifest.excluded?(pkg_name) }
+                    ignored,  ok    = other.partition { |pkg_name| manifest.ignored?(pkg_name) }
+
+                    if !excluded.empty? && (!weak_dependencies[sel] || (ok.empty? && ignored.empty?))
+                        exclusions = excluded.map do |pkg_name|
+                            [pkg_name, manifest.exclusion_reason(pkg_name)]
+                        end
+                        base_msg = "#{sel} is selected in the manifest or on the command line"
+                        if exclusions.size == 1
+                            reason = exclusions[0][1]
+                            if sel == exclusions[0][0]
+                                raise ExcludedSelection.new(sel), "#{base_msg}, but it is excluded from the build: #{reason}"
+                            elsif weak_dependencies[sel]
+                                raise ExcludedSelection.new(sel), "#{base_msg}, but it expands to #{exclusions.map(&:first).join(", ")}, which is excluded from the build: #{reason}"
+                            else
+                                raise ExcludedSelection.new(sel), "#{base_msg}, but its dependency #{exclusions.map(&:first).join(", ")} is excluded from the build: #{reason}"
+                            end
+                        elsif weak_dependencies[sel]
+                            raise ExcludedSelection.new(sel), "#{base_msg}, but expands to #{exclusions.map(&:first).join(", ")}, and all these packages are excluded from the build:\n  #{exclusions.map { |name, reason| "#{name}: #{reason}" }.join("\n  ")}"
+                        else
+                            raise ExcludedSelection.new(sel), "#{base_msg}, but it requires #{exclusions.map(&:first).join(", ")}, and all these packages are excluded from the build:\n  #{exclusions.map { |name, reason| "#{name}: #{reason}" }.join("\n  ")}"
+                        end
+                    else
+                        self.exclusions[sel] |= excluded.to_set.dup
+                        self.ignores[sel] |= ignored.to_set.dup
+                    end
+
+                    excluded = excluded.to_set
+                    ignored = ignored.to_set
+                    expansion.delete_if do |pkg_name|
+                        ignored.include?(pkg_name) || excluded.include?(pkg_name)
+                    end
+                end
+
+                selection.keys.sort.each do |pkg_name|
+                    if manifest.excluded?(pkg_name)
+                        selection.delete(pkg_name)
+                    elsif manifest.ignored?(pkg_name)
+                        selection.delete(pkg_name)
+                    end
+                end
+                matches.delete_if do |key, sel|
+                    sel.empty?
+                end
+            end
+        end
+end
+