autoproj 2.12.0 → 2.15.0

data/lib/autoproj/ops/atomic_write.rb

@@ -2,9 +2,9 @@ module Autoproj
     module Ops
         # Shamelessly stolen from ActiveSupport
         def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
-            require 'tempfile' unless defined?(Tempfile)
-            require 'fileutils' unless defined?(FileUtils)
-    
+            require "tempfile" unless defined?(Tempfile)
+            require "fileutils" unless defined?(FileUtils)
+
             temp_file = Tempfile.new(File.basename(file_name), temp_dir)
             yield temp_file
             temp_file.flush
@@ -12,15 +12,16 @@ module Autoproj
             rescue NotImplementedError
             end
             temp_file.close
-    
+
             begin
                 # Get original file permissions
                 old_stat = File.stat(file_name)
             rescue Errno::ENOENT
                 # No old permissions, write a temp file to determine the defaults
                 check_name = File.join(
-                    File.dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}")
-                File.open(check_name, "w") { }
+                    File.dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}"
+                )
+                File.open(check_name, "w") {}
                 old_stat = File.stat(check_name)
                 File.unlink(check_name)
             end

data/lib/autoproj/ops/build.rb

@@ -1,4 +1,4 @@
-require 'erb'
+require "erb"
 module Autoproj
     module Ops
         # Operations related to building packages
@@ -77,7 +77,6 @@ module Autoproj
                 build_packages(all_enabled_packages)
             end
 
-
             # Builds the listed packages
             #
             # Only build steps that are actually needed will be performed. See
@@ -89,7 +88,7 @@ module Autoproj
             def build_packages(all_enabled_packages, options = Hash.new)
                 if @report_path
                     reporting = Ops::PhaseReporting.new(
-                        'build', @report_path, method(:package_metadata)
+                        "build", @report_path, method(:package_metadata)
                     )
                 end
 
@@ -99,11 +98,10 @@ module Autoproj
                 begin
                     Autobuild.apply(
                         all_enabled_packages,
-                        "autoproj-build", ['build'], options
+                        "autoproj-build", ["build"], options
                     ) do |pkg, phase|
-                        reporting&.report_incremental(pkg) if phase == 'build'
+                        reporting&.report_incremental(pkg) if phase == "build"
                     end
-
                 ensure
                     packages = all_enabled_packages.map do |name|
                         @manifest.find_autobuild_package(name)

data/lib/autoproj/ops/cache.rb

@@ -12,20 +12,18 @@ module Autoproj
 
             def with_retry(count)
                 (count + 1).times do |i|
-                    begin
-                        break yield
-                    rescue Autobuild::SubcommandFailed
-                        if i == count
-                            raise
-                        else
-                            Autobuild.message "  failed, retrying (#{i}/#{count})"
-                        end
+                    break yield
+                rescue Autobuild::SubcommandFailed
+                    if i == count
+                        raise
+                    else
+                        Autobuild.message "  failed, retrying (#{i}/#{count})"
                     end
                 end
             end
 
             def git_cache_dir
-                File.join(cache_dir, 'git')
+                File.join(cache_dir, "git")
             end
 
             def cache_git(pkg, checkout_only: false)
@@ -34,37 +32,37 @@ module Autoproj
 
                 pkg.importer.local_branch = nil
                 pkg.importer.remote_branch = nil
-                pkg.importer.remote_name = 'autobuild'
+                pkg.importer.remote_name = "autobuild"
 
                 unless File.directory?(pkg.importdir)
                     FileUtils.mkdir_p File.dirname(pkg.importdir)
                     Autobuild::Subprocess.run(
                         "autoproj-cache", "import", Autobuild.tool(:git),
-                        "--git-dir", pkg.importdir, 'init', "--bare"
+                        "--git-dir", pkg.importdir, "init", "--bare"
                     )
                 end
-                pkg.importer.update_remotes_configuration(pkg)
+                pkg.importer.update_remotes_configuration(pkg, only_local: false)
 
                 with_retry(10) do
                     Autobuild::Subprocess.run(
-                        'autoproj-cache', :import, Autobuild.tool('git'),
-                        '--git-dir', pkg.importdir, 'remote', 'update', 'autobuild'
+                        "autoproj-cache", :import, Autobuild.tool("git"),
+                        "--git-dir", pkg.importdir, "remote", "update", "autobuild"
                     )
                 end
                 with_retry(10) do
                     Autobuild::Subprocess.run(
-                        'autoproj-cache', :import, Autobuild.tool('git'),
-                        '--git-dir', pkg.importdir, 'fetch', 'autobuild', '--tags'
+                        "autoproj-cache", :import, Autobuild.tool("git"),
+                        "--git-dir", pkg.importdir, "fetch", "autobuild", "--tags"
                     )
                 end
                 Autobuild::Subprocess.run(
-                    'autoproj-cache', :import, Autobuild.tool('git'),
-                    '--git-dir', pkg.importdir, 'gc', '--prune=all'
+                    "autoproj-cache", :import, Autobuild.tool("git"),
+                    "--git-dir", pkg.importdir, "gc", "--prune=all"
                 )
             end
 
             def archive_cache_dir
-                File.join(cache_dir, 'archives')
+                File.join(cache_dir, "archives")
             end
 
             def cache_archive(pkg)
@@ -75,25 +73,25 @@ module Autoproj
             end
 
             def create_or_update(*package_names, all: true, keep_going: false,
-                                 checkout_only: false)
+                checkout_only: false)
                 FileUtils.mkdir_p cache_dir
 
-                if package_names.empty?
-                    packages =
+                packages =
+                    if package_names.empty?
                         if all
                             manifest.each_autobuild_package
                         else
                             manifest.all_selected_source_packages.map(&:autobuild)
                         end
-                else
-                    packages = package_names.map do |name|
-                        if (pkg = manifest.find_autobuild_package(name))
-                            pkg
-                        else
-                            raise PackageNotFound, "no package named #{name}"
+                    else
+                        package_names.map do |name|
+                            if (pkg = manifest.find_autobuild_package(name))
+                                pkg
+                            else
+                                raise PackageNotFound, "no package named #{name}"
+                            end
                         end
                     end
-                end
 
                 packages = packages.sort_by(&:name)
 
@@ -107,13 +105,20 @@ module Autoproj
                     begin
                         case pkg.importer
                         when Autobuild::Git
-                            Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (git)"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] caching #{pkg.name} (git)"
+                            )
                             cache_git(pkg, checkout_only: checkout_only)
                         when Autobuild::ArchiveImporter
-                            Autoproj.message "  [#{i}/#{total}] caching #{pkg.name} (archive)"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] caching #{pkg.name} (archive)"
+                            )
                             cache_archive(pkg)
                         else
-                            Autoproj.message "  [#{i}/#{total}] not caching #{pkg.name} (cannot cache #{pkg.importer.class})"
+                            Autoproj.message(
+                                "  [#{i}/#{total}] not caching #{pkg.name} "\
+                                "(cannot cache #{pkg.importer.class})"
+                            )
                         end
                     rescue Interrupt
                         raise
@@ -121,10 +126,10 @@ module Autoproj
                         raise unless keep_going
 
                         pkg.error "       failed to cache #{pkg.name}, "\
-                                  'but going on as requested'
+                                  "but going on as requested"
                         lines = e.to_s.split('\n')
                         lines = e.message.split('\n') if lines.empty?
-                        lines = ['unknown error'] if lines.empty?
+                        lines = ["unknown error"] if lines.empty?
                         pkg.message(lines.shift, :red, :bold)
                         lines.each do |line|
                             pkg.message(line)
@@ -135,15 +140,15 @@ module Autoproj
             end
 
             def gems_cache_dir
-                File.join(cache_dir, 'package_managers', 'gem')
+                File.join(cache_dir, "package_managers", "gem")
             end
 
             def create_or_update_gems(keep_going: true, compile_force: false, compile: [])
                 # Note: this might directly copy into the cache directoy, and
                 # we support it later
-                cache_dir = File.join(@ws.prefix_dir, 'gems', 'vendor', 'cache')
+                cache_dir = File.join(@ws.prefix_dir, "gems", "vendor", "cache")
                 PackageManagers::BundlerManager.run_bundler(
-                    @ws, 'cache'
+                    @ws, "cache"
                 )
 
                 FileUtils.mkdir_p(gems_cache_dir) unless File.exist?(gems_cache_dir)
@@ -170,7 +175,9 @@ module Autoproj
                         next if !compile_force && File.file?(expected_platform_gem)
 
                         begin
-                            compile_gem(gem, artifacts: artifacts, output: real_target_dir)
+                            compile_gem(
+                                gem, artifacts: artifacts, output: real_target_dir
+                            )
                         rescue CompilationFailed
                             unless keep_going
                                 raise CompilationFailed, "#{gem} failed to compile"
@@ -200,32 +207,36 @@ module Autoproj
             end
 
             def guess_gem_program
-                if Autobuild.programs['gem']
-                    return Autobuild.programs['gem']
-                end
+                return Autobuild.programs["gem"] if Autobuild.programs["gem"]
 
-                ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
-                ruby_bindir = RbConfig::CONFIG['bindir']
+                ruby_bin = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
+                ruby_bindir = RbConfig::CONFIG["bindir"]
 
-                candidates = ['gem']
-                if ruby_bin =~ /^ruby(.+)$/
-                    candidates << "gem#{$1}"
-                end
+                candidates = ["gem"]
+                candidates << "gem#{$1}" if ruby_bin =~ /^ruby(.+)$/
 
                 candidates.each do |gem_name|
                     if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
-                        Autobuild.programs['gem'] = gem_full_path
-                        return Autobuild.programs['gem']
+                        Autobuild.programs["gem"] = gem_full_path
+                        return Autobuild.programs["gem"]
                     end
                 end
 
-                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
+                raise ArgumentError,
+                      "cannot find a gem program (tried "\
+                      "#{candidates.sort.join(', ')} in #{ruby_bindir})"
             end
 
             private def compile_gem(gem_path, output:, artifacts: [])
-                artifacts = artifacts.flat_map { |n| ["--artifact", n] }
-                unless system(Autobuild.tool('ruby'), '-S', guess_gem_program,
-                              'compile', '--output', output, *artifacts, gem_path)
+                artifacts = artifacts.flat_map do |include, n|
+                    if include
+                        ["--include", n]
+                    else
+                        ["--exclude", n]
+                    end
+                end
+                unless system(Autobuild.tool("ruby"), "-S", guess_gem_program,
+                              "compile", "--output", output, *artifacts, gem_path)
                     raise CompilationFailed, "#{gem_path} failed to compile"
                 end
             end

data/lib/autoproj/ops/cached_env.rb

@@ -1,17 +1,18 @@
-require 'autobuild/environment'
+require "autobuild/environment"
 
 module Autoproj
     module Ops
         def self.cached_env_path(root_dir)
-            File.join(root_dir, '.autoproj', 'env.yml')
+            File.join(root_dir, ".autoproj", "env.yml")
         end
 
         def self.load_cached_env(root_dir)
             path = cached_env_path(root_dir)
             if File.file?(path)
-                env = YAML.load(File.read(path))
+                env = YAML.safe_load(File.read(path))
                 Autobuild::Environment::ExportedEnvironment.new(
-                    env['set'], env['unset'], env['update'])
+                    env["set"], env["unset"], env["update"]
+                )
             end
         end
 
@@ -20,11 +21,11 @@ module Autoproj
             path = cached_env_path(root_dir)
             existing =
                 begin
-                    YAML.load(File.read(path))
+                    YAML.safe_load(File.read(path))
                 rescue Exception
                 end
 
-            env = Hash['set' => env.set, 'unset' => env.unset, 'update' => env.update]
+            env = Hash["set" => env.set, "unset" => env.unset, "update" => env.update]
             if env != existing
                 Ops.atomic_write(path) do |io|
                     io.write YAML.dump(env)