autoproj 2.0.0.rc3 → 2.0.0.rc4

data/lib/autoproj/{osdeps.rb → os_package_resolver.rb}

@@ -1,25 +1,9 @@
 require 'tempfile'
 require 'json'
 
-require 'autoproj/package_managers/manager'
-require 'autoproj/package_managers/unknown_os_manager'
-require 'autoproj/package_managers/shell_script_manager'
-
-require 'autoproj/package_managers/apt_dpkg_manager'
-require 'autoproj/package_managers/emerge_manager'
-require 'autoproj/package_managers/homebrew_manager'
-require 'autoproj/package_managers/pacman_manager'
-require 'autoproj/package_managers/pkg_manager'
-require 'autoproj/package_managers/port_manager'
-require 'autoproj/package_managers/yum_manager'
-require 'autoproj/package_managers/zypper_manager'
-
-require 'autoproj/package_managers/gem_manager'
-require 'autoproj/package_managers/pip_manager'
-
 module Autoproj
     # Manager for packages provided by external package managers
-    class OSDependencies
+    class OSPackageResolver
 	class << self
 	    # When requested to load a file called '$FILE', the osdeps code will
 	    # also look for files called '$FILE-suffix', where 'suffix' is an
@@ -45,7 +29,7 @@ def self.load(file)
                       else ArgumentError
                       end
 
-	    result = OSDependencies.new
+	    result = new
 	    candidates.each do |file|
                 next if !File.file?(file)
                 file = File.expand_path(file)
@@ -56,19 +40,18 @@ def self.load(file)
                     raise ConfigError.new, "error in #{file}: #{e.message}", e.backtrace
                 end
 
-                result.merge(OSDependencies.new(data, file))
+                result.merge(new(data, file))
 	    end
 	    result
         end
 
         class << self
             attr_reader :aliases
-            attr_accessor :force_osdeps
         end
         @aliases = Hash.new
 
-        attr_writer :silent
-        def silent?; @silent end
+        # The underlying workspace
+        attr_reader :ws
 
         def self.alias(old_name, new_name)
             @aliases[new_name] = old_name
@@ -99,23 +82,14 @@ def self.load_default
                 Autoproj.warn "#{file} (from AUTOPROJ_DEFAULT_OSDEPS) is not a file, falling back to #{AUTOPROJ_OSDEPS}"
                 file = AUTOPROJ_OSDEPS
             end
-            OSDependencies.load(file)
+            load(file)
         end
 
         def load_default
             merge(self.class.load_default)
         end
 
-        PACKAGE_HANDLERS = [PackageManagers::AptDpkgManager,
-            PackageManagers::GemManager,
-            PackageManagers::EmergeManager,
-            PackageManagers::PacmanManager,
-            PackageManagers::HomebrewManager,
-            PackageManagers::YumManager,
-            PackageManagers::PortManager,
-            PackageManagers::ZypperManager,
-            PackageManagers::PipManager ,
-            PackageManagers::PkgManager]
+        PACKAGE_MANAGERS = OSPackageInstaller::PACKAGE_MANAGERS.keys
         
         # Mapping from OS name to package manager name
         #
@@ -128,15 +102,15 @@ def load_default
         #    homebrew: package
         #
         # we need to be able to separate between OS and package manager names.
-        OS_PACKAGE_HANDLERS = {
-            'debian' => 'apt-dpkg',
-            'gentoo' => 'emerge',
-            'arch' => 'pacman',
-            'fedora' => 'yum',
+        OS_PACKAGE_MANAGERS = {
+            'debian'     => 'apt-dpkg',
+            'gentoo'     => 'emerge',
+            'arch'       => 'pacman',
+            'fedora'     => 'yum',
             'macos-port' => 'macports',
             'macos-brew' => 'brew',
-            'opensuse' => 'zypper',
-            'freebsd' => 'pkg'
+            'opensuse'   => 'zypper',
+            'freebsd'    => 'pkg'
         }
 
         # The information contained in the OSdeps files, as a hash
@@ -150,36 +124,28 @@ def load_default
         attr_reader :sources
 
         # Use to override the autodetected OS-specific package handler
-        attr_writer :os_package_handler
-
-        # Returns the package manager object for the current OS
-        def os_package_handler
-            if @os_package_handler.nil?
-                os_names, _ = OSDependencies.operating_system
-                if os_names && (key = os_names.find { |name| OS_PACKAGE_HANDLERS[name] })
-                    @os_package_handler = package_handlers[OS_PACKAGE_HANDLERS[key]]
-                    if !@os_package_handler
-                        raise ArgumentError, "found #{OS_PACKAGE_HANDLERS[name]} as the required package handler for #{os_names.join(", ")}, but it is not registered"
-                    end
-                else
-                    @os_package_handler = PackageManagers::UnknownOSManager.new
+        attr_writer :os_package_manager
+
+        # Returns the name of the package manager object for the current OS
+        #
+        # @return [String]
+        def os_package_manager
+            if !instance_variable_defined?(:@os_package_manager)
+                os_names, _ = OSPackageResolver.operating_system
+                os_name = os_names.find { |name| OS_PACKAGE_MANAGERS[name] }
+                @os_package_manager = OS_PACKAGE_MANAGERS[os_name]
+                if !@os_package_manager
+                    raise "unsupported OS #{os_names.join(", ")}"
                 end
             end
-            return @os_package_handler
+            return @os_package_manager
         end
 
-        # Returns the set of package managers
-        def package_handlers
-            if !@package_handlers
-                @package_handlers = Hash.new
-                PACKAGE_HANDLERS.each do |klass|
-                    obj = klass.new
-                    obj.names.each do |n|
-                        @package_handlers[n] = obj
-                    end
-                end
-            end
-            @package_handlers
+        # Returns the set of known package managers
+        #
+        # @return [Array<String>]
+        def package_managers
+            PACKAGE_MANAGERS
         end
 
         # The Gem::SpecFetcher object that should be used to query RubyGems, and
@@ -196,8 +162,6 @@ def initialize(defs = Hash.new, file = nil)
                     all_definitions[package_name] << [[file], defs[package_name]]
                 end
             end
-            @silent = true
-            @filter_uptodate_packages = true
         end
 
         # Returns the name of all known OS packages
@@ -215,7 +179,7 @@ def source_of(package_name)
         end
 
         # Merges the osdeps information of +info+ into +self+. If packages are
-        # defined in both OSDependencies objects, the information in +info+
+        # defined in both OSPackageResolver objects, the information in +info+
         # takes precedence
         def merge(info)
             root_dir = nil
@@ -228,11 +192,11 @@ def merge(info)
                     # Warn if the new osdep definition resolves to a different
                     # set of packages than the old one
                     old_resolved = resolve_package(h).inject(Hash.new) do |osdep_h, (handler, status, list)|
-                        osdep_h[handler.name] = [status, list]
+                        osdep_h[handler] = [status, list]
                         osdep_h
                     end
                     new_resolved = info.resolve_package(h).inject(Hash.new) do |osdep_h, (handler, status, list)|
-                        osdep_h[handler.name] = [status, list]
+                        osdep_h[handler] = [status, list]
                         osdep_h
                     end
                     if old_resolved != new_resolved
@@ -282,7 +246,7 @@ def self.supported_operating_system?
                 @supported_operating_system =
                     if !os_names then false
                     else
-                        os_names.any? { |os_name| OS_PACKAGE_HANDLERS.has_key?(os_name) }
+                        os_names.any? { |os_name| OS_PACKAGE_MANAGERS.has_key?(os_name) }
                     end
             end
             return @supported_operating_system
@@ -325,8 +289,8 @@ def self.guess_operating_system
                         ENV['AUTOPROJ_MACOSX_PACKAGE_MANAGER']
                     else 'macos-brew'
                     end
-                if !OS_PACKAGE_HANDLERS.include?(manager)
-                    known_managers = OS_PACKAGE_HANDLERS.keys.grep(/^macos/)
+                if !OS_PACKAGE_MANAGERS.has_key?(manager)
+                    known_managers = OS_PACKAGE_MANAGERS.keys.grep(/^macos/)
                     raise ArgumentError, "#{manager} is not a known MacOSX package manager. Known package managers are #{known_managers.join(", ")}"
                 end
 
@@ -497,8 +461,8 @@ class InvalidRecursiveStatement < Autobuild::Exception; end
         # ending at the resolved name
         def self.resolve_name(name)
             path = [ name ]
-            while OSDependencies.aliases.has_key?(name)
-                name = OSDependencies.aliases[name]
+            while aliases.has_key?(name)
+                name = aliases[name]
                 path << name
             end
             path
@@ -522,10 +486,10 @@ def self.resolve_name(name)
         # name and version. The package list might be empty even if status ==
         # FOUND_PACKAGES, for instance if the ignore keyword is used.
         def resolve_package(name)
-            path = OSDependencies.resolve_name(name)
+            path = self.class.resolve_name(name)
             name = path.last
 
-            os_names, os_versions = OSDependencies.operating_system
+            os_names, os_versions = self.class.operating_system
             os_names = os_names.dup
             os_names << 'default'
 
@@ -543,19 +507,15 @@ def resolve_package(name)
                 os_versions = ['default']
             end
 
-            package_handler_names = package_handlers.keys
-
             result = []
-            found, pkg = partition_osdep_entry(name, dep_def, nil, (package_handler_names - os_package_handler.names), os_names, os_versions)
+            found, pkg = partition_osdep_entry(name, dep_def, nil,
+                                               (package_managers - [os_package_manager]), os_names, os_versions)
             if found
-                result << [os_package_handler, found, pkg]
+                result << [os_package_manager, found, pkg]
             end
 
-            # NOTE: package_handlers might contain the same handler multiple
-            # times (when a package manager has multiple names). That's why we
-            # do a to_set.each
-            package_handlers.each_value.to_set.each do |handler|
-                found, pkg = partition_osdep_entry(name, dep_def, handler.names, [], os_names, os_versions)
+            package_managers.each do |handler|
+                found, pkg = partition_osdep_entry(name, dep_def, [handler], [], os_names, os_versions)
                 if found
                     result << [handler, found, pkg]
                 end
@@ -573,13 +533,7 @@ def resolve_package(name)
                 end
             end
 
-            result.map do |handler, status, entries|
-                if handler.respond_to?(:parse_package_entry)
-                    [handler, status, entries.map { |s| handler.parse_package_entry(s) }]
-                else
-                    [handler, status, entries]
-                end
-            end
+            result
         end
 
         # Value returned by #resolve_package and #partition_osdep_entry in
@@ -737,21 +691,21 @@ def partition_osdep_entry(osdep_name, dep_def, handler_names, excluded, *keys)
         #
         # @raise MissingOSDep if some packages can't be found or if the
         #   nonexistent keyword was found for some of them
-        def resolve_os_dependencies(dependencies)
+        def resolve_os_packages(dependencies)
             all_packages = []
             dependencies.each do |name|
                 result = resolve_package(name)
                 if !result
-                    path = OSDependencies.resolve_name(name)
+                    path = self.class.resolve_name(name)
                     raise MissingOSDep.new, "there is no osdeps definition for #{path.last} (search tree: #{path.join("->")})"
                 end
 
                 if result.empty?
-                    if OSDependencies.supported_operating_system?
-                        os_names, os_versions = OSDependencies.operating_system
+                    if self.class.supported_operating_system?
+                        os_names, os_versions = self.class.operating_system
                         raise MissingOSDep.new, "there is an osdeps definition for #{name}, but not for this operating system and version (resp. #{os_names.join(", ")} and #{os_versions.join(", ")})"
                     end
-                    result = [[os_package_handler, FOUND_PACKAGES, [name]]]
+                    result = [[os_package_manager, FOUND_PACKAGES, [name]]]
                 end
 
                 result.each do |handler, status, packages|
@@ -817,16 +771,16 @@ def availability_of(name)
             end
 
             if resolved.empty?
-                if !OSDependencies.operating_system
+                if !self.class.operating_system
                     return UNKNOWN_OS
-                elsif !OSDependencies.supported_operating_system?
+                elsif !self.class.supported_operating_system?
                     return AVAILABLE
                 else return WRONG_OS
                 end
             end
 
             resolved = resolved.delete_if { |_, status, list| status == FOUND_PACKAGES && list.empty? }
-            failed = resolved.find_all do |handler, status, list|
+            failed = resolved.find_all do |_, status, _|
                 status == FOUND_NONEXISTENT
             end
             if failed.empty?
@@ -839,296 +793,6 @@ def availability_of(name)
                 return NONEXISTENT
             end
         end
-
-        HANDLE_ALL  = 'all'
-        HANDLE_RUBY = 'ruby'
-        HANDLE_OS   = 'os'
-        HANDLE_NONE = 'none'
-
-        def self.osdeps_mode_option_unsupported_os(config = Autoproj.config)
-            long_doc =<<-EOT
-The software packages that autoproj will have to build may require other
-prepackaged softwares (a.k.a. OS dependencies) to be installed (RubyGems
-packages, packages from your operating system/distribution, ...). Autoproj is
-usually able to install those automatically, but unfortunately your operating
-system is not (yet) supported by autoproj's osdeps mechanism, it can only offer
-you some limited support.
-
-Some package handlers are cross-platform, and are therefore supported.  However,
-you will have to install the kind of OS dependencies (so-called OS packages)
-
-This option is meant to allow you to control autoproj's behaviour while handling
-OS dependencies.
-
-* if you say "all", all OS-independent packages are going to be installed.
-* if you say "gem", the RubyGem packages will be installed.
-* if you say "pip", the Pythin PIP packages will be installed.
-* if you say "none", autoproj will not do anything related to the OS
-  dependencies.
-
-As any configuration value, the mode can be changed anytime by calling
-  autoproj reconfigure
-
-Finally, the "autoproj osdeps" command will give you the necessary information
-about the OS packages that you will need to install manually.
-
-So, what do you want ? (all, none or a comma-separated list of: gem pip)
-            EOT
-            message = [ "Which prepackaged software (a.k.a. 'osdeps') should autoproj install automatically (all, none or a comma-separated list of: gem pip) ?", long_doc.strip ]
-
-	    config.declare 'osdeps_mode', 'string',
-		:default => 'ruby',
-		:doc => message,
-                :lowercase => true
-        end
-
-        def self.osdeps_mode_option_supported_os(config = Autoproj.config)
-            long_doc =<<-EOT
-The software packages that autoproj will have to build may require other
-prepackaged softwares (a.k.a. OS dependencies) to be installed (RubyGems
-packages, packages from your operating system/distribution, ...). Autoproj
-is able to install those automatically for you.
-
-Advanced users may want to control this behaviour. Additionally, the
-installation of some packages require administration rights, which you may
-not have. This option is meant to allow you to control autoproj's behaviour
-while handling OS dependencies.
-
-* if you say "all", it will install all packages automatically.
-  This requires root access thru 'sudo'
-* if you say "pip", only the Ruby packages will be installed.
-  Installing these packages does not require root access.
-* if you say "gem", only the Ruby packages will be installed.
-  Installing these packages does not require root access.
-* if you say "os", only the OS-provided packages will be installed.
-  Installing these packages requires root access.
-* if you say "none", autoproj will not do anything related to the
-  OS dependencies.
-
-Finally, you can provide a comma-separated list of pip gem and os.
-
-As any configuration value, the mode can be changed anytime by calling
-  autoproj reconfigure
-
-Finally, the "autoproj osdeps" command will give you the necessary information
-about the OS packages that you will need to install manually.
-
-So, what do you want ? (all, none or a comma-separated list of: os gem pip)
-            EOT
-            message = [ "Which prepackaged software (a.k.a. 'osdeps') should autoproj install automatically (all, none or a comma-separated list of: os gem pip) ?", long_doc.strip ]
-
-	    config.declare 'osdeps_mode', 'string',
-		:default => 'all',
-		:doc => message,
-                :lowercase => true
-        end
-
-        def self.define_osdeps_mode_option(config = Autoproj.config)
-            if supported_operating_system?
-                osdeps_mode_option_supported_os(config)
-            else
-                osdeps_mode_option_unsupported_os(config)
-            end
-        end
-
-        def self.osdeps_mode_string_to_value(string)
-            string = string.to_s.downcase.split(',')
-            modes = []
-            string.map do |str|
-                case str
-                when 'all'  then modes.concat(['os', 'gem', 'pip'])
-                when 'ruby' then modes << 'gem'
-                when 'gem'  then modes << 'gem'
-                when 'pip'  then modes << 'pip'
-                when 'os'   then modes << 'os'
-                when 'none' then
-                else raise ArgumentError, "#{str} is not a known package handler"
-                end
-            end
-            modes
-        end
-
-        # If set to true (the default), #install will try to remove the list of
-        # already uptodate packages from the installed packages. Set to false to
-        # install all packages regardless of their status
-        attr_writer :filter_uptodate_packages
-
-        # If set to true (the default), #install will try to remove the list of
-        # already uptodate packages from the installed packages. Use
-        # #filter_uptodate_packages= to set it to false to install all packages
-        # regardless of their status
-        def filter_uptodate_packages?
-            !!@filter_uptodate_packages
-        end
-
-        # Override the osdeps mode
-        def osdeps_mode=(value)
-            @osdeps_mode = OSDependencies.osdeps_mode_string_to_value(value)
-        end
-
-        # Returns the osdeps mode chosen by the user
-        def osdeps_mode
-            # This has two uses. It caches the value extracted from the
-            # AUTOPROJ_OSDEPS_MODE and/or configuration file. Moreover, it
-            # allows to override the osdeps mode by using
-            # OSDependencies#osdeps_mode=
-            if @osdeps_mode
-                return @osdeps_mode
-            end
-
-            @osdeps_mode = OSDependencies.osdeps_mode
-        end
-
-        def self.osdeps_mode(config = Autoproj.config)
-            while true
-                mode =
-                    if !config.has_value_for?('osdeps_mode') &&
-                        mode_name = ENV['AUTOPROJ_OSDEPS_MODE']
-                        begin OSDependencies.osdeps_mode_string_to_value(mode_name)
-                        rescue ArgumentError
-                            Autoproj.warn "invalid osdeps mode given through AUTOPROJ_OSDEPS_MODE (#{mode})"
-                            nil
-                        end
-                    else
-                        mode_name = config.get('osdeps_mode')
-                        begin OSDependencies.osdeps_mode_string_to_value(mode_name)
-                        rescue ArgumentError
-                            Autoproj.warn "invalid osdeps mode stored in configuration file"
-                            nil
-                        end
-                    end
-
-                if mode
-                    @osdeps_mode = mode
-                    config.set('osdeps_mode', mode_name, true)
-                    return mode
-                end
-
-                # Invalid configuration values. Retry
-                config.reset('osdeps_mode')
-                ENV['AUTOPROJ_OSDEPS_MODE'] = nil
-            end
-        end
-
-        # The set of packages that have already been installed
-        attr_reader :installed_packages
-
-        # 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
-                else
-                    options = options.dup
-                    options[:osdeps_mode] ||= osdeps_mode
-                    options
-                end
-
-            os_package_handler.enabled = false
-            package_handlers.each_value do |handler|
-                handler.enabled = false
-            end
-            options[:osdeps_mode].each do |m|
-                if m == 'os'
-                    os_package_handler.enabled = true
-                elsif pkg = package_handlers[m]
-                    pkg.enabled = true
-                else
-                    Autoproj.warn "osdep handler #{m.inspect} has no handler, available handlers are #{package_handlers.keys.map(&:inspect).sort.join(", ")}"
-                end
-            end
-            os_package_handler.silent = self.silent?
-            package_handlers.each_value do |v|
-                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 that packages that are handled within the autoproj project
-        # (i.e. gems) are restored to pristine condition
-        #
-        # This is usually called as a rebuild step to make sure that all these
-        # packages are updated to whatever required the rebuild
-        def pristine(packages, options = Hash.new)
-            install(packages, options.merge(install_only: true))
-            packages = resolve_os_dependencies(packages)
-
-            _, other_packages =
-                packages.partition { |handler, list| handler == os_package_handler }
-            other_packages.each do |handler, list|
-                if handler.respond_to?(:pristine)
-                    handler.pristine(list)
-                end
-            end
-        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?
-
-            filter_options, options =
-                filter_options options, install_only: !Autobuild.do_update
-            setup_package_handlers(options)
-
-            packages = resolve_os_dependencies(packages)
-
-            needs_filter = (filter_uptodate_packages? || filter_options[:install_only])
-            packages = packages.map do |handler, list|
-                if needs_filter && handler.respond_to?(:filter_uptodate_packages)
-                    list = handler.filter_uptodate_packages(list, filter_options)
-                end
-
-                if !list.empty?
-                    [handler, list]
-                end
-            end.compact
-            return false if packages.empty?
-
-            # Install OS packages first, as the other package handlers might
-            # depend on OS packages
-            os_packages, other_packages = packages.partition { |handler, list| handler == os_package_handler }
-            [os_packages, other_packages].each do |packages|
-                packages.each do |handler, list|
-                    handler.install(list)
-                    @installed_packages |= list.to_set
-                end
-            end
-            true
-        end
-
-        def reinstall(options = Hash.new)
-            # We also reinstall the osdeps that provide the
-            # functionality
-            managers = setup_package_handlers(options)
-            managers.each do |mng|
-                if mng.enabled? && mng.respond_to?(:reinstall)
-                    mng.reinstall
-                end
-            end
-        end
     end
 end