autoproj 2.0.0.rc4 → 2.0.0.rc5

data/lib/autoproj/os_package_installer.rb

@@ -317,7 +317,11 @@ def install(packages, options = Hash.new)
 
             packages = os_package_resolver.resolve_os_packages(packages)
             packages = packages.map do |handler_name, list|
-                [package_managers[handler_name], list]
+                if manager = package_managers[handler_name]
+                    [package_managers[handler_name], list]
+                else
+                    raise ArgumentError, "no package manager called #{handler_name} found"
+                end
             end
 
             needs_filter = (filter_uptodate_packages? || filter_options[:install_only])

data/lib/autoproj/os_package_resolver.rb

@@ -122,6 +122,12 @@ def load_default
         # information in +definitions+ originates. It is a mapping from the
         # package name to the osdeps file' full path
         attr_reader :sources
+        # Controls whether the package resolver will prefer installing
+        # OS-independent packages (such as e.g. Gems) over their OS-provided
+        # equivalent (e.g. the packaged version of a gem)
+        def prefer_indep_over_os_packages?; !!@prefer_indep_over_os_packages end
+        # (see prefer_indep_over_os_packages?)
+        def prefer_indep_over_os_packages=(flag); @prefer_indep_over_os_packages = flag end
 
         # Use to override the autodetected OS-specific package handler
         attr_writer :os_package_manager
@@ -144,15 +150,15 @@ def os_package_manager
         # Returns the set of known package managers
         #
         # @return [Array<String>]
-        def package_managers
-            PACKAGE_MANAGERS
-        end
+        attr_reader :package_managers
 
         # The Gem::SpecFetcher object that should be used to query RubyGems, and
         # install RubyGems packages
         def initialize(defs = Hash.new, file = nil)
             @definitions = defs.to_hash
             @all_definitions = Hash.new { |h, k| h[k] = Array.new }
+            @package_managers = PACKAGE_MANAGERS.dup
+            @prefer_indep_over_os_packages = false
 
             @sources     = Hash.new
             @installed_packages = Set.new
@@ -200,7 +206,7 @@ def merge(info)
                         osdep_h
                     end
                     if old_resolved != new_resolved
-                        Autoproj.warn("osdeps definition for #{h}, previously defined in #{old} overridden by #{new}")
+                        Autoproj.warn("osdeps definition for #{h}, previously defined in #{old} overridden by #{new}: resp. #{old_resolved} and #{new_resolved}")
                     end
                 end
                 v2
@@ -491,7 +497,11 @@ def resolve_package(name)
 
             os_names, os_versions = self.class.operating_system
             os_names = os_names.dup
-            os_names << 'default'
+            if prefer_indep_over_os_packages?
+                os_names.unshift 'default'
+            else
+                os_names.push 'default'
+            end
 
             dep_def = definitions[name]
             if !dep_def

data/lib/autoproj/package_managers/bundler_manager.rb

@@ -28,16 +28,18 @@ def self.with_prerelease(*value)
             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)
+                orig_gem_path = (env['GEM_PATH'] || "").split(File::PATH_SEPARATOR).find_all do |p|
+                    !Workspace.in_autoproj_project?(p)
+                end
                 env.system_env['GEM_PATH'] = Gem.default_path
                 env.original_env['GEM_PATH'] = orig_gem_path.join(File::PATH_SEPARATOR)
 
+                if Workspace.in_autoproj_project?(env['GEM_HOME'])
+                    env.unset('GEM_HOME')
+                end
+
                 env.init_from_env 'RUBYLIB'
                 env.inherit 'RUBYLIB'
                 original_rubylib =
@@ -46,32 +48,33 @@ def initialize_environment
                             !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)
+                if system_rubylib = discover_rubylib
+                    env.system_env['RUBYLIB'] = []
+                    env.original_env['RUBYLIB'] = (original_rubylib - system_rubylib).join(File::PATH_SEPARATOR)
+                end
 
                 dot_autoproj = ws.dot_autoproj_dir
                 if ws.config.private_bundler?
-                    env.push_path 'GEM_PATH', File.join(dot_autoproj, 'bundler')
+                    env.add_path 'GEM_PATH', File.join(dot_autoproj, 'bundler')
                 end
                 if ws.config.private_autoproj?
-                    env.push_path 'GEM_PATH', File.join(dot_autoproj, 'autoproj')
+                    env.add_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')
+                        env.add_path 'GEM_PATH', File.join(reused_w.prefix_dir, 'gems')
                     end
-                    env.push_path 'PATH', File.join(reused_w.prefix_dir, 'gems', 'bin')
+                    env.add_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
+                    env.add_path 'GEM_PATH', gem_home
                 end
 
                 FileUtils.mkdir_p gem_home
@@ -83,18 +86,19 @@ def initialize_environment
                 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')
+                env.add_path 'PATH', File.join(gem_home, 'bin')
+                env.add_path 'PATH', File.join(ws.dot_autoproj_dir, 'autoproj', 'bin')
                 Autobuild.programs['bundler'] = File.join(ws.dot_autoproj_dir, 'autoproj', 'bin', 'bundler')
 
-                update_env_rubylib(system_rubylib)
+                if bundle_rubylib = discover_bundle_rubylib
+                    update_env_rubylib(bundle_rubylib, system_rubylib)
+                end
             end
 
-            def update_env_rubylib(system_rubylib = discover_rubylib)
-                rubylib = discover_bundle_rubylib
+            def update_env_rubylib(bundle_rubylib, system_rubylib = discover_rubylib)
                 current = ws.env.resolved_env['RUBYLIB'].split(File::PATH_SEPARATOR) + system_rubylib
-                (rubylib - current).each do |p|
-                    ws.env.push_path('RUBYLIB', p)
+                (bundle_rubylib - current).each do |p|
+                    ws.env.add_path('RUBYLIB', p)
                 end
             end
 
@@ -106,24 +110,56 @@ def parse_package_entry(entry)
                 end
             end
 
+            class NotCleanState < RuntimeError; end
+
+            def backup_files(mapping)
+                mapping.each do |file, backup_file|
+                    if File.file?(file)
+                        FileUtils.cp file, backup_file
+                    end
+                end
+            end
+
+            def backup_restore(mapping)
+                mapping.each do |file, backup_file|
+                    if File.file?(backup_file)
+                        FileUtils.cp backup_file, file
+                    end
+                end
+            end
+
+            def backup_clean(mapping)
+                mapping.each do |file, backup_file|
+                    if File.file?(backup_file)
+                        FileUtils.rm backup_file
+                    end
+                end
+            end
+
             def install(gems)
-                # Generate the gemfile
+                root_dir     = File.join(ws.prefix_dir, 'gems')
+                gemfile_path = File.join(root_dir, 'Gemfile')
+                gemfile_lock_path = "#{gemfile_path}.lock"
+                backups = Hash[
+                    gemfile_path => "#{gemfile_path}.orig",
+                    gemfile_lock_path => "#{gemfile_lock_path}.orig"
+                ]
+
+                # Back up the existing gemfile, we'll restore it if something is
+                # wrong to avoid leaving bundler in an inconsistent state
+                backup_files(backups)
+
+                # Generate the gemfile and remove the lockfile
                 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|
+                File.open(gemfile_path, '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
+                FileUtils.rm File.join(root_dir, 'Gemfile.lock')
 
                 if ws.config.private_gems?
                     options = ['--path', root_dir]
@@ -133,9 +169,9 @@ def install(gems)
                     connections = Set.new
                     Autobuild::Subprocess.run 'autoproj', 'osdeps',
                         Autobuild.tool('bundler'), 'install',
-                            "--gemfile=#{gemfile}", *options,
+                            "--gemfile=#{gemfile_path}", *options,
                             "--binstubs", File.join(root_dir, 'bin'),
-                            env: Hash['BUNDLE_GEMFILE' => gemfile] do |line|
+                            env: Hash['BUNDLE_GEMFILE' => gemfile_path] do |line|
 
                         case line
                         when /Installing (.*)/
@@ -150,28 +186,44 @@ def install(gems)
                     end
                 end
 
-                update_env_rubylib
+                if bundle_rubylib = discover_bundle_rubylib
+                    update_env_rubylib(bundle_rubylib)
+                else
+                    raise NotCleanState, "bundler executed successfully, but the result is not in a clean state"
+                end
+
+            rescue Exception => e
+                backup_restore(backups)
+                raise
+            ensure
+                backup_clean(backups)
             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? }
+                Tempfile.open 'autoproj-rubylib' do |io|
+                    result = Bundler.clean_system(
+                        Hash['RUBYLIB' => nil],
+                        Autobuild.tool('ruby'), '-e', 'puts $LOAD_PATH',
+                        out: io)
+                        #err: '/dev/null')
+                    if result
+                        io.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
+                    end
+                end
             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? }
+                Tempfile.open 'autoproj-rubylib' do |io|
+                    result = Bundler.clean_system(
+                        Hash['BUNDLE_GEMFILE' => gemfile],
+                        Autobuild.tool('bundler'), 'exec', 'ruby', '-e', 'puts $LOAD_PATH',
+                        out: io)
+                        #err: '/dev/null')
+                    if result
+                        io.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
+                    end
+                end
             end
         end
     end

data/lib/autoproj/package_set.rb

@@ -571,8 +571,9 @@ def provides?(name)
 
     # Specialization of the PackageSet class for the overrides listed in autoproj/
     class LocalPackageSet < PackageSet
-        def initialize(manifest)
+        def initialize(manifest, local_dir = nil)
             super(manifest, manifest.vcs)
+            @local_dir = local_dir
         end
 
         def name
@@ -592,14 +593,10 @@ def local?
         end
 
         def local_dir
-            if manifest.file
-                File.dirname(manifest.file)
-            end
+            @local_dir || (File.dirname(manifest.file) if manifest.file)
         end
 
-        def raw_local_dir
-            local_dir
-        end
+        def raw_local_dir; local_dir end
 
         def manifest_path
             manifest.file

data/lib/autoproj/reporter.rb

@@ -58,6 +58,8 @@ def self.report(options = Hash.new)
             silent: false,
             debug: Autobuild.debug
 
+        reporter = Autoproj::Reporter.new
+        Autobuild::Reporting << reporter
         Autobuild::Reporting.report do
             yield
         end
@@ -86,6 +88,8 @@ def self.report(options = Hash.new)
         if options[:debug] then raise
         else exit 1
         end
+    ensure
+        Autobuild::Reporting.remove(reporter) if reporter
     end
 end
 

data/lib/autoproj/system.rb

@@ -11,7 +11,7 @@ def self.create_symlink(from, to)
 
     # Returns true if +path+ is part of an autoproj installation
     def self.in_autoproj_installation?(path)
-        !!Workspace.find_workspace_dir(path, 'workspace')
+        !!find_workspace_dir(path, 'workspace')
     end
 
     # Forcefully sets the root directory
@@ -33,7 +33,7 @@ def self.root_dir(dir = Dir.pwd)
         if @root_dir
             return @root_dir
         end
-        path = Workspace.find_root_dir(dir)
+        path = Autoproj.find_workspace_dir(dir)
         if !path
             raise UserError, "not in a Autoproj installation"
         end

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "2.0.0.rc4"
+    VERSION = "2.0.0.rc5"
 end

data/lib/autoproj/workspace.rb

@@ -19,10 +19,7 @@ def initialize(root_dir)
             env.source_before(File.join(dot_autoproj_dir, 'env.sh'))
             @manifest = Manifest.new
             @os_package_installer = OSPackageInstaller.new(self, os_package_resolver)
-
-            Autobuild.env = nil
             env.prepare(root_dir)
-
             super(root_dir)
         end
 
@@ -53,21 +50,25 @@ def self.from_pwd
         #   and the one from +dir+ mismatch
         # @raise [NotWorkspace] if dir is not within an autoproj workspace
         def self.from_dir(dir)
-            if path = find_workspace_dir(dir)
+            if path = Autoproj.find_workspace_dir(dir)
                 # Make sure that the currently loaded env.sh is actually us
                 env = autoproj_current_root
                 if env && env != path
                     raise MismatchingWorkspace, "the current environment is for #{env}, but you are in #{path}, make sure you are loading the right #{ENV_FILENAME} script !"
                 end
                 Workspace.new(path)
+            elsif find_v1_workspace_dir(dir)
+                raise OutdatedWorkspace, "#{dir} looks like a v1 workspace, run autoproj upgrade before continuing"
             else
                 raise NotWorkspace, "not in a Autoproj installation"
             end
         end
 
         def self.from_environment
-            if path = (find_workspace_dir || autoproj_current_root)
+            if path = Autoproj.find_workspace_dir
                 from_dir(path)
+            elsif Autoproj.find_v1_workspace_dir(dir = Autoproj.defaulT_find_base_dir)
+                raise OutdatedWorkspace, "#{dir} looks like a v1 workspace, run autoproj upgrade before continuing"
             else
                 raise NotWorkspace, "not in an Autoproj installation, and no env.sh has been loaded so far"
             end
@@ -76,64 +77,7 @@ def self.from_environment
         # Tests whether the given path is under a directory tree managed by
         # autoproj
         def self.in_autoproj_project?(path)
-            !!find_workspace_dir(path)
-        end
-
-        # @private
-        #
-        # Finds an autoproj "root directory" that contains a given directory. It
-        # can either be the root of a workspace or the root of an install
-        # directory
-        #
-        # @param [String] base_dir the start of the search
-        # @param [String] config_field_name the name of a field in the root's
-        #   configuration file, that should be returned instead of the root
-        #   itself
-        # @return [String,nil] the root of the workspace directory, or nil if
-        #   there's none
-        def self.find_root_dir(base_dir, config_field_name)
-            path = Pathname.new(base_dir)
-            while !path.root?
-                if (path + ".autoproj").exist?
-                    break
-                end
-                path = path.parent
-            end
-
-            if path.root?
-                return
-            end
-
-            config_path = path + ".autoproj" + "config.yml"
-            if config_path.exist?
-                config = YAML.load(config_path.read) || Hash.new
-                result = config[config_field_name] || path.to_s
-                result = File.expand_path(result, path.to_s)
-            else
-                result = path.to_s 
-            end
-
-            # I don't know if this is still useful or not ... but it does not hurt
-            #
-            # Preventing backslashed in path, that might be confusing on some path compares
-            if Autobuild.windows?
-                result = result.gsub(/\\/,'/')
-            end
-            result
-        end
-
-        # Finds the workspace root that contains a directory
-        #
-        # @return [String,nil]
-        def self.find_workspace_dir(base_dir = Dir.pwd)
-            find_root_dir(base_dir, 'workspace')
-        end
-
-        # Looks for the autoproj prefix that contains a given directory
-        #
-        # @return [String,nil]
-        def self.find_prefix_dir(base_dir = Dir.pwd)
-            find_root_dir(base_dir, 'prefix')
+            !!Autoproj.find_workspace_dir(path)
         end
 
         def load(*args)