autoproj 2.0.0.rc38 → 2.0.0.rc39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b53d93cd01cc0b8c5e434458cb24c73edfd49c9
-  data.tar.gz: a1d11757027126a5fbb843bf96f040b3d54f5964
+  metadata.gz: d50b298207a3006893877e6c968a46ec5614ed91
+  data.tar.gz: f6e394d4adb73e2d0f4ed6f9d2e8113e041aede9
 SHA512:
-  metadata.gz: ab152231c4aa64cb65edcc79ffb0bf17493b3e538bb6197218b04c6436c8ea5990155e9173f2b03354b69b96567177bbdc2a4613d0e652003ecfd91ba4bc1bc4
-  data.tar.gz: 7fd86ca99c09b5445af96e027abe5a01fab4aaaec6fc678241f7dae7b1d9fe318d22f6474db539d7f3cd521a2e94fae844fc4b9473055d2d127d1033b203d18c
+  metadata.gz: 267238c6a85992b631faaa5283558e5e90ad05d4cac54cedb4ed3a8cf480445b569536c324089b17a7f91d3f89965f6c93f1adfd27076b8750e5a317dd95036f
+  data.tar.gz: 329ac2bb6222d965f9aa4121cfce725a9e4911301a606913a00b062f6f42c5ad3a037a3c327e773c9d9518b75f410185b3d5d973db31c6a712aa7704da79852a

data/.travis.yml

@@ -1,21 +1,23 @@
-sudo: false
+sudo: true
 language: ruby
 rvm:
   - '2.0'
-  - '2.1'
-  - '2.2'
-  - '2.3.1'
-  - 'jruby-9.1.2.0'
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+  - jruby-9.1.5.0
 matrix:
     allow_failures:
-        - rvm: 'jruby-9.1.2.0'
+        - rvm: jruby-9.1.5.0
 
 cache: bundler
 
 install:
+    - git config --global user.name "Autoproj on Travis CI"
+    - git config --global user.email "autoproj@travis"
     - gem install bundler
     # Some tests expect gems to be present in vendor/bundle
     - bundler install --path vendor/bundle
 script:
     - bundler exec rake
-    - bundler exec rake test
+    - AUTOPROJ_SKIP_LONG_TESTS=1 bundler exec rake test

data/lib/autoproj/cli/build.rb

@@ -5,11 +5,9 @@ module Autoproj
     module CLI
         class Build < Update
             def validate_options(selected_packages, options)
-                selected_packages, options = super
-                if options[:amake] && selected_packages.empty? && !options[:all]
-                    selected_packages = ['.']
-                end
-
+                selected_packages, options =
+                    super(selected_packages, options.merge(
+                        checkout_only: true, aup: options[:amake]))
                 if options[:deps].nil?
                     options[:deps] = 
                         !(options[:rebuild] || options[:force])
@@ -23,8 +21,6 @@ def run(selected_packages, options)
                     rebuild: false,
                     parallel: nil
 
-                Autobuild.ignore_errors = options[:keep_going]
-
                 command_line_selection, source_packages, osdep_packages =
                     super(selected_packages, options.merge(checkout_only: true))
 
@@ -38,6 +34,8 @@ def run(selected_packages, options)
                     pkg.disable
                 end
 
+                Autobuild.ignore_errors = options[:keep_going]
+
                 ops = Ops::Build.new(ws.manifest)
                 if build_options[:rebuild] || build_options[:force]
                     packages_to_rebuild =

data/lib/autoproj/cli/main.rb

@@ -361,6 +361,11 @@ def patch(*packages)
             def unpatch(*packages)
                 run_autoproj_cli(:patcher, :Patcher, Hash[], *packages, patch: false)
             end
+
+            desc 'manifest', 'select or displays the active manifest'
+            def manifest(*name)
+                run_autoproj_cli(:manifest, :Manifest, Hash[silent: true], *name)
+            end
         end
     end
 end

data/lib/autoproj/cli/manifest.rb

@@ -0,0 +1,52 @@
+require 'autoproj'
+module Autoproj
+    module CLI
+        class Manifest
+            attr_reader :ws
+
+            def initialize(ws = Workspace.default)
+                @ws = ws
+            end
+
+            def validate_options(args, options)
+                return args, options
+            end
+
+            def run(name, options = Hash.new)
+                ws.load_config
+                if name.empty?
+                    Autoproj.message "current manifest is #{ws.manifest_file_path}"
+                elsif name.size == 1
+                    name = name.first
+                    if File.file?(full_path = File.expand_path(name))
+                        if File.dirname(full_path) != ws.config_dir
+                            raise ArgumentError, "#{full_path} is not part of #{ws.config_dir}"
+                        end
+                    else
+                        full_path = File.join(ws.config_dir, name)
+                    end
+
+                    if !File.file?(full_path)
+                        alternative_full_path = File.join(ws.config_dir, "manifest.#{name}")
+                        if !File.file?(alternative_full_path)
+                            raise ArgumentError, "neither #{full_path} nor #{alternative_full_path} exist"
+                        end
+                        full_path = alternative_full_path
+                    end
+                    begin
+                        Autoproj::Manifest.new(ws).load(full_path)
+                    rescue Exception
+                        Autoproj.error "failed to load #{full_path}"
+                        raise
+                    end
+                    ws.config.set 'manifest_name', File.basename(full_path)
+                    ws.save_config
+                    Autoproj.message "set manifest to #{full_path}"
+                else
+                    raise ArgumentError, "expected zero or one argument, but got #{name.size}"
+                end
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/patcher.rb

@@ -5,7 +5,7 @@ module CLI
         class Patcher < InspectionTool
             def run(packages, patch: true)
                 initialize_and_load
-                packages, _ = finalize_setup(packages, recursive: false, non_imported_packages: nil)
+                packages, _ = finalize_setup(packages, recursive: false, non_imported_packages: :ignore)
                 packages.each do |package_name|
                     pkg = ws.manifest.package_definition_by_name(package_name)
                     if patch

data/lib/autoproj/cli/query.rb

@@ -49,7 +49,7 @@ def format_package(format, priority, package)
                 fields['PREFIX']   = autobuild_package.prefix
                 fields['NAME']     = package.name
                 fields['PRIORITY'] = priority
-                fields['URL']      = (package.vcs.url if package.vcs)
+                fields['URL']      = (package.vcs.url if !package.vcs.none?)
                 fields['PRESENT']  = File.directory?(autobuild_package.srcdir)
                 Autoproj.expand(format, fields)
             end

data/lib/autoproj/cli/update.rb

@@ -5,23 +5,22 @@
 module Autoproj
     module CLI
         class Update < Base
-            def validate_options(packages, options)
-                packages, options = super
-
-                if !options[:osdeps]
-                    options[:osdeps_mode] = Array.new
-                end
+            def validate_options(selection, options)
+                selection, options = super
 
                 if from = options[:from]
                     options[:from] = Autoproj::InstallationManifest.from_workspace_root(options[:from])
                 end
-                ws.os_package_installer.filter_uptodate_packages = options[:osdeps_filter_uptodate]
 
-                if options[:aup] && !options[:all] && packages.empty?
-                    packages = ['.']
+                if options[:aup] && !options[:all] && selection.empty?
+                    if Dir.pwd == ws.root_dir
+                        options[:all] = true
+                    else
+                        selection = [Dir.pwd]
+                    end
                 end
 
-                if options[:force_reset]
+                if options.delete(:force_reset)
                     options[:reset] = :force
                 end
 
@@ -31,21 +30,16 @@ def validate_options(packages, options)
                     end
                 end
 
-                return packages, options
-            end
-
-            def run(selected_packages, options)
-                ws.manifest.accept_unavailable_osdeps = !options[:osdeps]
-                explicit_selection = !selected_packages.empty?
-                selected_packages, config_selected =
-                    normalize_command_line_package_selection(selected_packages)
+                has_explicit_selection = !selection.empty?
+                selection, config_selected =
+                    normalize_command_line_package_selection(selection)
 
                 # Autoproj and configuration are updated only if (1) it is
                 # explicitely selected or (2) nothing is explicitely selected
                 update_autoproj =
                     (options[:autoproj] || (
                         options[:autoproj] != false &&
-                        !explicit_selection &&
+                        !has_explicit_selection &&
                         !options[:config] && 
                         !options[:checkout_only])
                     )
@@ -53,35 +47,93 @@ def run(selected_packages, options)
                 update_config =
                     (options[:config] || config_selected || (
                         options[:config] != false &&
-                        !explicit_selection &&
+                        !has_explicit_selection &&
                         !options[:autoproj]))
 
                 update_packages =
                     options[:all] ||
-                    (explicit_selection && !selected_packages.empty?) ||
-                    (!explicit_selection && !options[:config] && !options[:autoproj])
+                    (has_explicit_selection && !selection.empty?) ||
+                    (!has_explicit_selection && !options[:config] && !options[:autoproj])
 
-                ws.setup
-                parallel = options[:parallel] || ws.config.parallel_import_level
+                options[:autoproj] = update_autoproj
+                options[:config]   = update_config
+                options[:packages] = update_packages
+                return selection, options
+            end
+
+            def run(selected_packages, options)
+                ws.manifest.accept_unavailable_osdeps = !options[:osdeps]
 
+                ws.setup
                 ws.autodetect_operating_system(force: true)
 
-                if update_autoproj
+                if options[:autoproj]
                     ws.update_autoproj
                 end
 
-                ws.load_package_sets(
-                    mainline: options[:mainline],
-                    only_local: options[:only_local],
-                    checkout_only: !update_config || options[:checkout_only],
-                    reset: options[:reset],
-                    ignore_errors: options[:keep_going],
-                    retry_count: options[:retry_count])
-                ws.config.save
-                if !update_packages
-                    return [], [], true
+                begin
+                    ws.load_package_sets(
+                        mainline: options[:mainline],
+                        only_local: options[:only_local],
+                        checkout_only: !options[:config] || options[:checkout_only],
+                        reset: options[:reset],
+                        keep_going: options[:keep_going],
+                        retry_count: options[:retry_count])
+                rescue ImportFailed => configuration_import_failure
+                    if !options[:keep_going] || !options[:packages]
+                        raise
+                    end
+                ensure
+                    ws.config.save
+                end
+
+                if !options[:packages]
+                    return [], [], []
+                end
+
+                osdeps_options = normalize_osdeps_options(
+                    checkout_only: options[:checkout_only],
+                    osdeps_mode: options[:osdeps_mode],
+                    osdeps: options[:osdeps],
+                    osdeps_filter_uptodate: options[:osdeps_filter_uptodate])
+
+                command_line_selection, selected_packages =
+                    finish_loading_configuration(selected_packages)
+                source_packages, osdep_packages, import_failure = 
+                    update_packages(
+                        selected_packages,
+                        osdeps: options[:osdeps], osdeps_options: osdeps_options,
+                        from: options[:from],
+                        checkout_only: options[:checkout_only],
+                        only_local: options[:only_local],
+                        reset: options[:reset],
+                        deps: options[:deps],
+                        keep_going: options[:keep_going],
+                        parallel: options[:parallel] || ws.config.parallel_import_level,
+                        retry_count: options[:retry_count])
+
+                ws.finalize_setup
+                ws.export_installation_manifest
+
+                if options[:osdeps] && !osdep_packages.empty?
+                    ws.install_os_packages(osdep_packages, **osdeps_options)
+                end
+
+                ws.export_env_sh(source_packages)
+                Autoproj.message "  updated #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
+
+                if import_failure && configuration_import_failure
+                    raise ImportFailed.new(configuration_import_failure.original_errors + import_failure.original_errors)
+                elsif import_failure
+                    raise import_failure
+                elsif configuration_import_failure
+                    raise configuration_import_failure
                 end
 
+                return command_line_selection, source_packages, osdep_packages
+            end
+
+            def finish_loading_configuration(selected_packages)
                 ws.setup_all_package_directories
                 # Call resolve_user_selection once to auto-add packages
                 resolve_user_selection(selected_packages)
@@ -98,40 +150,49 @@ def run(selected_packages, options)
                 else
                     command_line_selection = Array.new
                 end
-                selected_packages = resolved_selected_packages
+                return command_line_selection, resolved_selected_packages
+            end
+
+            def normalize_osdeps_options(
+                checkout_only: false, osdeps: true, osdeps_mode: nil,
+                osdeps_filter_uptodate: true)
 
-                if other_root = options[:from]
-                    setup_update_from(other_root)
+                osdeps_options = Hash[install_only: checkout_only]
+                if osdeps_mode
+                    osdeps_options[:osdeps_mode] = osdeps_mode
+                elsif !osdeps
+                    osdeps_options[:osdeps_mode] = Array.new
                 end
+                ws.os_package_installer.filter_uptodate_packages = osdeps_filter_uptodate
+                osdeps_options
+            end
 
-                osdeps_options = Hash[install_only: options[:checkout_only]]
-                if options[:osdeps_mode]
-                    osdeps_options[:osdeps_mode] = options[:osdeps_mode]
+            def update_packages(selected_packages,
+                from: nil, checkout_only: false, only_local: false, reset: false,
+                deps: true, keep_going: false, parallel: 1,
+                retry_count: 0, osdeps: true, osdeps_options: Hash.new)
+
+                if from
+                    setup_update_from(from)
                 end
 
                 ops = Autoproj::Ops::Import.new(ws)
                 source_packages, osdep_packages = 
-                    ops.import_packages(selected_packages,
-                                    checkout_only: options[:checkout_only],
-                                    only_local: options[:only_local],
-                                    reset: options[:reset],
-                                    recursive: options[:deps],
-                                    ignore_errors: options[:keep_going],
-                                    parallel: parallel,
-                                    retry_count: options[:retry_count],
-                                    install_vcs_packages: (osdeps_options if options[:osdeps]))
-
-                ws.finalize_setup
-                ws.export_installation_manifest
-
-                if options[:osdeps] && !osdep_packages.empty?
-                    ws.install_os_packages(osdep_packages, **osdeps_options)
+                        ops.import_packages(selected_packages,
+                                        checkout_only: checkout_only,
+                                        only_local: only_local,
+                                        reset: reset,
+                                        recursive: deps,
+                                        keep_going: keep_going,
+                                        parallel: parallel,
+                                        retry_count: retry_count,
+                                        install_vcs_packages: (osdeps_options if osdeps))
+                return source_packages, osdep_packages, nil
+            rescue PackageImportFailed => import_failure
+                if !keep_going
+                    raise
                 end
-
-                ws.export_env_sh(source_packages)
-                Autoproj.message "  updated #{ws.root_dir}/#{Autoproj::ENV_FILENAME}", :green
-
-                return command_line_selection, source_packages, osdep_packages
+                return import_failure.source_packages, import_failure.osdep_packages, import_failure
             end
 
             def load_all_available_package_manifests

data/lib/autoproj/cli/versions.rb

@@ -33,7 +33,7 @@ def run(user_selection, options)
                     finalize_setup(user_selection,
                                    recursive: options[:deps])
                 
-                ops = Ops::Snapshot.new(ws.manifest, ignore_errors: options[:keep_going])
+                ops = Ops::Snapshot.new(ws.manifest, keep_going: options[:keep_going])
                 
                 if user_selection.empty?
                     snapshot_package_sets = (options[:config] != false)

data/lib/autoproj/exceptions.rb

@@ -8,6 +8,26 @@ def initialize(file = nil)
     end
     class InternalError < RuntimeError; end
 
+    class ImportFailed < Autobuild::CompositeException
+        def empty?
+            original_errors.empty?
+        end
+    end
+
+    class PackageImportFailed < ImportFailed
+        # The list of the source packages that have been updated
+        attr_reader :source_packages
+        # The list of osdep packages that should be installed because of
+        # {#source_packages}
+        attr_reader :osdep_packages
+
+        def initialize(original_errors, source_packages: [], osdep_packages: [])
+            super(original_errors)
+            @source_packages = source_packages
+            @osdep_packages = osdep_packages
+        end
+    end
+
     # Exception raised when trying to resolve a package name and it failed
     class PackageNotFound < ConfigError
     end

data/lib/autoproj/find_workspace.rb

@@ -67,14 +67,13 @@ def self.find_v2_root_dir(base_dir, config_field_name)
         resolved = find_v2_root_dir(result, config_field_name)
 
         if !resolved || (resolved != result)
-            raise ArgumentError, "found #{path} as possible workspace root for #{base_dir}, but it contains a configuration file in #{config_path} that points to #{result} and #{result} is not an autoproj workspace root"
+            raise ArgumentError, "found #{path} as possible workspace root for #{base_dir}, but it contains a configuration file that points to #{result} and #{result} is not an autoproj workspace root"
         end
         resolved
     end
 
     # Filters in the given list of paths the paths that are within a workspace
     def self.filter_out_paths_in_workspace(paths)
-        known_valid_dirs = Set.new
         known_workspace_dirs = Array.new
         paths.find_all do |p|
             if !File.directory?(p)