autoproj 2.13.0 → 2.15.2

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
-

data/lib/autoproj/local_package_set.rb

@@ -3,7 +3,7 @@ module Autoproj
     # in autoproj/
     class LocalPackageSet < PackageSet
         def initialize(ws, local_dir: ws.config_dir)
-            super(ws, VCSDefinition.none, name: 'main configuration', raw_local_dir: local_dir)
+            super(ws, VCSDefinition.none, name: "main configuration", raw_local_dir: local_dir)
             @local_dir = local_dir
         end
 
@@ -28,7 +28,7 @@ module Autoproj
         end
 
         def overrides_file_path
-            if d = local_dir
+            if (d = local_dir)
                 File.join(d, "overrides.yml")
             end
         end
@@ -47,7 +47,7 @@ module Autoproj
         # Load the files in overrides.d in addition to the overrides: field in
         # the yaml file
         def load_overrides(source_definition)
-            files = Dir.glob(File.join( ws.overrides_dir, "*.yml" ) ).sort
+            files = Dir.glob(File.join(ws.overrides_dir, "*.yml")).sort
             overrides = files.map do |file|
                 source_data = Autoproj.in_file(file, Autoproj::YAML_LOAD_ERROR) do
                     YAML.load(File.read(file)) || Array.new
@@ -55,7 +55,8 @@ module Autoproj
                 source_data =
                     if source_data.respond_to?(:to_ary)
                         source_data
-                    else source_data['overrides'] || Hash.new
+                    else
+                        source_data["overrides"] || Hash.new
                     end
                 [file, source_data]
             end
@@ -64,24 +65,25 @@ module Autoproj
 
         def raw_description_file
             description = Hash[
-                'imports' => Array.new,
-                'version_control' => Array.new,
-                'overrides' => Array.new]
+                "imports" => Array.new,
+                "version_control" => Array.new,
+                "overrides" => Array.new]
             if File.file?(overrides_file_path)
                 overrides_data = Autoproj.in_file(overrides_file_path, Autoproj::YAML_LOAD_ERROR) do
                     YAML.load(File.read(overrides_file_path)) || Hash.new
                 end
                 overrides_data = PackageSet.validate_and_normalize_source_file(
-                    overrides_file_path, overrides_data)
+                    overrides_file_path, overrides_data
+                )
                 description = description.merge(overrides_data)
             end
 
             manifest_data = Autoproj.in_file(manifest_path, Autoproj::YAML_LOAD_ERROR) do
                 YAML.load(File.read(manifest_path)) || Hash.new
             end
-            description['imports'] = description['imports'].
-                concat(manifest_data['package_sets'] || Array.new)
-            description['name'] = name
+            description["imports"] = description["imports"]
+                                     .concat(manifest_data["package_sets"] || Array.new)
+            description["name"] = name
             description
         end
     end