autoproj 2.0.0.b6 → 2.0.0.b7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ac674274886714c8971929bc69953eb9a8554de
-  data.tar.gz: 1722b19143830e552aad26239225e742dd6bda78
+  metadata.gz: e73644d1f3143dffe36b4af50d2f9dbdc348e8a3
+  data.tar.gz: 0ec902c6207a631ff578403a74e39eb6b72413ce
 SHA512:
-  metadata.gz: 13148336716af711440e24212d70f83330ec82336ddb77cad4c32cb9d487a27f1180b523628a0dfd5812b45221bb1a805a679a55bcf0360cda969c2036f6d9a4
-  data.tar.gz: 6a487132bf1e90c569cb534e01706627c942d1bdf58b689786fc440c836fd2a3ecdf76d2c9cc85d58ee8e02dd8e7ac1c6b0718629d9090037f0e243437465fe2
+  metadata.gz: 4374b8c9855e3a85af8e1d0eb36d233e56d592ff046adc9eeb6405d2b229f0aa60221bdbc5e5f70a6e73ff67c0ec1c2064d3931dda661e9e5f32817f888bff76
+  data.tar.gz: d99c1417e26934cc5ebd0d2c55c1102a99e89ba10800aa593dbc21cbbc49deeb54ca0a9bcf3f714c62fe80e62b7b3ff342b3bda6ca31ad1691f687be718726d3

data/bin/autoproj

@@ -2,7 +2,10 @@
 
 require 'autoproj'
 require 'autoproj/autobuild'
+require 'autoproj/cli'
 require 'autoproj/cli/main'
 Autoproj::CLI.basic_setup
+
+Autoproj::CLI.load_plugins
 Autoproj::CLI::Main.start(ARGV)
 

data/bin/autoproj_bootstrap

@@ -385,6 +385,15 @@ module Autoproj
             set('import_log_enabled', !!value)
         end
 
+        def parallel_build_level
+            get('parallel_build_level', nil) || Autobuild.parallel_build_level
+        end
+
+        def parallel_build_level=(level)
+            set('parallel_build_level', level)
+            Autobuild.parallel_build_level = level
+        end
+
         def parallel_import_level
             get('parallel_import_level', 10)
         end
@@ -1253,11 +1262,21 @@ fi
                 end
 
                 ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+                ruby_bindir = RbConfig::CONFIG['bindir']
+
+                candidates = ['gem']
                 if ruby_bin =~ /^ruby(.+)$/
-                    Autobuild.programs['gem'] = "gem#{$1}"
-                else
-                    Autobuild.programs['gem'] = "gem"
+                    candidates << "gem#{$1}" 
                 end
+
+                candidates.each do |gem_name|
+                    if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
+                        Autobuild.programs['gem'] = gem_full_path
+                        return
+                    end
+                end
+
+                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
             end
 
             def build_gem_cmdlines(gems)

data/lib/autoproj/autobuild.rb

@@ -538,8 +538,88 @@ def user_config(key)
 end
 
 class Autobuild::Git
-    # get version information from the importer
-    def snapshot(package, target_dir = nil)
+    # Get version information
+    #
+    # @option options [Boolean] local (true) whether the snapshot should access
+    #   the remote repository to determine if the local commit is there, and
+    #   determine what would be the best remote branch, or stick to information
+    #   that is present locally
+    # @option options [Boolean] exact_state (true) whether the snapshot should
+    #   point to a specific commit (either with a tag or with a commit ID), or
+    #   only override the branch
+    # @return [Hash] the snapshot information, in a format that can be used by
+    #   {#relocate}
+    def snapshot(package, target_dir = nil, options = Hash.new)
+        options = Kernel.validate_options options,
+            local: true,
+            exact_state: true
+
+        if options[:local]
+            snapshot_local(package, exact_state: options[:exact_state])
+        else
+            snapshot_against_remote(package, exact_state: options[:exact_state])
+        end
+    end
+
+    def normalize_branch_name(name)
+        if name =~ /^refs\/heads\//
+            return name
+        else
+            "refs/heads/#{name}"
+        end
+    end
+
+    # Returns true if the given snapshot information is different from the
+    # configured importer state
+    #
+    # It tests only against the parameters returned by {#snapshot}
+    def snapshot_overrides?(snapshot)
+        # We have to normalize the branch and tag names
+        if snapshot_local = (snapshot['local_branch'] || snapshot['branch'])
+            snapshot_local = normalize_branch_name(snapshot_local)
+            local_branch  = normalize_branch_name(self.local_branch)
+            return true if snapshot_local != local_branch
+        end
+        if snapshot_remote = (snapshot['remote_branch'] || snapshot['branch'])
+            snapshot_remote = normalize_branch_name(snapshot_remote)
+            remote_branch  = normalize_branch_name(self.remote_branch)
+            return true if snapshot_remote != remote_branch
+        end
+        if snapshot_id = snapshot['commit']
+            return true if self.commit != snapshot_id
+        end
+        false
+    end
+
+    # @api private
+    def snapshot_against_remote(package, options = Hash.new)
+        info = Hash['tag' => nil, 'commit' => nil]
+        remote_revname = describe_commit_on_remote(package, 'HEAD', tags: options[:exact_state])
+
+        case remote_revname
+        when /^refs\/heads\/(.*)/
+            remote_branch = $1
+            if local_branch == remote_branch
+                info['branch'] = local_branch
+            else
+                info['local_branch'] = local_branch
+                info['remote_branch'] = remote_branch
+            end
+        when /^refs\/tags\/(.*)/
+            info['tag'] = $1
+        else
+            info['local_branch'] = local_branch
+            info['remote_branch'] = remote_revname
+        end
+
+        if options[:exact_state] && !info['tag']
+            info['commit'] = rev_parse(package, 'HEAD')
+        end
+        info
+    end
+
+    # @api private
+    def snapshot_local(package, options = Hash.new)
         info = Hash.new
         if local_branch != remote_branch
             info['local_branch'] = local_branch
@@ -547,26 +627,29 @@ class Autobuild::Git
         else
             info['branch'] = branch
         end
-
-        begin
-            tag = run_git_bare(package, 'describe', '--tags', '--exact-match', 'HEAD').first.strip
-            info.merge('tag' => tag.encode('UTF-8'), 'commit' => nil)
-        rescue Autobuild::SubcommandFailed
-            head_commit = rev_parse(package, 'HEAD')
-            info.merge('tag' => nil, 'commit' => head_commit.encode('UTF-8'))
+        
+        if options[:exact_state]
+            has_tag, described = describe_rev(package, 'HEAD')
+            if has_tag
+                info.merge('tag' => described, 'commit' => nil)
+            else
+                info.merge('tag' => nil, 'commit' => described)
+            end
+        else
+            info
         end
     end
 end
 
 class Autobuild::SVN
-    def snapshot(package, target_dir = nil)
+    def snapshot(package, target_dir = nil, options = Hash.new)
         version = svn_revision(package)
         Hash['revision' => version]
     end
 end
 
 class Autobuild::ArchiveImporter
-    def snapshot(package, target_dir = nil)
+    def snapshot(package, target_dir = nil, options = Hash.new)
         result = Hash[
             'mode' => mode,
             'no_subdirectory' => !has_subdirectory?,

data/lib/autoproj/cli.rb

@@ -3,6 +3,12 @@ module Autoproj
     module CLI
         class InvalidArguments < Autobuild::Exception
         end
+
+        def self.load_plugins
+            Gem.find_latest_files('autoproj-*', true).each do |path|
+                require path
+            end
+        end
     end
 end
 

data/lib/autoproj/cli/build.rb

@@ -20,13 +20,16 @@ module Autoproj
             def run(selected_packages, options)
                 build_options, options = filter_options options,
                     force: false,
-                    rebuild: false
+                    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))
 
+                parallel = build_options[:parallel] || ws.config.parallel_build_level
+
                 return if source_packages.empty?
 
                 # Disable all packages that are not selected
@@ -70,7 +73,7 @@ module Autoproj
                 end
 
                 Autobuild.do_build = true
-                ops.build_packages(source_packages)
+                ops.build_packages(source_packages, parallel: parallel)
                 Autobuild.apply(source_packages, "autoproj-build", ['install'])
             end
         end

data/lib/autoproj/cli/locate.rb

@@ -58,7 +58,7 @@ module Autoproj
                     if name == selection || pkg.srcdir == selection
                         puts result_value(pkg, options)
                         return
-                    elsif name =~ selection_rx
+                    elsif name =~ selection_rx || selection.start_with?(pkg.srcdir)
                         candidates << pkg
                     end
                 end
@@ -104,7 +104,7 @@ module Autoproj
                 if candidates.empty?
                     raise ArgumentError, "cannot find #{selection} in the current autoproj installation"
                 elsif candidates.size > 1
-                    raise ArgumentError, "multiple packages match #{selection} in the current autoproj installation: #{candidates.join(", ")}"
+                    raise ArgumentError, "multiple packages match #{selection} in the current autoproj installation: #{candidates.map(&:name).sort.join(", ")}"
                 else
                     puts result_value(candidates.first, options)
                 end

data/lib/autoproj/cli/main.rb

@@ -58,6 +58,8 @@ module Autoproj
                 desc: 'only use locally available information (mainly for distributed version control systems such as git)'
             option :mainline, type: :string,
                 desc: "compare to the given baseline. if 'true', the comparison will ignore any override, otherwise it will take into account overrides only up to the given package set"
+            option :snapshot, type: :boolean, default: false,
+                desc: "use the VCS information as 'versions --no-local' would detect it instead of the one in the configuration"
             def status(*packages)
                 run_autoproj_cli(:status, :Status, Hash[], *packages)
             end
@@ -197,6 +199,11 @@ are given, the packages will not be versioned. In other words,
             option :replace, type: :boolean,
                 default: false,
                 desc: 'in combination with --save, controls whether an existing file should be updated or replaced'
+            option :deps, type: :boolean,
+                default: false,
+                desc: 'whether both packages and their dependencies should be versioned, or only the selected packages (the latter is the default)'
+            option :local, type: :boolean, default: false,
+                desc: 'whether we should access the remote server to verify that the snapshotted state is present'
             option :save, type: :string,
                 desc: 'save to the given file instead of displaying it on the standard output'
             def versions(*packages)

data/lib/autoproj/cli/osdeps.rb

@@ -3,21 +3,10 @@ require 'autoproj/cli/inspection_tool'
 module Autoproj
     module CLI
         class OSDeps < InspectionTool
-            def validate_options(package_names, options = Hash.new)
-                package_names, options = super
-
-                initialize_and_load
-                if package_names.empty?
-                    package_names = ws.manifest.default_packages(false)
-                end
-
-                return package_names, options
-            end
-
             def run(user_selection, options = Hash.new)
+                initialize_and_load
                 _, osdep_packages, resolved_selection, _ =
                     finalize_setup(user_selection,
-                                   recursive: false,
                                    ignore_non_imported_packages: true)
 
                 ws.osdeps.install(

data/lib/autoproj/cli/status.rb

@@ -28,32 +28,59 @@ module Autoproj
                 end
 
                 if options[:config]
-                    pkg_sets = ws.manifest.each_package_set.map(&:create_autobuild_package)
+                    pkg_sets = ws.manifest.each_package_set.to_a
                     if !pkg_sets.empty?
                         Autoproj.message("autoproj: displaying status of configuration", :bold)
-                        display_status(pkg_sets, only_local: options[:only_local])
+                        display_status(pkg_sets, snapshot: options[:snapshot], only_local: options[:only_local])
                         STDERR.puts
                     end
                 end
 
                 Autoproj.message("autoproj: displaying status of packages", :bold)
                 packages = packages.sort.map do |pkg_name|
-                    ws.manifest.find_autobuild_package(pkg_name)
+                    ws.manifest.find_package(pkg_name)
+                end
+                display_status(packages, snapshot: options[:snapshot], only_local: options[:only_local])
+            end
+
+            def snapshot_overrides_vcs?(importer, vcs, snapshot)
+                if importer.respond_to?(:snapshot_overrides?)
+                    importer.snapshot_overrides?(snapshot)
+                else
+                    vcs = vcs.to_hash
+                    snapshot.any? { |k, v| vcs[k] != v }
                 end
-                display_status(packages, only_local: options[:only_local])
             end
 
             PackageStatus = Struct.new :msg, :sync, :uncommitted, :local, :remote
-            def status_of_package(pkg, options = Hash.new)
+            def status_of_package(package_description, options = Hash.new)
+                pkg = package_description.autobuild
+                importer = pkg.importer
                 package_status = PackageStatus.new(Array.new, false, false, false, false)
-                if !pkg.importer
+                if !importer
                     package_status.msg << Autoproj.color("  is a local-only package (no VCS)", :bold, :red)
-                elsif !pkg.importer.respond_to?(:status)
-                    package_status.msg << Autoproj.color("  the #{pkg.importer.class.name.gsub(/.*::/, '')} importer does not support status display", :bold, :red)
+                elsif !importer.respond_to?(:status)
+                    package_status.msg << Autoproj.color("  the #{importer.class.name.gsub(/.*::/, '')} importer does not support status display", :bold, :red)
                 elsif !File.directory?(pkg.srcdir)
                     package_status.msg << Autoproj.color("  is not imported yet", :magenta)
                 else
-                    begin status = pkg.importer.status(pkg, options[:only_local])
+                    if importer.respond_to?(:snapshot)
+                        snapshot =
+                            begin importer.snapshot(pkg, nil, exact_state: false, local: options[:only_local])
+                            rescue Autobuild::PackageException
+                                Hash.new
+                            end
+                        if snapshot_overrides_vcs?(importer, package_description.vcs, snapshot)
+                            non_nil_values = snapshot.delete_if { |k, v| !v }
+                            package_status.msg << Autoproj.color("  found configuration that contains all local changes: #{non_nil_values.sort_by(&:first).map { |k, v| "#{k}: #{v}" }.join(", ")}", :light_green)
+                            package_status.msg << Autoproj.color("  consider adding this to your overrides, or use autoproj versions to do it for you", :light_green)
+                            if options[:snapshot]
+                                importer.relocate(importer.repository, snapshot)
+                            end
+                        end
+                    end
+
+                    begin status = importer.status(pkg, options[:only_local])
                     rescue Interrupt
                         raise
                     rescue Exception => e
@@ -61,6 +88,10 @@ module Autoproj
                         return package_status
                     end
 
+                    status.unexpected_working_copy_state.each do |msg|
+                        package_status.msg << Autoproj.color("  #{msg}", :red, :bold)
+                    end
+
                     if status.uncommitted_code
                         package_status.msg << Autoproj.color("  contains uncommitted modifications", :red)
                         package_status.uncommitted = true
@@ -103,26 +134,27 @@ module Autoproj
                 result = StatusResult.new
 
                 executor = Concurrent::FixedThreadPool.new(ws.config.parallel_import_level, max_length: 0)
-                interactive, noninteractive = packages.partition { |pkg| pkg.importer && pkg.importer.interactive? }
+                interactive, noninteractive = packages.partition do |pkg|
+                    pkg.autobuild.importer && pkg.autobuild.importer.interactive?
+                end
                 noninteractive = noninteractive.map do |pkg|
-                    [pkg, Concurrent::Future.execute(executor: executor) { status_of_package(pkg, only_local: options[:only_local]) }]
+                    [pkg, Concurrent::Future.execute(executor: executor) { status_of_package(pkg, snapshot: options[:snapshot], only_local: options[:only_local]) }]
                 end
 
                 sync_packages = ""
                 (noninteractive + interactive).each do |pkg, future|
                     if future 
-                        if error = future.reason
-                            raise error
+                        if !(status = future.value)
+                            raise future.reason
                         end
-                        status = future.value
-                    else status = status_of_package(pkg, only_local: options[:only_local])
+                    else status = status_of_package(pkg, snapshot: options[:snapshot], only_local: options[:only_local])
                     end
 
                     result.uncommitted ||= status.uncommitted
                     result.local       ||= status.local
                     result.remote      ||= status.remote
 
-                    pkg_name = pkg.autoproj_name
+                    pkg_name = pkg.name
                     if status.sync && status.msg.empty?
                         if sync_packages.size > 80
                             Autoproj.message "#{sync_packages},"
@@ -161,6 +193,7 @@ module Autoproj
 
             rescue Interrupt
                 Autoproj.warn "Interrupted, waiting for pending jobs to finish"
+                raise
             rescue Exception => e
                 Autoproj.error "internal error: #{e}, waiting for pending jobs to finish"
                 raise

data/lib/autoproj/cli/versions.rb

@@ -29,21 +29,20 @@ module Autoproj
 
             def run(user_selection, options)
                 initialize_and_load
-                user_selection, config_selected =
-                    normalize_command_line_package_selection(user_selection)
-                packages, * =
+                packages, *, config_selected =
                     finalize_setup(user_selection,
+                                   recursive: options[:deps],
                                    ignore_non_imported_packages: true)
 
                 
                 ops = Ops::Snapshot.new(ws.manifest, ignore_errors: options[:keep_going])
 
                 versions = Array.new
-                if config_selected || (options[:config] != false) || user_selection.empty?
-                    versions += ops.snapshot_package_sets
+                if (config_selected && options[:config] != false) || user_selection.empty?
+                    versions += ops.snapshot_package_sets(nil, local: options[:local])
                 end
                 if (!config_selected && !options[:config]) || !user_selection.empty?
-                    versions += ops.snapshot_packages(packages)
+                    versions += ops.snapshot_packages(packages, nil, local: options[:local])
                 end
 
                 if output_file = options[:save]

data/lib/autoproj/configuration.rb

@@ -189,6 +189,15 @@ module Autoproj
             set('import_log_enabled', !!value)
         end
 
+        def parallel_build_level
+            get('parallel_build_level', nil) || Autobuild.parallel_build_level
+        end
+
+        def parallel_build_level=(level)
+            set('parallel_build_level', level)
+            Autobuild.parallel_build_level = level
+        end
+
         def parallel_import_level
             get('parallel_import_level', 10)
         end

data/lib/autoproj/ops/build.rb

@@ -82,10 +82,10 @@ module Autoproj
             # @param [Array<String>] all_enabled_packages the list of package
             #   names of the packages that should be rebuilt
             # @return [void]
-            def build_packages(all_enabled_packages)
+            def build_packages(all_enabled_packages, options = Hash.new)
                 Autobuild.do_rebuild = false
                 Autobuild.do_forced_build = false
-                Autobuild.apply(all_enabled_packages, "autoproj-build", ['build'])
+                Autobuild.apply(all_enabled_packages, "autoproj-build", ['build'], options)
             end
         end
     end

data/lib/autoproj/ops/configuration.rb

@@ -304,46 +304,52 @@ module Autoproj
             end
         end
 
-        def sort_package_sets_by_import_order(package_sets, root_pkg_set)
-            # We do not consider the 'standalone' package sets while sorting.
-            # They are taken care of later, as we need to maintain the order the
-            # user defined in the package_sets section of the manifest
-            queue = package_sets.flat_map do |pkg_set|
-                if (!pkg_set.imports.empty? || !pkg_set.explicit?) && !(pkg_set == root_pkg_set)
-                    [pkg_set] + pkg_set.imports.to_a
-                else []
-                end
-            end.to_set.to_a
+        def inspect; to_s end
 
-            sorted = Array.new
+        def sort_package_sets_by_import_order(package_sets, root_pkg_set)
+            # The sorting is done in two steps:
+            #  - first, we build a topological order of the package sets
+            #  - then, we insert the auto-imported packages, following this
+            #    topological order, in the user-provided order. Each package is
+            #    considered in turn, and added at the earliest place that fits
+            #    the dependencies
+            topological = Array.new
+            queue = package_sets.to_a
             while !queue.empty?
-                pkg_set = queue.shift
-                if pkg_set.imports.any? { |imported_set| !sorted.include?(imported_set) }
-                    queue.push(pkg_set)
-                else
-                    sorted << pkg_set
+                last_size = queue.size
+                pending = queue.dup
+                queue = Array.new
+                while !pending.empty?
+                    pkg_set = pending.shift
+                    if not_processed_yet = pkg_set.imports.find { |imported_set| !topological.include?(imported_set) }
+                        queue.push(pkg_set)
+                    else
+                        topological << pkg_set
+                    end
+                end
+                if queue.size == last_size
+                    raise ArgumentError, "cannot resolve the dependencies between package sets. There seem to be a cycle amongst #{queue.map(&:name).sort.join(", ")}"
                 end
             end
 
-            # We now need to re-add the standalone package sets. Their order is
-            # determined by the order in the package_set section of the manifest
-            #
-            # Concretely, we add them in order, just after the entry above them
-            previous = nil
-            root_pkg_set.imports.each do |explicit_pkg_set|
-                if !sorted.include?(explicit_pkg_set)
-                    if !previous
-                        sorted.unshift explicit_pkg_set
-                    else
-                        i = sorted.index(previous)
-                        sorted.insert(i + 1, explicit_pkg_set)
+            result = root_pkg_set.imports.to_a.dup
+            to_insert = topological.dup.
+                find_all { |pkg_set| !result.include?(pkg_set) }
+            while !to_insert.empty?
+                pkg_set = to_insert.shift
+                dependencies = pkg_set.imports.dup
+                if dependencies.empty?
+                    result.unshift(pkg_set)
+                else
+                    i = result.find_index do |p|
+                        dependencies.delete(p)
+                        dependencies.empty?
                     end
+                    result.insert(i + 1, pkg_set)
                 end
-                previous = pkg_set
             end
-
-            sorted << root_pkg_set
-            sorted
+            result << root_pkg_set
+            result
         end
 
         def load_package_sets(options = Hash.new)

data/lib/autoproj/ops/import.rb

@@ -243,7 +243,8 @@ module Autoproj
                 manifest = ws.manifest
 
                 all = Set.new
-                package_queue = manifest.all_layout_packages(false).each_source_package_name.to_a
+                package_queue = manifest.all_layout_packages(false).each_source_package_name.to_a +
+                    processed_packages.map(&:name).to_a
                 while !package_queue.empty?
                     pkg_name = package_queue.shift
                     next if all.include?(pkg_name)
@@ -252,7 +253,7 @@ module Autoproj
                     next if manifest.ignored?(pkg_name) || manifest.excluded?(pkg_name)
 
                     pkg = manifest.find_autobuild_package(pkg_name)
-                    if !processed_packages.include?(pkg)
+                    if !processed_packages.include?(pkg) && File.directory?(pkg.srcdir)
                         manifest.load_package_manifest(pkg.name)
                         Autoproj.each_post_import_block(pkg) do |block|
                             block.call(pkg)

data/lib/autoproj/ops/snapshot.rb

@@ -89,22 +89,34 @@ module Autoproj
             @ignore_errors = options[:ignore_errors]
         end
 
-        def snapshot_package_sets(target_dir = nil)
+        def snapshot_package_sets(target_dir = nil, options = Hash.new)
+            options = Kernel.validate_options options,
+                local: true
+
             result = Array.new
             manifest.each_package_set do |pkg_set|
                 next if pkg_set.local?
 
-                if vcs_info = pkg_set.snapshot(target_dir)
+                vcs_info =
+                    begin pkg_set.snapshot(target_dir, local: options[:local])
+                    rescue Exception => e
+                        error_or_warn(pkg_set, e)
+                        next
+                    end
+
+                if vcs_info
                     result << Hash["pkg_set:#{pkg_set.repository_id}", vcs_info]
                 else
-                    error_or_warn(pkg_set, "cannot snapshot #{package_name}: importer snapshot failed")
+                    error_or_warn(pkg_set, "cannot snapshot package set #{pkg_set.name}: importer snapshot failed")
                 end
             end
             result
         end
 
         def error_or_warn(package, error)
-            if ignore_errors?
+            if error.kind_of?(Interrupt)
+                raise
+            elsif ignore_errors?
                 if !error.respond_to?(:to_str)
                     error = error.message
                 end
@@ -116,7 +128,10 @@ module Autoproj
             end
         end
 
-        def snapshot_packages(packages, target_dir = nil)
+        def snapshot_packages(packages, target_dir = nil, options = Hash.new)
+            options = Kernel.validate_options options,
+                local: true
+
             result = Array.new
             packages.each do |package_name|
                 package  = manifest.packages[package_name]
@@ -133,9 +148,10 @@ module Autoproj
                 end
 
                 vcs_info =
-                    begin importer.snapshot(package.autobuild, target_dir)
+                    begin importer.snapshot(package.autobuild, target_dir, local: options[:local])
                     rescue Exception => e
-                        error_or_warn(package, "cannot snapshot #{package_name}: #{e.message}")
+                        error_or_warn(package, e)
+                        next
                     end
 
                 if vcs_info

data/lib/autoproj/osdeps.rb

@@ -647,11 +647,21 @@ fi
                 end
 
                 ruby_bin = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+                ruby_bindir = RbConfig::CONFIG['bindir']
+
+                candidates = ['gem']
                 if ruby_bin =~ /^ruby(.+)$/
-                    Autobuild.programs['gem'] = "gem#{$1}"
-                else
-                    Autobuild.programs['gem'] = "gem"
+                    candidates << "gem#{$1}" 
+                end
+
+                candidates.each do |gem_name|
+                    if File.file?(gem_full_path = File.join(ruby_bindir, gem_name))
+                        Autobuild.programs['gem'] = gem_full_path
+                        return
+                    end
                 end
+
+                raise ArgumentError, "cannot find a gem program (tried #{candidates.sort.join(", ")} in #{ruby_bindir})"
             end
 
             def build_gem_cmdlines(gems)

data/lib/autoproj/package_set.rb

@@ -131,17 +131,22 @@ module Autoproj
                 !File.exists?(File.join(raw_local_dir, "init.rb"))
         end
 
+        # Defined for coherence with the API on {PackageDefinition}
+        def autobuild
+            create_autobuild_package
+        end
+
         def create_autobuild_package
             Ops::Tools.create_autobuild_package(vcs, name, raw_local_dir)
         end
 
-        def snapshot(target_dir)
+        def snapshot(target_dir, options = Hash.new)
             if local?
                 Hash.new
             else
                 package = create_autobuild_package
                 if package.importer.respond_to?(:snapshot)
-                    package.importer.snapshot(package, target_dir)
+                    package.importer.snapshot(package, target_dir, options)
                 end
             end
         end

data/lib/autoproj/reporter.rb

@@ -2,7 +2,6 @@ require 'autobuild/reporting'
 module Autoproj
     class << self
         attr_accessor :verbose
-        attr_reader :console
         def silent?
             Autobuild.silent?
         end
@@ -11,8 +10,6 @@ module Autoproj
         end
     end
     @verbose = false
-    @console = HighLine.new
-	
 
     def self.silent(&block)
         Autobuild.silent(&block)

data/lib/autoproj/version.rb

@@ -1,3 +1,3 @@
 module Autoproj
-    VERSION = "2.0.0.b6"
+    VERSION = "2.0.0.b7"
 end

data/lib/autoproj/workspace.rb

@@ -140,7 +140,12 @@ module Autoproj
             @config = Configuration.new(config_path)
             if File.file?(config_path)
                 config.load(reconfigure: reconfigure)
-                manifest.vcs = VCSDefinition.from_raw(config.get('manifest_source', nil))
+                if raw_vcs = config.get('manifest_source', nil)
+                    manifest.vcs = VCSDefinition.from_raw(raw_vcs)
+                else
+                    manifest.vcs = VCSDefinition.from_raw(
+                        type: 'local', url: config_dir)
+                end
             end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autoproj
 version: !ruby/object:Gem::Version
-  version: 2.0.0.b6
+  version: 2.0.0.b7
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-13 00:00:00.000000000 Z
+date: 2015-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autobuild