autoproj 2.3.1 → 2.4.0

data/lib/autoproj/cli/main_plugin.rb

@@ -5,7 +5,7 @@ class MainPlugin < Thor
 
             no_commands do
                 def ws
-                    @ws ||= Workspace.from_pwd
+                    @ws ||= Workspace.default
                 end
 
                 def install_plugins
@@ -37,7 +37,7 @@ def install(name)
 
                 gem_options = Hash.new
                 if options[:git] && options[:path]
-                    raise ArgumentError, "you can provide only one of --git or --path"
+                    raise CLIInvalidArguments, "you can provide only one of --git or --path"
                 elsif options[:git]
                     gem_options[:git] = options[:git]
                 elsif options[:path]

data/lib/autoproj/cli/manifest.rb

@@ -15,7 +15,7 @@ def run(name, options = Hash.new)
                     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}"
+                            raise CLIInvalidArguments, "#{full_path} is not part of #{ws.config_dir}"
                         end
                     else
                         full_path = File.join(ws.config_dir, name)
@@ -24,7 +24,7 @@ def run(name, options = Hash.new)
                     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"
+                            raise CLIInvalidArguments, "neither #{full_path} nor #{alternative_full_path} exist"
                         end
                         full_path = alternative_full_path
                     end
@@ -38,9 +38,12 @@ def run(name, options = Hash.new)
                     ws.save_config
                     Autoproj.message "set manifest to #{full_path}"
                 else
-                    raise ArgumentError, "expected zero or one argument, but got #{name.size}"
+                    raise CLIInvalidArguments, "expected zero or one argument, but got #{name.size}"
                 end
             end
+
+            def notify_env_sh_updated
+            end
         end
     end
 end

data/lib/autoproj/cli/query.rb

@@ -4,6 +4,10 @@
 module Autoproj
     module CLI
         class Query < InspectionTool
+            def os_package_resolver
+                ws.os_package_resolver
+            end
+
             def find_all_matches(query, packages)
                 matches = packages.map do |pkg|
                     if priority = query.match(pkg)
@@ -13,35 +17,92 @@ def find_all_matches(query, packages)
                 matches.sort_by { |priority, pkg| [priority, pkg.name] }
             end
 
-            def run(query_string, format: '$NAME', search_all: false, only_present: false)
+            def run(query_string, format: '$NAME', search_all: false, only_present: false, osdeps: false)
                 initialize_and_load
-                all_selected_packages, * = finalize_setup([], non_imported_packages: :return)
+                all_selected_packages, all_selected_osdeps_packages, * =
+                    finalize_setup([], non_imported_packages: :return)
+
+                if osdeps
+                    query_os_packages(query_string, all_selected_osdeps_packages, format: format, search_all: search_all)
+                else
+                    query_source_packages(query_string, all_selected_packages, format: format, search_all: search_all, only_present: only_present)
+                end
+            end
+
+            def query_os_packages(query_string, selected_packages, format: '$NAME', search_all: false)
+                if query_string.empty?
+                    query = OSPackageQuery.all
+                else
+                    query = OSPackageQuery.parse_query(query_string.first, os_package_resolver)
+                end
+
+                if search_all
+                    packages = os_package_resolver.all_package_names
+                else
+                    packages = selected_packages
+                end
+
+                matches = find_all_matches(query, packages.to_a)
+
+                needs_real_package = (/\$REAL_PACKAGE\b/ === format)
+                needs_handler = (/\$HANDLER\b/ === format)
+
+                matches.each do |priority, pkg_name|
+                    if needs_real_package || needs_handler
+                        resolved = os_package_resolver.resolve_os_packages([pkg_name])
+                        resolved.each do |handler, real_packages|
+                            if needs_real_package
+                                real_packages.each do |real_package_name|
+                                    puts format_osdep_package(format, priority, pkg_name, handler, real_package_name)
+                                end
+                            else
+                                puts format_osdep_package(format, priority, pkg_name, handler, nil)
+                            end
+                        end
+                    else
+                        puts format_osdep_package(format, priority, pkg_name, nil, nil)
+                    end
+                end
+            end
+
+            def format_osdep_package(format, priority, name, handler, real_package_name)
+                fields = Hash.new
+                fields['NAME']     = name
+                fields['PRIORITY'] = priority
+                fields['HANDLER']  = handler
+                fields['REAL_PACKAGE']  = real_package_name
+                Autoproj.expand(format, fields)
+            end
+
+            def query_source_packages(query_string, selected_packages, format: '$NAME', search_all: false, only_present: false)
+                if query_string.empty?
+                    query = SourcePackageQuery.all
+                else
+                    query = SourcePackageQuery.parse_query(query_string.first)
+                end
+
                 if search_all
                     packages = ws.manifest.each_package_definition.to_a
                 else
-                    packages = all_selected_packages.map do |pkg_name|
+                    packages = selected_packages.map do |pkg_name|
                         ws.manifest.find_package_definition(pkg_name)
                     end
                 end
+
                 if only_present
                     packages = packages.find_all do |pkg|
                         File.directory?(pkg.autobuild.srcdir)
                     end
                 end
 
-                if query_string.empty?
-                    query = Autoproj::Query.all
-                else
-                    query = Autoproj::Query.parse_query(query_string.first)
-                end
                 matches = find_all_matches(query, packages)
 
                 matches.each do |priority, pkg_def|
-                    puts format_package(format, priority, pkg_def)
+                    puts format_source_package(format, priority, pkg_def)
                 end
             end
 
-            def format_package(format, priority, package)
+            def format_source_package(format, priority, package)
                 autobuild_package = package.autobuild
                 fields = Hash.new
                 fields['SRCDIR']   = autobuild_package.srcdir

data/lib/autoproj/cli/reset.rb

@@ -10,14 +10,14 @@ def run(ref_name, options)
                 pkg = manifest.main_package_set.create_autobuild_package
                 importer = pkg.importer
                 if !importer || !importer.kind_of?(Autobuild::Git)
-                    raise ConfigError, "cannot use autoproj reset if the main configuration is not managed by git"
+                    raise CLIInvalidArguments, "cannot use autoproj reset if the main configuration is not managed by git"
                 end
                 
                 # Check if the reflog entry exists
                 begin
                     importer.rev_parse(pkg, ref_name)
                 rescue Autobuild::PackageException
-                    raise InvalidArguments, "#{ref_name} does not exist, run autoproj log for log entries and autoproj tag without arguments for the tags"
+                    raise CLIInvalidArguments, "#{ref_name} does not exist, run autoproj log for log entries and autoproj tag without arguments for the tags"
                 end
 
                 # Checkout the version file
@@ -26,13 +26,13 @@ def run(ref_name, options)
                     Versions::DEFAULT_VERSIONS_FILE_BASENAME)
                 begin
                     file_data = importer.show(pkg, ref_name, versions_file)
-                    versions_path = File.join(Autoproj.config_dir, versions_file)
+                    versions_path = File.join(ws.config_dir, versions_file)
                     if File.file?(versions_path)
                         old_versions_path = "#{versions_path}.old"
                         FileUtils.rm_f old_versions_path
                         FileUtils.cp versions_path, old_versions_path
                     end
-                    FileUtils.mkdir_p File.join(Autoproj.config_dir, Workspace::OVERRIDES_DIR)
+                    FileUtils.mkdir_p File.join(ws.config_dir, Workspace::OVERRIDES_DIR)
                     File.open(versions_path, 'w') do |io|
                         io.write file_data
                     end

data/lib/autoproj/cli/switch_config.rb

@@ -9,9 +9,9 @@ module CLI
         class SwitchConfig < Base
             def run(args, options = Hash.new)
                 if !File.directory?(ws.config_dir)
-                    raise ConfigError, "there's no autoproj/ directory in this workspace, use autoproj bootstrap to check out one"
+                    raise CLIInvalidArguments, "there's no autoproj/ directory in this workspace, use autoproj bootstrap to check out one"
                 elsif Dir.pwd.start_with?(ws.remotes_dir) || Dir.pwd.start_with?(ws.config_dir)
-                    raise ConfigError, "you cannot run autoproj switch-config from autoproj's configuration directory or one of its subdirectories"
+                    raise CLIInvalidArguments, "you cannot run autoproj switch-config from autoproj's configuration directory or one of its subdirectories"
                 end
 
                 ws.load_config

data/lib/autoproj/cli/tag.rb

@@ -14,7 +14,7 @@ def run(arguments, options = Hash.new)
                 pkg = main_package_set.create_autobuild_package
                 importer = pkg.importer
                 if !importer || !importer.kind_of?(Autobuild::Git)
-                    raise ConfigError, "cannot use autoproj tag if the main configuration is not managed by git"
+                    raise CLIInvalidArguments, "cannot use autoproj tag if the main configuration is not managed by git"
                 end
 
                 versions_file = File.join(
@@ -37,7 +37,7 @@ def run(arguments, options = Hash.new)
                 # Check if the tag already exists
                 begin
                     importer.rev_parse(pkg, "refs/tags/#{tag_name}")
-                    raise InvalidArguments, "tag #{tag_name} already exists"
+                    raise CLIInvalidArguments, "tag #{tag_name} already exists"
                 rescue Autobuild::PackageException
                 end
 

data/lib/autoproj/cli/update.rb

@@ -198,6 +198,8 @@ def update_packages(selected_packages,
                                         install_vcs_packages: (osdeps_options if osdeps),
                                         auto_exclude: auto_exclude)
                 return source_packages, osdep_packages, nil
+            rescue ExcludedSelection => e
+                raise CLIInvalidSelection, e.message, e.backtrace
             rescue PackageImportFailed => import_failure
                 if !keep_going
                     raise

data/lib/autoproj/cli/which.rb

@@ -0,0 +1,17 @@
+require 'autoproj/cli/inspection_tool'
+module Autoproj
+    module CLI
+        class Which < InspectionTool
+            def run(cmd)
+                initialize_and_load
+                finalize_setup(Array.new)
+
+                puts ws.which(cmd)
+            rescue Workspace::ExecutableNotFound => e
+                raise CLIInvalidArguments, e.message, e.backtrace
+            end
+        end
+    end
+end
+
+

data/lib/autoproj/exceptions.rb

@@ -36,6 +36,9 @@ class PackageUnavailable < PackageNotFound; end
     class UnregisteredPackage < ArgumentError
     end
 
+    class UnregisteredPackageSet < ArgumentError
+    end
+
     class InvalidPackageManifest < RuntimeError; end
 
     class InputError < RuntimeError; end
@@ -67,18 +70,20 @@ def initialize(selection)
 
     class UserError < RuntimeError; end
 
-    class WorkspaceAlreadyCreated < RuntimeError; end
+    class InvalidWorkspace < RuntimeError; end
+
+    class WorkspaceAlreadyCreated < InvalidWorkspace; end
 
     # Exception raised when looking for a workspace and it cannot be found
-    class NotWorkspace < RuntimeError; end
+    class NotWorkspace < InvalidWorkspace; end
 
     # Exception raised when the autoproj workspace changes and the current
     # workspace is outdated
-    class OutdatedWorkspace < RuntimeError; end
+    class OutdatedWorkspace < InvalidWorkspace; end
 
     # Exception raised when initializing on a workspace that is not the current
     # one
-    class MismatchingWorkspace < RuntimeError; end
+    class MismatchingWorkspace < InvalidWorkspace; end
 end
 
 

data/lib/autoproj/git_server_configuration.rb

@@ -1,4 +1,52 @@
 module Autoproj
+    GIT_SERVER_CONFIG_VARS = %w{_ROOT _PUSH_ROOT _PRIVATE_ROOT}
+
+    GIT_SERVER_ACCESS_METHODS = Hash[
+        'git' => 'git,ssh',
+        'ssh' => 'ssh,ssh',
+        'http' => 'http,http']
+
+
+    # @api private
+    #
+    # Helper for {.git_server_configuration}
+    def self.git_server_validate_config_value(base_url, value, disabled_methods: )
+        values = (GIT_SERVER_ACCESS_METHODS[value] || value).split(",")
+        values.each do |access_method|
+            if !GIT_SERVER_ACCESS_METHODS.has_key?(access_method)
+                raise Autoproj::InputError, "#{access_method} is not a known access method"
+            elsif disabled_methods.include?(access_method)
+                raise Autoproj::InputError, "#{access_method} is disabled on #{base_url}"
+            end
+        end
+        value
+    end
+
+    # @api private
+    #
+    # Helper for {.git_server_configuration}
+    def self.git_server_resolve_master_config(name, config, base_url: , git_url: , http_url: , ssh_url: , disabled_methods: )
+        access_mode = config.get(name)
+        begin
+            git_server_validate_config_value(base_url, access_mode, disabled_methods: disabled_methods)
+        rescue Autoproj::InputError => e
+            Autoproj.warn e.message
+            config.reset(name)
+            access_mode = config.get(name)
+        end
+        access_mode = GIT_SERVER_ACCESS_METHODS[access_mode] || access_mode
+        pull, push, private_pull = access_mode.split(',')
+        private_pull ||= push
+        [[pull, "_ROOT"], [push, "_PUSH_ROOT"], [private_pull, "_PRIVATE_ROOT"]].each do |method, var_suffix|
+            url = if method == "git" then git_url
+                  elsif method == "http" then http_url
+                  elsif method == "ssh" then ssh_url
+                  end
+            config.set("#{name}#{var_suffix}", url)
+        end
+        return pull, push, private_pull
+    end
+
     # Adds the relevant options to handle a gitorious server
     # What this does is ask the user how he would like to access the gitorious
     # server. Then, it sets
@@ -18,79 +66,57 @@ module Autoproj
     #
     # which would be expanded to the expected URLs for pull and push.
     #
-    def self.git_server_configuration(name, base_url, options = Hash.new)
-        options = Kernel.validate_options options,
+    def self.git_server_configuration(name, base_url,
             git_url: "git://#{base_url}",
             http_url: "https://git.#{base_url}",
             ssh_url: "git@#{base_url}:",
             default: 'http,ssh',
             disabled_methods: [],
             config: Autoproj.config,
-            fallback_to_http: nil
-
-        config = options.delete(:config)
-        disabled_methods = Array(options[:disabled_methods])
+            fallback_to_http: nil,
+            lazy: false)
 
-        access_methods = Hash[
-            'git' => 'git,ssh',
-            'ssh' => 'ssh,ssh',
-            'http' => 'http,http']
+        disabled_methods = Array(disabled_methods)
 
-        gitorious_long_doc = [
-            "How should I interact with #{base_url} (#{(access_methods.keys - disabled_methods).sort.join(", ")})",
+        long_doc = [
+            "How should I interact with #{base_url} (#{(GIT_SERVER_ACCESS_METHODS.keys - disabled_methods).sort.join(", ")})",
             "If you give one value, it's going to be the method used for all access",
             "If you give multiple values, comma-separated, the first one will be",
             "used for pulling and the second one for pushing. An optional third value",
             "will be used to pull from private repositories (the same than pushing is",
             "used by default)"]
 
-        validator = lambda do |value|
-            values = (access_methods[value] || value).split(",")
-            values.each do |access_method|
-                if !access_methods.has_key?(access_method)
-                    raise Autoproj::InputError, "#{access_method} is not a known access method"
-                elsif disabled_methods.include?(access_method)
-                    raise Autoproj::InputError, "#{access_method} is disabled on #{base_url}"
-                end
-            end
-            value
+        config.declare name, 'string', default: default, doc: long_doc do |value|
+            git_server_validate_config_value(base_url, value, disabled_methods: disabled_methods)
         end
 
-        config.declare name, 'string',
-            default: options[:default],
-            doc: gitorious_long_doc, &validator
-
-        access_mode = config.get(name)
-        begin
-            validator[access_mode]
-        rescue Autoproj::InputError => e
-            Autoproj.warn e.message
-            config.reset(name)
-            access_mode = config.get(name)
-        end
-        access_mode = access_methods[access_mode] || access_mode
-        pull, push, private_pull = access_mode.split(',')
-        private_pull ||= push
-        [[pull, "_ROOT"], [push, "_PUSH_ROOT"], [private_pull, "_PRIVATE_ROOT"]].each do |method, var_suffix|
-            url = if method == "git" then options[:git_url]
-                  elsif method == "http" then options[:http_url]
-                  elsif method == "ssh" then options[:ssh_url]
-                  end
-            config.set("#{name}#{var_suffix}", url)
+        if !lazy
+            pull, push, private_pull = git_server_resolve_master_config(name, config,
+                base_url: base_url,
+                git_url: git_url,
+                http_url: http_url,
+                ssh_url: ssh_url,
+                disabled_methods: disabled_methods)
         end
 
-        Autoproj.add_source_handler name.downcase do |url, vcs_options|
+        Autoproj.add_source_handler name.downcase do |url, private: false, **vcs_options|
             if url !~ /\.git$/
                 url += ".git"
             end
             if url !~ /^\//
                 url = "/#{url}"
             end
-            github_options, vcs_options = Kernel.filter_options vcs_options,
-                private: false
 
+            if !GIT_SERVER_CONFIG_VARS.all? { |v| config.has_value_for?("#{name}#{v}") }
+                pull, push, private_pull = git_server_resolve_master_config(name, config,
+                    base_url: base_url,
+                    git_url: git_url,
+                    http_url: http_url,
+                    ssh_url: ssh_url,
+                    disabled_methods: disabled_methods)
+            end
             pull_base_url =
-                if github_options[:private]
+                if private
                     config.get("#{name}_PRIVATE_ROOT")
                 else
                     config.get("#{name}_ROOT")
@@ -99,21 +125,22 @@ def self.git_server_configuration(name, base_url, options = Hash.new)
             Hash[type: 'git',
                  url: "#{pull_base_url}#{url}",
                  push_to: "#{push_base_url}#{url}",
-                 interactive: (github_options[:private] && private_pull == 'http'),
+                 interactive: (private && private_pull == 'http'),
                  retry_count: 10,
                  repository_id: "#{name.downcase}:#{url}"].merge(vcs_options)
         end
     end
 
-    def self.gitorious_server_configuration(name, base_url, options = Hash.new)
+    def self.gitorious_server_configuration(name, base_url, **options)
         Autoproj.warn_deprecated "gitorious_server_configuration",
             "use require 'git_server_configuration' and
             Autoproj.git_server_configuration instead. note that the method call
             interface has not changed, you just have to change the name(s)"
-        git_server_configuration(name, base_url, options)
+        git_server_configuration(name, base_url, **options)
     end
 end
 
-Autoproj.git_server_configuration('GITORIOUS', 'gitorious.org', default: 'http,ssh', disabled_methods: 'git')
-Autoproj.git_server_configuration('GITHUB', 'github.com', http_url: 'https://github.com', default: 'http,ssh')
-
+if !$autoproj_disable_github_gitorious_definitions
+    Autoproj.git_server_configuration('GITORIOUS', 'gitorious.org', default: 'http,ssh', disabled_methods: 'git', lazy: true)
+    Autoproj.git_server_configuration('GITHUB', 'github.com', http_url: 'https://github.com', default: 'http,ssh')
+end