autoproj 2.0.0.rc3 → 2.0.0.rc4

data/lib/autoproj/package_managers/apt_dpkg_manager.rb

@@ -5,9 +5,9 @@ module PackageManagers
         class AptDpkgManager < ShellScriptManager
             attr_accessor :status_file
 
-            def initialize(status_file = "/var/lib/dpkg/status")
+            def initialize(ws, status_file = "/var/lib/dpkg/status")
                 @status_file = status_file
-                super(['apt-dpkg'], true,
+                super(ws, true,
                       "apt-get install '%s'",
                       "export DEBIAN_FRONTEND=noninteractive; apt-get install -y '%s'")
             end

data/lib/autoproj/package_managers/bundler_manager.rb

@@ -0,0 +1,179 @@
+module Autoproj
+    module PackageManagers
+        # Package manager interface for the RubyGems system
+        class BundlerManager < Manager
+            class << self
+                attr_writer :with_prerelease
+                attr_accessor :with_doc
+            end
+            @with_prerelease = false
+            @with_doc = false
+
+            def self.with_prerelease(*value)
+                if value.empty?
+                    @with_prerelease
+                else
+                    begin
+                        saved_flag = @with_prerelease
+                        @with_prerelease = value.first
+                        yield
+                    ensure
+                        @with_prerelease = saved_flag
+                    end
+                end
+            end
+
+            # Filters all paths that come from other autoproj installations out
+            # of GEM_PATH
+            def initialize_environment
+                env = ws.env
+
+                env.original_env['GEM_PATH'] =
+                    (env['GEM_PATH'] || "").split(File::PATH_SEPARATOR).find_all do |p|
+                        !Workspace.in_autoproj_project?(p)
+                    end.join(File::PATH_SEPARATOR)
+                env.inherit 'GEM_PATH'
+                env.init_from_env 'GEM_PATH'
+                orig_gem_path = env.original_env['GEM_PATH'].split(File::PATH_SEPARATOR)
+                env.system_env['GEM_PATH'] = Gem.default_path
+                env.original_env['GEM_PATH'] = orig_gem_path.join(File::PATH_SEPARATOR)
+
+                env.init_from_env 'RUBYLIB'
+                env.inherit 'RUBYLIB'
+                original_rubylib =
+                    (env['RUBYLIB'] || "").split(File::PATH_SEPARATOR).find_all do |p|
+                        !Workspace.in_autoproj_project?(p)
+                            !p.start_with?(Bundler.rubygems.gem_dir) &&
+                            !Bundler.rubygems.gem_path.any? { |gem_p| p.start_with?(p) }
+                    end
+                system_rubylib = discover_rubylib
+                env.system_env['RUBYLIB'] = []
+                env.original_env['RUBYLIB'] = (original_rubylib - system_rubylib).join(File::PATH_SEPARATOR)
+
+                dot_autoproj = ws.dot_autoproj_dir
+                if ws.config.private_bundler?
+                    env.push_path 'GEM_PATH', File.join(dot_autoproj, 'bundler')
+                end
+                if ws.config.private_autoproj?
+                    env.push_path 'GEM_PATH', File.join(dot_autoproj, 'autoproj')
+                end
+
+                ws.manifest.each_reused_autoproj_installation do |p|
+                    reused_w = ws.new(p)
+                    reused_c = reused_w.load_config
+                    if reused_c.private_gems?
+                        env.push_path 'GEM_PATH', File.join(reused_w.prefix_dir, 'gems')
+                    end
+                    env.push_path 'PATH', File.join(reused_w.prefix_dir, 'gems', 'bin')
+                end
+
+
+                gem_home = File.join(ws.prefix_dir, "gems")
+                if ws.config.private_gems?
+                    env.set 'GEM_HOME', gem_home
+                    env.push_path 'GEM_PATH', gem_home
+                end
+
+                FileUtils.mkdir_p gem_home
+                gemfile = File.join(gem_home, 'Gemfile')
+                if !File.exists?(gemfile)
+                    File.open(gemfile, 'w') do |io|
+                        io.puts "eval_gemfile \"#{File.join(ws.dot_autoproj_dir, 'autoproj', 'Gemfile')}\""
+                    end
+                end
+
+                env.set 'BUNDLE_GEMFILE', File.join(gem_home, 'Gemfile')
+                env.push_path 'PATH', File.join(ws.dot_autoproj_dir, 'autoproj', 'bin')
+                env.push_path 'PATH', File.join(gem_home, 'bin')
+                Autobuild.programs['bundler'] = File.join(ws.dot_autoproj_dir, 'autoproj', 'bin', 'bundler')
+
+                update_env_rubylib(system_rubylib)
+            end
+
+            def update_env_rubylib(system_rubylib = discover_rubylib)
+                rubylib = discover_bundle_rubylib
+                current = ws.env.resolved_env['RUBYLIB'].split(File::PATH_SEPARATOR) + system_rubylib
+                (rubylib - current).each do |p|
+                    ws.env.push_path('RUBYLIB', p)
+                end
+            end
+
+            def parse_package_entry(entry)
+                if entry =~ /^([^><=~]*)([><=~]+.*)$/
+                    [$1.strip, $2.strip]
+                else
+                    [entry]
+                end
+            end
+
+            def install(gems)
+                # Generate the gemfile
+                gems = gems.sort.map do |name|
+                    name, version = parse_package_entry(name)
+                    "gem \"#{name}\", \"#{version || ">= 0"}\""
+                end.join("\n")
+
+                root_dir = File.join(ws.prefix_dir, 'gems')
+                FileUtils.mkdir_p root_dir
+                gemfile = File.join(root_dir, 'Gemfile')
+                File.open(gemfile, 'w') do |io|
+                    io.puts "eval_gemfile \"#{File.join(ws.dot_autoproj_dir, 'autoproj', 'Gemfile')}\""
+                    io.puts gems
+                end
+
+                File.open(File.join(root_dir, 'Gemfile.lock'), 'w') do |io|
+                    io.write File.read(File.join(ws.dot_autoproj_dir, 'autoproj', 'Gemfile.lock'))
+                end
+
+                if ws.config.private_gems?
+                    options = ['--path', root_dir]
+                end
+
+                Bundler.with_clean_env do
+                    connections = Set.new
+                    Autobuild::Subprocess.run 'autoproj', 'osdeps',
+                        Autobuild.tool('bundler'), 'install',
+                            "--gemfile=#{gemfile}", *options,
+                            "--binstubs", File.join(root_dir, 'bin'),
+                            env: Hash['BUNDLE_GEMFILE' => gemfile] do |line|
+
+                        case line
+                        when /Installing (.*)/
+                            Autobuild.message "  bundler: installing #{$1}"
+                        when /Fetching.*from (.*)/
+                            host = $1.gsub(/\.+$/, '')
+                            if !connections.include?(host)
+                                Autobuild.message "  bundler: connected to #{host}"
+                                connections << host
+                            end
+                        end
+                    end
+                end
+
+                update_env_rubylib
+            end
+
+            def discover_rubylib
+                r, w = IO.pipe
+                Bundler.clean_system(
+                    Hash['RUBYLIB' => nil],
+                    Autobuild.tool('ruby'), '-e', 'puts $LOAD_PATH',
+                    out: w)
+                w.close
+                r.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
+            end
+
+            def discover_bundle_rubylib
+                gemfile = File.join(ws.prefix_dir, 'gems', 'Gemfile')
+                r, w = IO.pipe
+                Bundler.clean_system(
+                    Hash['BUNDLE_GEMFILE' => gemfile],
+                    Autobuild.tool('bundler'), 'exec', 'ruby', '-e', 'puts $LOAD_PATH',
+                    out: w)
+                w.close
+                r.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
+            end
+        end
+    end
+end
+

data/lib/autoproj/package_managers/emerge_manager.rb

@@ -3,8 +3,8 @@ module PackageManagers
         # Package manager interface for systems that use emerge (i.e. gentoo) as
         # their package manager
         class EmergeManager < ShellScriptManager
-            def initialize
-                super(['emerge'], true,
+            def initialize(ws)
+                super(ws, true,
                         "emerge '%s'",
                         "emerge --noreplace '%s'")
             end

data/lib/autoproj/package_managers/gem_manager.rb

@@ -25,7 +25,8 @@ def self.with_prerelease(*value)
 
             # Filters all paths that come from other autoproj installations out
             # of GEM_PATH
-            def self.initialize_environment(env = Autobuild.env, manifest = Autoproj.manifest, root_dir = Autoproj.root_dir)
+            def initialize_environment
+                env = ws.env
                 env.original_env['GEM_PATH'] =
                     (env['GEM_PATH'] || "").split(File::PATH_SEPARATOR).find_all do |p|
                         !Autoproj.in_autoproj_installation?(p)
@@ -37,7 +38,7 @@ def self.initialize_environment(env = Autobuild.env, manifest = Autoproj.manifes
                 env.system_env['GEM_PATH'] = Gem.default_path
                 env.original_env['GEM_PATH'] = orig_gem_path.join(File::PATH_SEPARATOR)
 
-                manifest.each_reused_autoproj_installation do |p|
+                ws.manifest.each_reused_autoproj_installation do |p|
                     p_gems = File.join(p, '.gems')
                     if File.directory?(p_gems)
                         env.push_path 'GEM_PATH', p_gems
@@ -45,7 +46,7 @@ def self.initialize_environment(env = Autobuild.env, manifest = Autoproj.manifes
                     end
                 end
 
-                @gem_home = (ENV['AUTOPROJ_GEM_HOME'] || File.join(root_dir, ".gems"))
+                @gem_home = (ENV['AUTOPROJ_GEM_HOME'] || File.join(ws.root_dir, ".gems"))
                 env.push_path 'GEM_PATH', gem_home
                 env.set 'GEM_HOME', gem_home
                 env.push_path 'PATH', "#{gem_home}/bin"
@@ -99,8 +100,8 @@ def self.default_install_options
                 @default_install_options ||= ['--no-user-install', '--no-format-executable']
             end
 
-            def initialize
-                super(['gem'])
+            def initialize(ws)
+                super(ws)
                 @installed_gems = Set.new
             end
 
@@ -274,7 +275,7 @@ def parse_package_entry(entry)
             end
 
             def gems_interaction(gems, cmdlines)
-                if OSDependencies.force_osdeps
+                if OSPackageInstaller.force_osdeps
                     return true
                 elsif enabled?
                     return true

data/lib/autoproj/package_managers/homebrew_manager.rb

@@ -3,8 +3,8 @@ module PackageManagers
         # Package manager interface for Mac OS using homebrew as
         # its package manager
         class HomebrewManager < ShellScriptManager
-            def initialize
-                super(['brew'], true,
+            def initialize(ws)
+                super(ws, true,
                         "brew install '%s'",
                         "brew install '%s'",
                         false)

data/lib/autoproj/package_managers/manager.rb

@@ -7,9 +7,8 @@ module PackageManagers
         # Package managers must be registered in PACKAGE_HANDLERS and
         # (if applicable) OS_PACKAGE_HANDLERS.
         class Manager
-            # @return [Array<String>] the various names this package manager is
-            #   known about
-            attr_reader :names
+            # @return [Workspace] the workspace
+            attr_reader :ws
 
             attr_writer :enabled
             def enabled?; !!@enabled end
@@ -22,8 +21,8 @@ def silent?; !!@silent end
             # @param [Array<String>] names the package manager names. It MUST be
             #   different from the OS names that autoproj uses. See the comment
             #   for OS_PACKAGE_HANDLERS for an explanation
-            def initialize(names = [])
-                @names = names.dup
+            def initialize(ws)
+                @ws = ws
                 @enabled = true
                 @silent = true
             end
@@ -37,7 +36,7 @@ def name
             # order to have a properly functioning package manager
             #
             # This is e.g. needed for python pip or rubygems
-            def self.initialize_environment(_env = nil, _manifest = nil, _root_dir = Autoproj.root_dir)
+            def initialize_environment
             end
         end
     end

data/lib/autoproj/package_managers/pacman_manager.rb

@@ -3,8 +3,8 @@ module PackageManagers
         # Package manager interface for systems that use pacman (i.e. arch) as
         # their package manager
         class PacmanManager < ShellScriptManager
-            def initialize
-                super(['pacman'], true,
+            def initialize(ws)
+                super(ws, true,
                         "pacman -Sy --needed '%s'",
                         "pacman -Sy --needed --noconfirm '%s'")
             end

data/lib/autoproj/package_managers/pip_manager.rb

@@ -4,18 +4,18 @@ module PackageManagers
         class PipManager < Manager
             attr_reader :installed_pips
 
-            def self.initialize_environment(env = Autobuild.env, _manifest = nil, root_dir = Autoproj.root_dir)
-                env.set 'PYTHONUSERBASE', pip_home(env, root_dir)
+            def initialize_environment
+                ws.env.set 'PYTHONUSERBASE', pip_home
             end
 
             # Return the directory where python packages are installed to.
             # The actual path is pip_home/lib/pythonx.y/site-packages.
-            def self.pip_home(env = Autobuild.env, root_dir = Autoproj.root_dir)
-                env['AUTOPROJ_PYTHONUSERBASE'] || File.join(root_dir,".pip")
+            def pip_home
+                ws.env['AUTOPROJ_PYTHONUSERBASE'] || File.join(ws.prefix_dir, "pip")
             end
 
-            def initialize
-                super(['pip'])
+            def initialize(ws)
+                super(ws)
                 @installed_pips = Set.new
             end
 
@@ -52,7 +52,7 @@ def install(pips)
             end
             
             def pips_interaction(pips, cmdlines)
-                if OSDependencies.force_osdeps
+                if OSPackageInstaller.force_osdeps
                     return true
                 elsif enabled?
                     return true
@@ -69,7 +69,7 @@ def pips_interaction(pips, cmdlines)
         
           #{cmdlines.map { |c| c.join(" ") }.join("\n      ")}
         
-        Autoproj expects these Python packages to be installed in #{PipManager.pip_home} This can
+        Autoproj expects these Python packages to be installed in #{pip_home} This can
         be overridden by setting the AUTOPROJ_PYTHONUSERBASE environment variable manually
 
                 EOMSG

data/lib/autoproj/package_managers/pkg_manager.rb

@@ -3,8 +3,8 @@ module PackageManagers
 	# Package manager interface for systems that use pkg (i.e. FreeBSD) as
         # their package manager
         class PkgManager < ShellScriptManager
-            def initialize
-                super(['pkg'], true,
+            def initialize(ws)
+                super(ws, true,
                         "pkg install -y '%s'",
                         "pkg install -y '%s'")
             end

data/lib/autoproj/package_managers/port_manager.rb

@@ -3,8 +3,8 @@ module PackageManagers
         # Package manager interface for systems that use port (i.e. MacPorts/Darwin) as
         # their package manager
         class PortManager < ShellScriptManager
-            def initialize
-                super(['macports'], true,
+            def initialize(ws)
+                super(ws, true,
                         "port install '%s'",
                         "port install '%s'")
             end

data/lib/autoproj/package_managers/shell_script_manager.rb

@@ -93,8 +93,8 @@ def needs_root?; !!@needs_root end
             #   itself, see {#auto_install_cmd}.
             # @param [Boolean] needs_root if the command lines should be started
             #   as root or not. See {#needs_root?}
-            def initialize(names, needs_locking, user_install_cmd, auto_install_cmd,needs_root=true)
-                super(names)
+            def initialize(ws, needs_locking, user_install_cmd, auto_install_cmd,needs_root=true)
+                super(ws)
                 @needs_locking, @user_install_cmd, @auto_install_cmd,@needs_root =
                     needs_locking, user_install_cmd, auto_install_cmd, needs_root
             end
@@ -139,7 +139,7 @@ def generate_auto_os_script(os_packages, options = Hash.new)
             # @return [Boolean] true if the packages should be installed
             #   automatically, false otherwise
             def osdeps_interaction(os_packages, shell_script)
-                if OSDependencies.force_osdeps
+                if OSPackageInstaller.force_osdeps
                     return true
                 elsif enabled?
                     return true
@@ -184,7 +184,7 @@ def osdeps_interaction(os_packages, shell_script)
             #   packages. See the option in {#generate_auto_os_script}
             # @return [Boolean] true if packages got installed, false otherwise
             def install(packages, options = Hash.new)
-                handled_os = OSDependencies.supported_operating_system?
+                handled_os = OSPackageResolver.supported_operating_system?
                 if handled_os
                     shell_script = generate_auto_os_script(packages, options)
                     user_shell_script = generate_user_os_script(packages, options)

data/lib/autoproj/package_managers/unknown_os_manager.rb

@@ -3,8 +3,8 @@ module PackageManagers
         # Dummy package manager used for unknown OSes. It simply displays a
         # message to the user when packages are needed
         class UnknownOSManager < Manager
-            def initialize
-                super(['unknown'])
+            def initialize(ws)
+                super(ws)
                 @installed_osdeps = Set.new
             end
 

data/lib/autoproj/package_managers/yum_manager.rb

@@ -2,8 +2,8 @@ module Autoproj
     module PackageManagers
         # Package manager interface for systems that use yum
         class YumManager < ShellScriptManager
-            def initialize
-                super(['yum'], true,
+            def initialize(ws)
+                super(ws, true,
                       "yum install '%s'",
                       "yum install -y '%s'")
             end

data/lib/autoproj/package_managers/zypper_manager.rb

@@ -2,8 +2,8 @@ module Autoproj
     module PackageManagers
         #Package manger for OpenSuse and Suse (untested)
         class ZypperManager < ShellScriptManager
-            def initialize
-                super(['zypper'], true,
+            def initialize(ws)
+                super(ws, true,
                         "zypper install '%s'",
                         "zypper -n install '%s'")
             end

data/lib/autoproj/package_set.rb

@@ -36,13 +36,13 @@ def add_source_file(name)
         # local? returns true.
         attr_accessor :vcs
 
-        # The set of OSDependencies object that represent the osdeps files
+        # The set of OSPackageResolver object that represent the osdeps files
         # available in this package set
         attr_reader :all_osdeps
 
-        # The OSDependencies which is a merged version of all OSdeps in
+        # The OSPackageResolver which is a merged version of all OSdeps in
         # #all_osdeps
-        attr_reader :osdeps
+        attr_reader :os_package_resolver
 
         # If this package set has been imported from another package set, this
         # is the other package set object
@@ -90,7 +90,7 @@ def default_packages
         def initialize(manifest, vcs)
             @manifest = manifest
             @vcs = vcs
-            @osdeps = OSDependencies.new
+            @os_package_resolver = OSPackageResolver.new
             @all_osdeps = []
             @overrides = Array.new
 
@@ -104,15 +104,15 @@ def initialize(manifest, vcs)
 
         # Load a new osdeps file for this package set
         def load_osdeps(file)
-            new_osdeps = OSDependencies.load(file)
-            @all_osdeps << new_osdeps
-            @osdeps.merge(@all_osdeps.last)
+            new_osdeps = OSPackageResolver.load(file)
+            all_osdeps << new_osdeps
+            os_package_resolver.merge(all_osdeps.last)
             new_osdeps
         end
 
         # Enumerate all osdeps package names from this package set
         def each_osdep(&block)
-            @osdeps.definitions.each_key(&block)
+            os_package_resolver.definitions.each_key(&block)
         end
 
         # True if this source has already been checked out on the local autoproj
@@ -222,7 +222,7 @@ def repository_id
         end
 
         # Remote sources can be accessed through a hidden directory in
-        # $AUTOPROJ_ROOT/.remotes, or through a symbolic link in
+        # {Workspace#remotes_dir}, or through a symbolic link in
         # autoproj/remotes/
         #
         # This returns the former. See #user_local_dir for the latter.
@@ -233,7 +233,7 @@ def raw_local_dir
         end
 
         # Remote sources can be accessed through a hidden directory in
-        # $AUTOPROJ_ROOT/.remotes, or through a symbolic link in
+        # {Workspace#remotes_dir}, or through a symbolic link in
         # autoproj/remotes/
         #
         # This returns the latter. See #raw_local_dir for the former.