autoproj 2.0.0.rc5 → 2.0.0.rc6

data/lib/autoproj/ops/snapshot.rb

@@ -234,7 +234,7 @@ def save_import_state(name, versions)
             # Ensure that our ref is being logged
             FileUtils.touch File.join(git_dir, 'logs', *self.class.import_state_log_ref.split("/"))
             # Create the commit with the versions info
-            commit_id = Snapshot.create_commit(main, import_state_log_file, name) do |io|
+            commit_id = Snapshot.create_commit(main, import_state_log_file, name, real_author: false) do |io|
                 YAML.dump(versions, io)
             end
             # And save it in our reflog
@@ -257,7 +257,7 @@ def save_import_state(name, versions)
         #   the root of the git repository
         # @param [String] the commit message
         # @return [String] the commit ID
-        def self.create_commit(pkg, path, message, parent_id = nil)
+        def self.create_commit(pkg, path, message, parent_id = nil, real_author: true)
             importer = pkg.importer
             object_id = Tempfile.open 'autoproj-versions' do |io|
                 yield(io)
@@ -274,6 +274,14 @@ def self.create_commit(pkg, path, message, parent_id = nil)
 
             parent_id ||= importer.rev_parse(pkg, 'HEAD')
 
+            env = Hash.new
+            if !real_author
+                env['GIT_AUTHOR_NAME'] = 'autoproj'
+                env['GIT_AUTHOR_EMAIL'] = 'autoproj'
+                env['GIT_COMMITTER_NAME'] = 'autoproj'
+                env['GIT_COMMITTER_EMAIL'] = 'autoproj'
+            end
+
             # Create the tree using a temporary index in order to not mess with
             # the user's index state. read-tree initializes the new index and
             # then we add the overrides file with update-index / write-tree
@@ -294,7 +302,7 @@ def self.create_commit(pkg, path, message, parent_id = nil)
 
             importer.run_git_bare(
                 pkg, 'commit-tree',
-                tree_id, '-p', parent_id, input_streams: [message]).first
+                tree_id, '-p', parent_id, env: env, input_streams: [message]).first
         end
     end
     end

data/lib/autoproj/os_package_installer.rb

@@ -160,7 +160,7 @@ def osdeps_mode_option_supported_os(config)
         end
 
         def define_osdeps_mode_option
-            if OSPackageResolver.supported_operating_system?
+            if os_package_resolver.supported_operating_system?
                 osdeps_mode_option_supported_os(ws.config)
             else
                 osdeps_mode_option_unsupported_os(ws.config)

data/lib/autoproj/os_package_resolver.rb

@@ -137,7 +137,7 @@ def prefer_indep_over_os_packages=(flag); @prefer_indep_over_os_packages = flag
         # @return [String]
         def os_package_manager
             if !instance_variable_defined?(:@os_package_manager)
-                os_names, _ = OSPackageResolver.operating_system
+                os_names, _ = operating_system
                 os_name = os_names.find { |name| OS_PACKAGE_MANAGERS[name] }
                 @os_package_manager = OS_PACKAGE_MANAGERS[os_name]
                 if !@os_package_manager
@@ -162,6 +162,7 @@ def initialize(defs = Hash.new, file = nil)
 
             @sources     = Hash.new
             @installed_packages = Set.new
+            @operating_system = self.class.operating_system
             if file
                 defs.each_key do |package_name|
                     sources[package_name] = file
@@ -246,7 +247,7 @@ def self.verify_definitions(hash, path = [])
 
         # Returns true if it is possible to install packages for the operating
         # system on which we are installed
-        def self.supported_operating_system?
+        def supported_operating_system?
             if @supported_operating_system.nil?
                 os_names, _ = operating_system
                 @supported_operating_system =
@@ -258,13 +259,6 @@ def self.supported_operating_system?
             return @supported_operating_system
         end
 
-        # Used mainly during testing to bypass the operating system
-        # autodetection
-        def self.operating_system=(values)
-            @supported_operating_system = nil
-            @operating_system = values
-        end
-
         def self.guess_operating_system
             if File.exists?('/etc/debian_version')
                 versions = [File.read('/etc/debian_version').strip]
@@ -345,6 +339,23 @@ def self.normalize_os_representation(names, versions)
             return names, versions
         end
 
+        def operating_system
+            @operating_system || self.class.operating_system
+        end
+
+        def operating_system=(values)
+            @supported_operating_system = nil
+            @operating_system = values
+        end
+
+        def self.operating_system
+            @operating_system
+        end
+
+        def self.operating_system=(values)
+            @operating_system = values
+        end
+
         # Autodetects the operating system name and version
         #
         # +osname+ is the operating system name, all in lowercase (e.g. ubuntu,
@@ -355,41 +366,16 @@ def self.normalize_os_representation(names, versions)
         # one.
         #
         # Examples: ['debian', ['sid', 'unstable']] or ['ubuntu', ['lucid lynx', '10.04']]
-        def self.operating_system(options = Hash.new)
-            # Validate the options. We check on the availability of
-            # validate_options as to not break autoproj_bootstrap (in which
-            # validate_options is not available)
-            options = validate_options options, force: false, config: Autoproj.config
-            config  = options.fetch(:config)
-
+        def self.autodetect_operating_system
             if user_os = ENV['AUTOPROJ_OS']
-                @operating_system =
-                    if user_os.empty? then false
-                    else
-                        names, versions = user_os.split(':')
-                        normalize_os_representation(names.split(','), versions.split(','))
-                    end
-                return @operating_system
-            end
-
-
-            if options[:force]
-                @operating_system = nil
-            elsif !@operating_system.nil? # @operating_system can be set to false to simulate an unknown OS
-                return @operating_system
-            elsif config.has_value_for?('operating_system')
-                os = config.get('operating_system')
-                if os.respond_to?(:to_ary)
-                    if os[0].respond_to?(:to_ary) && os[0].all? { |s| s.respond_to?(:to_str) } &&
-                       os[1].respond_to?(:to_ary) && os[1].all? { |s| s.respond_to?(:to_str) }
-                       @operating_system = os
-                       return os
-                    end
+                if user_os.empty?
+                    return false
+                else
+                    names, versions = user_os.split(':')
+                    return normalize_os_representation(names.split(','), versions.split(','))
                 end
-                @operating_system = nil # Invalid OS format in the configuration file
             end
 
-            Autobuild.progress :operating_system_autodetection, "autodetecting the operating system"
             names, versions = os_from_os_release
 
             if !names
@@ -415,13 +401,7 @@ def self.operating_system(options = Hash.new)
 
             names = ensure_derivatives_refer_to_their_parents(names)
             names, versions = normalize_os_representation(names, versions)
-
-            @operating_system = [names, versions]
-            config.set('operating_system', @operating_system, true)
-            Autobuild.progress :operating_system_autodetection, "operating system: #{(names - ['default']).join(",")} - #{(versions - ['default']).join(",")}"
-            @operating_system
-        ensure
-            Autobuild.progress_done :operating_system_autodetection
+            return [names, versions]
         end
 
         def self.os_from_os_release(filename = '/etc/os-release')
@@ -495,7 +475,7 @@ def resolve_package(name)
             path = self.class.resolve_name(name)
             name = path.last
 
-            os_names, os_versions = self.class.operating_system
+            os_names, os_versions = operating_system
             os_names = os_names.dup
             if prefer_indep_over_os_packages?
                 os_names.unshift 'default'
@@ -712,7 +692,7 @@ def resolve_os_packages(dependencies)
 
                 if result.empty?
                     if self.class.supported_operating_system?
-                        os_names, os_versions = self.class.operating_system
+                        os_names, os_versions = 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_manager, FOUND_PACKAGES, [name]]]
@@ -781,9 +761,9 @@ def availability_of(name)
             end
 
             if resolved.empty?
-                if !self.class.operating_system
+                if !operating_system
                     return UNKNOWN_OS
-                elsif !self.class.supported_operating_system?
+                elsif !supported_operating_system?
                     return AVAILABLE
                 else return WRONG_OS
                 end

data/lib/autoproj/package_managers/bundler_manager.rb

@@ -30,13 +30,9 @@ def initialize_environment
 
                 env.inherit 'GEM_PATH'
                 env.init_from_env 'GEM_PATH'
-                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'])
+                if env.original_env['GEM_HOME'].empty?
                     env.unset('GEM_HOME')
                 end
 
@@ -44,8 +40,7 @@ def initialize_environment
                 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) &&
+                        !p.start_with?(Bundler.rubygems.gem_dir) &&
                             !Bundler.rubygems.gem_path.any? { |gem_p| p.start_with?(p) }
                     end
                 if system_rubylib = discover_rubylib
@@ -53,15 +48,7 @@ def initialize_environment
                     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.add_path 'GEM_PATH', File.join(dot_autoproj, 'bundler')
-                end
-                if ws.config.private_autoproj?
-                    env.add_path 'GEM_PATH', File.join(dot_autoproj, 'autoproj')
-                end
-
-                ws.manifest.each_reused_autoproj_installation do |p|
+                ws.config.each_reused_autoproj_installation do |p|
                     reused_w = ws.new(p)
                     reused_c = reused_w.load_config
                     if reused_c.private_gems?
@@ -70,7 +57,6 @@ def initialize_environment
                     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
@@ -86,9 +72,19 @@ def initialize_environment
                 end
 
                 env.set 'BUNDLE_GEMFILE', File.join(gem_home, 'Gemfile')
+                env.add_path 'PATH', Gem.bindir
                 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')
+
+                dot_autoproj = ws.dot_autoproj_dir
+                if ws.config.private_bundler?
+                    env.add_path 'PATH', File.join(dot_autoproj, 'bundler', 'bin')
+                    env.add_path 'GEM_PATH', File.join(dot_autoproj, 'bundler')
+                end
+                env.add_path 'PATH', File.join(dot_autoproj, 'autoproj', 'bin')
+                if ws.config.private_autoproj?
+                    env.add_path 'GEM_PATH', File.join(dot_autoproj, 'autoproj')
+                end
+                Autobuild.programs['bundler'] = 'bundler'
 
                 if bundle_rubylib = discover_bundle_rubylib
                     update_env_rubylib(bundle_rubylib, system_rubylib)
@@ -96,7 +92,7 @@ def initialize_environment
             end
 
             def update_env_rubylib(bundle_rubylib, system_rubylib = discover_rubylib)
-                current = ws.env.resolved_env['RUBYLIB'].split(File::PATH_SEPARATOR) + system_rubylib
+                current = (ws.env.resolved_env['RUBYLIB'] || '').split(File::PATH_SEPARATOR) + system_rubylib
                 (bundle_rubylib - current).each do |p|
                     ws.env.add_path('RUBYLIB', p)
                 end
@@ -148,6 +144,11 @@ def install(gems)
                 # Back up the existing gemfile, we'll restore it if something is
                 # wrong to avoid leaving bundler in an inconsistent state
                 backup_files(backups)
+                if !File.file?("#{gemfile_path}.orig")
+                    File.open("#{gemfile_path}.orig", 'w') do |io|
+                        io.puts "eval_gemfile \"#{File.join(ws.dot_autoproj_dir, 'autoproj', 'Gemfile')}\""
+                    end
+                end
 
                 # Generate the gemfile and remove the lockfile
                 gems = gems.sort.map do |name|
@@ -161,16 +162,14 @@ def install(gems)
                 end
                 FileUtils.rm File.join(root_dir, 'Gemfile.lock')
 
-                if ws.config.private_gems?
-                    options = ['--path', root_dir]
-                end
-
+                binstubs_path = File.join(root_dir, 'bin')
                 Bundler.with_clean_env do
                     connections = Set.new
                     Autobuild::Subprocess.run 'autoproj', 'osdeps',
                         Autobuild.tool('bundler'), 'install',
                             "--gemfile=#{gemfile_path}", *options,
-                            "--binstubs", File.join(root_dir, 'bin'),
+                            "--binstubs", binstubs_path,
+                            "--shebang", Gem.ruby,
                             env: Hash['BUNDLE_GEMFILE' => gemfile_path] do |line|
 
                         case line
@@ -196,6 +195,7 @@ def install(gems)
                 backup_restore(backups)
                 raise
             ensure
+                FileUtils.rm_f File.join(binstubs_path, 'bundler')
                 backup_clean(backups)
             end
 
@@ -204,8 +204,8 @@ def discover_rubylib
                     result = Bundler.clean_system(
                         Hash['RUBYLIB' => nil],
                         Autobuild.tool('ruby'), '-e', 'puts $LOAD_PATH',
-                        out: io)
-                        #err: '/dev/null')
+                        out: io,
+                        err: '/dev/null')
                     if result
                         io.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
                     end
@@ -218,8 +218,8 @@ def discover_bundle_rubylib
                     result = Bundler.clean_system(
                         Hash['BUNDLE_GEMFILE' => gemfile],
                         Autobuild.tool('bundler'), 'exec', 'ruby', '-e', 'puts $LOAD_PATH',
-                        out: io)
-                        #err: '/dev/null')
+                        out: io,
+                        err: '/dev/null')
                     if result
                         io.readlines.map { |l| l.chomp }.find_all { |l| !l.empty? }
                     end

data/lib/autoproj/package_managers/gem_manager.rb

@@ -38,7 +38,7 @@ def initialize_environment
                 env.system_env['GEM_PATH'] = Gem.default_path
                 env.original_env['GEM_PATH'] = orig_gem_path.join(File::PATH_SEPARATOR)
 
-                ws.manifest.each_reused_autoproj_installation do |p|
+                ws.config.each_reused_autoproj_installation do |p|
                     p_gems = File.join(p, '.gems')
                     if File.directory?(p_gems)
                         env.push_path 'GEM_PATH', p_gems

data/lib/autoproj/package_managers/shell_script_manager.rb

@@ -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 = OSPackageResolver.supported_operating_system?
+                handled_os = ws.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/version.rb

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

data/lib/autoproj/workspace.rb

@@ -18,6 +18,7 @@ def initialize(root_dir)
             @env = Environment.new
             env.source_before(File.join(dot_autoproj_dir, 'env.sh'))
             @manifest = Manifest.new
+
             @os_package_installer = OSPackageInstaller.new(self, os_package_resolver)
             env.prepare(root_dir)
             super(root_dir)
@@ -173,6 +174,8 @@ def load_config(reconfigure = false)
                     manifest.vcs = VCSDefinition.from_raw(
                         type: 'local', url: config_dir)
                 end
+                os_package_resolver.prefer_indep_over_os_packages = config.prefer_indep_over_os_packages?
+                OSPackageResolver.operating_system ||= config.get('operating_system', nil)
             end
             @config
         end
@@ -183,8 +186,43 @@ def load_manifest
             end
         end
 
+        def autodetect_operating_system(force: false)
+            if force || !os_package_resolver.operating_system
+                begin
+                    Autobuild.progress_start :operating_system_autodetection,
+                        "autodetecting the operating system"
+                    names, versions = OSPackageResolver.autodetect_operating_system
+                    OSPackageResolver.operating_system = [names, versions]
+                    Autobuild.progress :operating_system_autodetection,
+                        "operating system: #{(names - ['default']).join(",")} - #{(versions - ['default']).join(",")}"
+                ensure
+                    Autobuild.progress_done :operating_system_autodetection
+                end
+                config.set('operating_system', os_package_resolver.operating_system, true)
+            end
+        end
+
+        def operating_system
+            os_package_resolver.operating_system
+        end
+
+        def supported_operating_system?
+            os_package_resolver.supported_operating_system?
+        end
+
+        def setup_os_package_installer
+            autodetect_operating_system
+            os_package_installer.each_manager do |pkg_mng|
+                pkg_mng.initialize_environment
+            end
+            os_package_resolver.load_default
+            os_package_installer.define_osdeps_mode_option
+            os_package_installer.osdeps_mode
+        end
+
         def setup
             load_config
+            autodetect_operating_system
             config.validate_ruby_executable
             config.apply_autobuild_configuration
             load_autoprojrc
@@ -206,14 +244,7 @@ def setup
                 Autobuild::Importer.default_cache_dirs = cache_dir
             end
             env.prepare(root_dir)
-            os_package_installer.each_manager do |pkg_mng|
-                pkg_mng.initialize_environment
-            end
-
-            os_package_resolver.load_default
-            os_package_installer.define_osdeps_mode_option
-            os_package_installer.osdeps_mode
-
+            setup_os_package_installer
             install_ruby_shims
         end
 
@@ -333,6 +364,10 @@ def load_osdeps_from_package_sets
         end
 
         def load_package_sets(options = Hash.new)
+            if !File.file?(manifest_file_path) # empty install, just return
+                return
+            end
+
             options = validate_options options,
                 only_local: false,
                 checkout_only: true,
@@ -525,7 +560,9 @@ def finalize_package_setup
             end
 
             manifest.each_package_set do |source|
-                load_if_present(source, source.local_dir, "overrides.rb")
+                if source.local_dir
+                    load_if_present(source, source.local_dir, "overrides.rb")
+                end
             end
 
             Dir.glob(File.join( overrides_dir, "*.rb" ) ).sort.each do |file|