autoproj 2.12.0 → 2.15.0

data/lib/autoproj/environment.rb

@@ -1,7 +1,8 @@
 module Autoproj
     ENV_FILENAME =
         if Autobuild.windows? then "env.bat"
-        else "env.sh"
+        else
+            "env.sh"
         end
 
     class Environment < Autobuild::Environment
@@ -9,7 +10,7 @@ module Autoproj
 
         def prepare(root_dir)
             @root_dir = root_dir
-            set 'AUTOPROJ_CURRENT_ROOT', root_dir
+            set "AUTOPROJ_CURRENT_ROOT", root_dir
             super()
         end
 
@@ -17,36 +18,43 @@ module Autoproj
             Autoproj.filter_out_paths_in_workspace(env)
         end
 
+        def env_filename(shell, *subdir)
+            env_filename = if shell == "sh"
+                               ENV_FILENAME
+                           else
+                               (Pathname(ENV_FILENAME).sub_ext "").to_s.concat(".#{shell}")
+                           end
+
+            File.join(root_dir, *subdir, env_filename)
+        end
+
+        def each_env_filename(*subdir)
+            (["sh"] + Autoproj.workspace.config.user_shells).to_set.each do |shell|
+                yield shell, env_filename(shell, *subdir)
+            end
+        end
+
         def export_env_sh(subdir = nil, options = Hash.new)
             if subdir.kind_of?(Hash)
-                subdir, options = nil, subdir
+                options = subdir
+                subdir = nil
             end
             options = validate_options options,
-                shell_helpers: true
+                                       shell_helpers: true
 
             shell_dir = File.expand_path(File.join("..", "..", "shell"), File.dirname(__FILE__))
-            completion_dir = File.join(shell_dir, 'completion')
+            completion_dir = File.join(shell_dir, "completion")
             env_updated = false
 
-            (['sh'] + Autoproj.workspace.config.user_shells).to_set.each do |shell|
-                env_filename = if shell == 'sh'
-                                   ENV_FILENAME
-                               else
-                                   (Pathname(ENV_FILENAME).sub_ext '').to_s.concat(".#{shell}")
-                               end
-
-                filename = if subdir
-                    File.join(root_dir, subdir, env_filename)
-                else
-                    File.join(root_dir, env_filename)
-                end
-
+            each_env_filename(*[subdir].compact) do |shell, filename|
                 helper = File.join(shell_dir, "autoproj_#{shell}")
                 if options[:shell_helpers]
                     source_after(helper, shell: shell) if File.file?(helper)
                     %w[alocate alog amake aup autoproj].each do |tool|
                         completion_file = File.join(completion_dir, "#{tool}_#{shell}")
-                        source_after(completion_file, shell: shell) if File.file?(completion_file)
+                        if File.file?(completion_file)
+                            source_after(completion_file, shell: shell)
+                        end
                     end
                 end
 
@@ -55,7 +63,7 @@ module Autoproj
                     rescue SystemCallError
                     end
 
-                StringIO.open(new_content = String.new, 'w') do |io|
+                StringIO.open(new_content = String.new, "w") do |io|
                     if inherit?
                         io.write <<-EOF
                         if test -n "$AUTOPROJ_CURRENT_ROOT" && test "$AUTOPROJ_CURRENT_ROOT" != "#{root_dir}"; then
@@ -80,46 +88,57 @@ module Autoproj
     def self.env_set(name, *value)
         env.set(name, *value)
     end
+
     # @deprecated call Autoproj.env.add instead
     def self.env_add(name, *value)
         env.add(name, *value)
     end
+
     # @deprecated call Autoproj.env.set_path instead
     def self.env_set_path(name, *value)
         env.set_path(name, *value)
     end
+
     # @deprecated call Autoproj.env.add_path instead
     def self.env_add_path(name, *value)
         env.add_path(name, *value)
     end
+
     # @deprecated call Autoproj.env.source_after instead
-    def self.env_source_file(file, shell: 'sh')
+    def self.env_source_file(file, shell: "sh")
         env.source_after(file, shell: shell)
     end
+
     # @deprecated call Autoproj.env.source_after instead
-    def self.env_source_after(file, shell: 'sh')
+    def self.env_source_after(file, shell: "sh")
         env.source_after(file, shell: shell)
     end
+
     # @deprecated call Autoproj.env.source_before instead
-    def self.env_source_before(file, shell: 'sh')
+    def self.env_source_before(file, shell: "sh")
         env.source_before(file, shell: shell)
     end
+
     # @deprecated call Autoproj.env.inherit instead
     def self.env_inherit(*names)
         env.inherit(*names)
     end
+
     # @deprecated use Autoproj.env.isolate instead
     def self.set_initial_env
         isolate_environment
     end
+
     # @deprecated use Autoproj.env.isolate instead
     def self.isolate_environment
         env.isolate
     end
+
     # @deprecated call Autoproj.env.prepare directly
     def self.prepare_environment(env = Autoproj.env, manifest = Autoproj.manifest)
         env.prepare(manifest)
     end
+
     # @deprecated use Autoproj.env.export_env_sh instead
     def self.export_env_sh(subdir = nil)
         env.export_env_sh(subdir)

data/lib/autoproj/exceptions.rb

@@ -1,13 +1,15 @@
-require 'autobuild/exceptions'
+require "autobuild/exceptions"
 
 module Autoproj
     class ConfigError < RuntimeError
         attr_accessor :file
+
         def initialize(file = nil)
             super
             @file = file
         end
     end
+
     class InternalError < RuntimeError; end
 
     class ImportFailed < Autobuild::CompositeException
@@ -48,8 +50,11 @@ module Autoproj
     # Exception raised when a caller requires to use an excluded package
     class ExcludedPackage < ConfigError
         attr_reader :name
+
         def initialize(name)
             @name = name
+
+            super()
         end
     end
 
@@ -65,8 +70,11 @@ module Autoproj
     # selection is completely excluded
     class ExcludedSelection < ConfigError
         attr_reader :selection
+
         def initialize(selection)
             @selection = selection
+
+            super()
         end
     end
 
@@ -90,5 +98,3 @@ module Autoproj
     # Raised by 'which' when an executable cannot be found
     class ExecutableNotFound < ArgumentError; end
 end
-
-

data/lib/autoproj/find_workspace.rb

@@ -1,10 +1,10 @@
-require 'pathname'
-require 'yaml'
+require "pathname"
+require "yaml"
 
 module Autoproj
     # The base path from which we search for workspaces
     def self.default_find_base_dir
-        ENV['AUTOPROJ_CURRENT_ROOT'] || Dir.pwd
+        ENV["AUTOPROJ_CURRENT_ROOT"] || Dir.pwd
     end
 
     # Looks for the autoproj workspace that is related to a given directory
@@ -29,19 +29,16 @@ module Autoproj
     #   if base_dir is not part of a workspace
     def self.find_v2_workspace_config(base_dir)
         path = Pathname.new(base_dir).expand_path
-        while !path.root?
-            if (path + ".autoproj" + "config.yml").exist?
-                break
-            end
+        until path.root?
+            break if path.join(".autoproj", "config.yml").exist?
+
             path = path.parent
         end
 
-        if path.root?
-            return
-        end
+        return if path.root?
 
-        config_path = path + ".autoproj" + "config.yml"
-        return path.to_s, (YAML.load(config_path.read) || Hash.new)
+        config_path = path.join(".autoproj", "config.yml")
+        [path.to_s, (YAML.load(config_path.read) || Hash.new)]
     end
 
     # @private
@@ -58,17 +55,18 @@ module Autoproj
     #   there's none
     def self.find_v2_root_dir(base_dir, config_field_name)
         path, config = find_v2_workspace_config(base_dir)
-        return if !path
+        return unless path
+
         result = config[config_field_name] || path.to_s
         result = File.expand_path(result, path.to_s)
-        if result == path.to_s
-            return result
-        end
+        return result if result == path.to_s
+
         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 that points to #{result} and #{result} is not an autoproj workspace root"
         end
+
         resolved
     end
 
@@ -84,7 +82,7 @@ module Autoproj
                 ws_path, ws_config = find_v2_workspace_config(p)
                 if ws_path
                     known_workspace_dirs << "#{ws_path}/"
-                    if ws_dir = ws_config['workspace']
+                    if (ws_dir = ws_config["workspace"])
                         known_workspace_dirs << "#{ws_dir}/"
                     end
                     false
@@ -97,12 +95,12 @@ module Autoproj
 
     # {#find_workspace_dir} for v2 workspaces
     def self.find_v2_workspace_dir(base_dir = default_find_base_dir)
-        find_v2_root_dir(base_dir, 'workspace')
+        find_v2_root_dir(base_dir, "workspace")
     end
 
     # {#find_prefix_dir} for v2 workspaces
     def self.find_v2_prefix_dir(base_dir = default_find_base_dir)
-        find_v2_root_dir(base_dir, 'prefix')
+        find_v2_root_dir(base_dir, "prefix")
     end
 
     # {#find_workspace_dir} for v1 workspaces
@@ -110,15 +108,12 @@ module Autoproj
     # Note that for v1 workspaces {#find_prefix_dir} cannot be implemented
     def self.find_v1_workspace_dir(base_dir = default_find_base_dir)
         path = Pathname.new(base_dir)
-        while !path.root?
-            if (path + "autoproj").exist?
-                if !(path + ".autoproj").exist?
-                    return path.to_s
-                end
+        until path.root?
+            if path.join("autoproj").exist?
+                return path.to_s unless path.join(".autoproj").exist?
             end
             path = path.parent
         end
         nil
     end
 end
-

data/lib/autoproj/git_server_configuration.rb

@@ -1,16 +1,15 @@
 module Autoproj
-    GIT_SERVER_CONFIG_VARS = %w{_ROOT _PUSH_ROOT _PRIVATE_ROOT}
+    GIT_SERVER_CONFIG_VARS = %w[_ROOT _PUSH_ROOT _PRIVATE_ROOT]
 
     GIT_SERVER_ACCESS_METHODS = Hash[
-        'git' => 'git,ssh',
-        'ssh' => 'ssh,ssh',
-        'http' => 'http,http']
-
+        "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: )
+    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)
@@ -25,7 +24,7 @@ module Autoproj
     # @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: )
+    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)
@@ -35,7 +34,7 @@ module Autoproj
             access_mode = config.get(name)
         end
         access_mode = GIT_SERVER_ACCESS_METHODS[access_mode] || access_mode
-        pull, push, private_pull = access_mode.split(',')
+        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
@@ -44,7 +43,7 @@ module Autoproj
                   end
             config.set("#{name}#{var_suffix}", url)
         end
-        return pull, push, private_pull
+        [pull, push, private_pull]
     end
 
     # Adds the relevant options to handle a gitorious server
@@ -67,53 +66,50 @@ module Autoproj
     # which would be expanded to the expected URLs for pull and push.
     #
     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,
-            lazy: false)
+        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,
+        lazy: false)
 
         disabled_methods = Array(disabled_methods)
 
         long_doc = [
-            "How should I interact with #{base_url} (#{(GIT_SERVER_ACCESS_METHODS.keys - disabled_methods).sort.join(", ")})",
+            "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)"]
+            "used by default)"
+        ]
 
-        config.declare name, 'string', default: default, doc: long_doc do |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
 
-        if !lazy
+        unless 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)
+                                                                        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, private: false, **vcs_options|
-            if url !~ /\.git$/
-                url += ".git"
-            end
-            if url !~ /^\//
-                url = "/#{url}"
-            end
+            url += ".git" if url !~ /\.git$/
+            url = "/#{url}" if url !~ /^\//
 
-            if !GIT_SERVER_CONFIG_VARS.all? { |v| config.has_value_for?("#{name}#{v}") }
+            unless 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)
+                                                                            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 private
@@ -122,10 +118,10 @@ module Autoproj
                     config.get("#{name}_ROOT")
                 end
             push_base_url = config.get("#{name}_PUSH_ROOT")
-            Hash[type: 'git',
+            Hash[type: "git",
                  url: "#{pull_base_url}#{url}",
                  push_to: "#{push_base_url}#{url}",
-                 interactive: (private && private_pull == 'http'),
+                 interactive: (private && private_pull == "http"),
                  retry_count: 10,
                  repository_id: "#{name.downcase}:#{url}"].merge(vcs_options)
         end
@@ -133,14 +129,14 @@ module Autoproj
 
     def self.gitorious_server_configuration(name, base_url, **options)
         Autoproj.warn_deprecated "gitorious_server_configuration",
-            "use require 'git_server_configuration' and
+                                 "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)
     end
 end
 
-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')
+unless $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

data/lib/autoproj/gitorious.rb

@@ -1 +1 @@
-require 'autoproj/git_server_configuration'
+require "autoproj/git_server_configuration"

data/lib/autoproj/installation_manifest.rb

@@ -8,33 +8,76 @@ module Autoproj
         attr_reader :path
         attr_reader :packages
         attr_reader :package_sets
-        def initialize(path)
+
+        def initialize(path = nil)
             @path = path
             @packages = Hash.new
             @package_sets = Hash.new
         end
 
         def exist?
-            File.exist?(path)
+            File.exist?(path) if path
         end
 
+        # Add a {PackageDefinition} to this manifest
+        #
+        # @return [Package] the package in the installation manifest format
         def add_package(pkg)
-            packages[pkg.name] = pkg
+            packages[pkg.name] =
+                case pkg
+                when PackageDefinition
+                    v = pkg.autobuild
+                    Package.new(
+                        v.name, v.class.name, pkg.vcs.to_hash, v.srcdir,
+                        (v.importdir if v.respond_to?(:importdir)),
+                        v.prefix,
+                        (v.builddir if v.respond_to?(:builddir)),
+                        v.logdir, v.dependencies
+                    )
+                else
+                    pkg
+                end
         end
 
+        # Add a {Autoproj::PackageSet} to this manifest
+        #
+        # @return [PackageSet] the package set in the installation manifest format
         def add_package_set(pkg_set)
-            package_sets[pkg_set.name] = pkg_set
+            package_sets[pkg_set.name] = PackageSet.new(
+                pkg_set.name, pkg_set.vcs.to_hash,
+                pkg_set.raw_local_dir, pkg_set.user_local_dir
+            )
         end
 
+        # Enumerate this {InstallationManifest}'s package sets
+        #
+        # @yieldparam [PackageSet]
         def each_package_set(&block)
             package_sets.each_value(&block)
         end
 
+        # Enumerate this {InstallationManifest}'s packages
+        #
+        # @yieldparam [Package]
         def each_package(&block)
             packages.each_value(&block)
         end
 
-        def load
+        # Resolve a package set by name
+        #
+        # @return [Package]
+        def find_package_set_by_name(name)
+            @package_sets[name]
+        end
+
+        # Resolve a package by name
+        #
+        # @return [Package]
+        def find_package_by_name(name)
+            @packages[name]
+        end
+
+        def load(path = @path)
             @packages = Hash.new
             raw = YAML.load(File.open(path))
             if raw.respond_to?(:to_str) # old CSV-based format
@@ -46,14 +89,16 @@ module Autoproj
                 save(path)
             else
                 raw.each do |entry|
-                    if entry['package_set']
+                    if entry["package_set"]
                         pkg_set = PackageSet.new(
-                            entry['package_set'], entry['vcs'], entry['raw_local_dir'], entry['user_local_dir'])
+                            entry["package_set"], entry["vcs"], entry["raw_local_dir"], entry["user_local_dir"]
+                        )
                         package_sets[pkg_set.name] = pkg_set
                     else
                         pkg = Package.new(
-                            entry['name'], entry['type'], entry['vcs'], entry['srcdir'], entry['importdir'],
-                            entry['prefix'], entry['builddir'], entry['logdir'], entry['dependencies'])
+                            entry["name"], entry["type"], entry["vcs"], entry["srcdir"], entry["importdir"],
+                            entry["prefix"], entry["builddir"], entry["logdir"], entry["dependencies"]
+                        )
                         packages[pkg.name] = pkg
                     end
                 end
@@ -61,25 +106,15 @@ module Autoproj
         end
 
         # Save the installation manifest
-        def save(path = self.path)
+        def save(path = @path)
             Ops.atomic_write(path) do |io|
-                marshalled_package_sets = each_package_set.map do |v|
-                    Hash['package_set' => v.name,
-                         'vcs' => v.vcs.to_hash,
-                         'raw_local_dir' => v.raw_local_dir,
-                         'user_local_dir' => v.user_local_dir]
+                marshalled_package_sets = each_package_set.map do |pkg_set|
+                    set = pkg_set.to_h.transform_keys(&:to_s)
+                    set["package_set"] = set["name"]
+                    set
                 end
-                marshalled_packages = each_package.map do |package_def|
-                    v = package_def.autobuild
-                    Hash['name' => v.name,
-                         'type' => v.class.name,
-                         'vcs' => package_def.vcs.to_hash,
-                         'srcdir' => v.srcdir,
-                         'importdir' => (v.importdir if v.respond_to?(:importdir)),
-                         'builddir' => (v.builddir if v.respond_to?(:builddir)),
-                         'logdir' => v.logdir,
-                         'prefix' => v.prefix,
-                         'dependencies' => v.dependencies]
+                marshalled_packages = each_package.map do |pkg|
+                    pkg.to_h.transform_keys(&:to_s)
                 end
                 io.write YAML.dump(marshalled_package_sets + marshalled_packages)
             end
@@ -91,18 +126,18 @@ module Autoproj
         # @param [String] root_dir
         # @return [String]
         def self.path_for_workspace_root(root_dir)
-            File.join(root_dir, '.autoproj', 'installation-manifest')
+            File.join(root_dir, ".autoproj", "installation-manifest")
         end
 
         def self.from_workspace_root(root_dir)
             path = path_for_workspace_root(root_dir)
             manifest = InstallationManifest.new(path)
-            if !manifest.exist?
+            unless manifest.exist?
                 raise ConfigError.new, "no #{path} file found. You should probably rerun autoproj envsh in that folder first"
             end
+
             manifest.load
             manifest
         end
     end
 end
-