autoproj 2.0.0.rc37 → 2.0.0.rc38

data/lib/autoproj/autobuild_extensions/git.rb

@@ -0,0 +1,116 @@
+module Autoproj
+    module AutobuildExtensions
+        module Git
+            # Reconfigures this importer to use an already existing checkout located
+            # in the given autoproj root
+            #
+            # @param [Autobuild::Package] the package we are dealing with
+            # @param [Autoproj::InstallationManifest] the other root's installation
+            #   manifest
+            def pick_from_autoproj_root(package, installation_manifest)
+                other_pkg = installation_manifest[package.name]
+                return if !other_pkg || !File.directory?(other_pkg.srcdir)
+                self.relocate(other_pkg.srcdir)
+                true
+            end
+
+            # 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, only_local: true, exact_state: true)
+                if only_local
+                    snapshot_local(package, exact_state: exact_state)
+                else
+                    snapshot_against_remote(package, exact_state: 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
+                    info['remote_branch'] = remote_branch
+                else
+                    info['branch'] = branch
+                end
+                
+                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
+    end
+end

data/lib/autoproj/autobuild_extensions/package.rb

@@ -0,0 +1,159 @@
+module Autoproj
+    module AutobuildExtensions
+        module Package
+            # Tags explicitely added with #add_tag
+            attr_reader :added_tags
+
+            attr_reader :optional_dependencies
+
+            attr_reader :os_packages
+
+            attr_writer :ws
+            def ws
+                @ws ||= Autoproj.workspace
+            end
+
+            # The Autoproj::PackageManifest object that describes this package
+            attr_accessor :description
+
+            def initialize(spec = Hash.new)
+                super
+                @ws = nil
+                @os_packages = Set.new
+                @added_tags = Set.new
+                @optional_dependencies = Set.new
+                @description = PackageManifest.new(self, null: true)
+            end
+
+            # The set of tags for this package. This is an union of the tags
+            # contained in +description+ and the ones explicitely added with
+            # #add_tag
+            def tags
+                result = @added_tags.dup
+                if description
+                    result |= description.tags.to_set
+                end
+                result
+            end
+
+            # Add a tag to the package. Use this if you don't want the tag to be
+            # shared with everyone that uses the package (i.e. cannot go in
+            # manifest.xml)
+            def add_tag(tag)
+                @added_tags << tag
+            end
+
+            # True if this package is tagged with the given tag string
+            def has_tag?(tag)
+                tags.include?(tag.to_s)
+            end
+
+            # Asks autoproj to remove references to the given obsolete oroGen
+            # package
+            def remove_obsolete_installed_orogen_package(name)
+                post_install do
+                    path = File.join(prefix, 'lib', 'pkgconfig')
+                    Dir.glob(File.join(path, "#{name}-*.pc")) do |pcfile|
+                        Autoproj.message "  removing obsolete file #{pcfile}", :bold
+                        FileUtils.rm_f pcfile
+                    end
+                    pcfile = File.join(path, "orogen-project-#{name}.pc")
+                    if File.exist?(pcfile)
+                        Autoproj.message "  removing obsolete file #{pcfile}", :bold
+                        FileUtils.rm_f pcfile
+                    end
+                end
+            end
+
+            # Asks autoproj to remove the given file in the package's installation
+            # prefix
+            def remove_obsolete_installed_file(*path)
+                post_install do
+                    path = File.join(prefix, *path)
+                    if File.exist?(path)
+                        Autoproj.message "  removing obsolete file #{path}", :bold
+                        FileUtils.rm_f path
+                    end
+                end
+            end
+
+            # Ask autoproj to run the given block after this package has been
+            # imported
+            def post_import(&block)
+                Autoproj.post_import(self, &block)
+            end
+
+            def autoproj_name # :nodoc:
+                srcdir.gsub(/^#{Regexp.quote(ws.root_dir)}\//, '')
+            end
+
+            def depends_on(name)
+                if name.respond_to?(:name) # probably a Package object
+                    name = name.name
+                end
+
+                pkg_autobuild, pkg_os = partition_package(name)
+                pkg_autobuild.each do |pkg|
+                    super(pkg)
+                end
+                @os_packages.merge(pkg_os.to_set)
+            end
+
+            def all_dependencies_with_osdeps(set = Set.new)
+                original_set = set.dup
+                all_dependencies(set)
+                set.dup.each do |dep_pkg_name|
+                    next if original_set.include?(dep_pkg_name)
+                    if dep_pkg = ws.manifest.find_autobuild_package(dep_pkg_name)
+                        set.merge(dep_pkg.os_packages)
+                    else
+                        raise ArgumentError, "#{dep_pkg_name}, which is listed as a dependency of #{name}, is not the name of a known package"
+                    end
+                end
+                set.merge(os_packages)
+                set
+            end
+
+            def depends_on_os_package(name)
+                depends_on(name)
+            end
+
+            def remove_dependency(name)
+                dependencies.delete name
+                optional_dependencies.delete name
+                os_packages.delete name
+            end
+
+            def optional_dependency(name)
+                optional_dependencies << name
+            end
+
+            def partition_package(pkg_name)
+                pkg_autobuild, pkg_osdeps = [], []
+                ws.manifest.resolve_package_name(pkg_name).each do |type, dep_name|
+                    if type == :osdeps
+                        pkg_osdeps << dep_name
+                    elsif type == :package
+                        pkg_autobuild << dep_name
+                    else raise Autoproj::InternalError, "expected package type to be either :osdeps or :package, got #{type.inspect}"
+                    end
+                end
+                return pkg_autobuild, pkg_osdeps
+            end
+
+            def partition_optional_dependencies
+                packages, osdeps = [], []
+                optional_dependencies.each do |name|
+                    begin
+                        pkg_autobuild, pkg_osdeps = partition_package(name)
+                        packages.concat(pkg_autobuild)
+                        osdeps.concat(pkg_osdeps)
+                    rescue Autoproj::PackageNotFound
+                        # Simply ignore non-existent optional dependencies
+                    end
+                end
+                return packages, osdeps
+            end
+        end
+    end
+end

data/lib/autoproj/autobuild_extensions/svn.rb

@@ -0,0 +1,11 @@
+module Autoproj
+    module AutobuildExtensions
+        module SVN
+            def snapshot(package, target_dir = nil, options = Hash.new)
+                version = svn_revision(package)
+                Hash['revision' => version]
+            end
+        end
+    end
+end
+

data/lib/autoproj/cli/base.rb

@@ -12,8 +12,8 @@ class Base
             # @return [Workspace]
             attr_reader :ws
 
-            def initialize(ws = nil)
-                @ws = (ws || Workspace.default)
+            def initialize(ws = Workspace.default)
+                @ws = ws
             end
 
             # Normalizes the arguments given by the user on the command line
@@ -56,7 +56,11 @@ def normalize_command_line_package_selection(selection)
             #   resolved
             def resolve_user_selection(selected_packages, **options)
                 if selected_packages.empty?
-                    return ws.manifest.default_packages
+                    selection = ws.manifest.default_packages
+                    if Autoproj.verbose
+                        Autoproj.message "selected packages: #{selection.each_package_name.to_a.sort.join(", ")}"
+                    end
+                    return selection, []
                 end
                 selected_packages = selected_packages.to_set
 
@@ -65,6 +69,7 @@ def resolve_user_selection(selected_packages, **options)
 
                 # Try to auto-add stuff if nonresolved
                 nonresolved.delete_if do |sel|
+                    sel = File.expand_path(sel)
                     next if !File.directory?(sel)
                     while sel != '/'
                         handler, srcdir = Autoproj.package_handler_for(sel)
@@ -73,7 +78,7 @@ def resolve_user_selection(selected_packages, **options)
                             srcdir = File.expand_path(srcdir)
                             relative_to_root = Pathname.new(srcdir).relative_path_from(Pathname.new(ws.root_dir))
                             pkg = ws.in_package_set(ws.manifest.main_package_set, ws.manifest.file) do
-                                send(handler, relative_to_root.to_s)
+                                send(handler, relative_to_root.to_s, workspace: ws)
                             end
                             ws.setup_package_directories(pkg)
                             selected_packages.select(sel, pkg.name, weak: true)
@@ -85,7 +90,7 @@ def resolve_user_selection(selected_packages, **options)
                 end
 
                 if Autoproj.verbose
-                    Autoproj.message "will install #{selected_packages.packages.to_a.sort.join(", ")}"
+                    Autoproj.message "selected packages: #{selected_packages.each_package_name.to_a.sort.join(", ")}"
                 end
                 return selected_packages, nonresolved
             end
@@ -113,9 +118,10 @@ def resolve_user_selection(selected_packages, **options)
             # @param [Boolean] recursive whether the resolution should be done
             #   recursively (i.e. dependencies of directly selected packages
             #   should be added) or not
-            # @param [Boolean] ignore_non_imported_packages whether packages
-            #   that are not imported should simply be ignored. Setting
-            #   checkout_only to true and ignore_non_imported_packages to true
+            # @param [Symbol] non_imported_packages whether packages
+            #   that are not imported should simply be ignored (:ignore),
+            #   returned (:return) or should be checked out (:checkout). Setting
+            #   checkout_only to true and this to anything but nil
             #   guarantees in effect that no import operation will take place,
             #   only loading
             # @return [(Array<String>,Array<String>,PackageSelection)] the list
@@ -123,16 +129,8 @@ def resolve_user_selection(selected_packages, **options)
             #   the package selection resolution object
             #
             # @see resolve_user_selection
-            def resolve_selection(user_selection, checkout_only: true, only_local: false, recursive: true, ignore_non_imported_packages: false)
+            def resolve_selection(user_selection, checkout_only: true, only_local: false, recursive: true, non_imported_packages: :ignore)
                 resolved_selection, _ = resolve_user_selection(user_selection, filter: false)
-                if ignore_non_imported_packages
-                    ws.manifest.each_autobuild_package do |pkg|
-                        if !File.directory?(pkg.srcdir)
-                            ws.manifest.ignore_package(pkg.name)
-                        end
-                    end
-                end
-                resolved_selection.filter_excluded_and_ignored_packages(ws.manifest)
 
                 ops = Ops::Import.new(ws)
                 source_packages, osdep_packages = ops.import_packages(
@@ -140,7 +138,8 @@ def resolve_selection(user_selection, checkout_only: true, only_local: false, re
                     checkout_only: checkout_only,
                     only_local: only_local,
                     recursive: recursive,
-                    warn_about_ignored_packages: false)
+                    warn_about_ignored_packages: false,
+                    non_imported_packages: non_imported_packages)
 
                 return source_packages, osdep_packages, resolved_selection
             end

data/lib/autoproj/cli/clean.rb

@@ -19,8 +19,7 @@ def run(selection, options = Hash.new)
                 packages, _ = normalize_command_line_package_selection(selection)
                 source_packages, * = resolve_selection(
                     selection,
-                    recursive: false,
-                    ignore_non_imported_packages: true)
+                    recursive: false)
                 if packages.empty?
                     raise ArgumentError, "no packages or OS packages match #{selection.join(" ")}"
                 end

data/lib/autoproj/cli/envsh.rb

@@ -9,8 +9,7 @@ def validate_options(_unused, options = Hash.new)
 
             def run(options = Hash.new)
                 initialize_and_load
-                finalize_setup(Array.new,
-                    ignore_non_imported_packages: true)
+                finalize_setup(Array.new)
 
                 options = Kernel.validate_options options,
                     shell_helpers: ws.config.shell_helpers?

data/lib/autoproj/cli/inspection_tool.rb

@@ -5,16 +5,11 @@ module CLI
         # Base class for CLI tools that do not change the state of the installed
         # system
         class InspectionTool < Base
-            def initialize_and_load(options = Hash.new)
-                options = Kernel.validate_options options,
-                    mainline: nil
-
+            def initialize_and_load(mainline: nil)
                 Autoproj.silent do
                     ws.setup
-                    if mainline = options[:mainline]
-                        if mainline == 'mainline' || mainline == 'true'
-                            mainline = true
-                        end
+                    if mainline == 'mainline' || mainline == 'true'
+                        mainline = true
                     end
                     ws.load_package_sets(mainline: mainline)
                     ws.config.save
@@ -25,9 +20,9 @@ def initialize_and_load(options = Hash.new)
             # Finish loading the package information
             #
             # @param [Array<String>] packages the list of package names
-            # @option options ignore_non_imported_packages (true) whether
-            #   packages that are not present on disk should be ignored (true in
-            #   most cases)
+            # @param [Symbol] non_imported_packages whether packages that are
+            #   not yet imported should be ignored (:ignore) or returned
+            #   (:return). 
             # @option options recursive (true) whether the package resolution
             #   should return the package(s) and their dependencies
             #
@@ -35,11 +30,7 @@ def initialize_and_load(options = Hash.new)
             #   selected packages, the PackageSelection representing the
             #   selection resolution itself, and a flag telling whether some of
             #   the arguments were pointing within the configuration area
-            def finalize_setup(packages = [], options = Hash.new)
-                options = Kernel.validate_options options,
-                    ignore_non_imported_packages: true,
-                    recursive: true
-
+            def finalize_setup(packages = [], non_imported_packages: :ignore, recursive: true)
                 Autoproj.silent do
                     packages, config_selected = normalize_command_line_package_selection(packages)
                     # Call resolve_user_selection once to auto-add packages, so
@@ -47,7 +38,7 @@ def finalize_setup(packages = [], options = Hash.new)
                     resolve_user_selection(packages)
                     ws.finalize_package_setup
                     source_packages, osdep_packages, resolved_selection =
-                        resolve_selection(packages, options)
+                        resolve_selection(packages, recursive: recursive, non_imported_packages: non_imported_packages)
                     ws.finalize_setup
                     ws.export_installation_manifest
                     return source_packages, osdep_packages, resolved_selection, config_selected
@@ -57,14 +48,14 @@ def finalize_setup(packages = [], options = Hash.new)
             def load_all_available_package_manifests
                 # Load the manifest for packages that are already present on the
                 # file system
-                ws.manifest.packages.each_value do |pkg|
-                    if File.directory?(pkg.autobuild.srcdir)
+                ws.manifest.each_autobuild_package do |pkg|
+                    if pkg.checked_out?
                         begin
-                            ws.manifest.load_package_manifest(pkg.autobuild.name)
+                            ws.manifest.load_package_manifest(pkg.name)
                         rescue Interrupt
                             raise
                         rescue Exception => e
-                            Autoproj.warn "cannot load package manifest for #{pkg.autobuild.name}: #{e.message}"
+                            Autoproj.warn "cannot load package manifest for #{pkg.name}: #{e.message}"
                         end
                     end
                 end