autoproj 2.13.0 → 2.15.2

data/lib/autoproj/repository_managers/apt.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: false
 
-require 'open3'
-require 'pathname'
-require 'open-uri'
+require "open3"
+require "pathname"
+require "open-uri"
 
 module Autoproj
     module RepositoryManagers
@@ -13,14 +13,14 @@ module Autoproj
             attr_reader :sources_dir
             attr_reader :autoproj_sources
 
-            SOURCES_DIR = '/etc/apt'.freeze
-            SOURCE_TYPES = ['deb', 'deb-src'].freeze
-            AUTOPROJ_SOURCES = '/etc/apt/sources.list.d/autoproj.list'.freeze
+            SOURCES_DIR = "/etc/apt".freeze
+            SOURCE_TYPES = %w[deb deb-src].freeze
+            AUTOPROJ_SOURCES = "/etc/apt/sources.list.d/autoproj.list".freeze
 
             def initialize(ws, sources_dir: SOURCES_DIR, autoproj_sources: AUTOPROJ_SOURCES)
                 @sources_dir = sources_dir
                 @autoproj_sources = autoproj_sources
-                @source_files = Dir[File.join(sources_dir, '**', '*.list')]
+                @source_files = Dir[File.join(sources_dir, "**", "*.list")]
                 @source_entries = {}
 
                 source_files.each { |file| load_sources_from_file(file) }
@@ -28,7 +28,7 @@ module Autoproj
             end
 
             def os_dependencies
-                super + ['archive-keyring', 'gnupg', 'apt-transport-https']
+                super + %w[archive-keyring gnupg apt-transport-https]
             end
 
             def load_sources_from_file(file)
@@ -45,16 +45,16 @@ module Autoproj
                 entry = {}
                 entry[:valid] = false
                 entry[:enabled] = true
-                entry[:source] = ''
-                entry[:comment] = ''
+                entry[:source] = ""
+                entry[:comment] = ""
 
                 line.strip!
-                if line.start_with?('#')
+                if line.start_with?("#")
                     entry[:enabled] = false
                     line = line[1..-1]
                 end
 
-                i = line.index('#')
+                i = line.index("#")
                 if i&.positive?
                     entry[:comment] = line[(i + 1)..-1].strip
                     line = line[0..(i - 1)]
@@ -63,7 +63,7 @@ module Autoproj
                 entry[:source] = line.strip
                 chunks = entry[:source].split
                 entry[:valid] = true if SOURCE_TYPES.include?(chunks[0])
-                entry[:source] = chunks.join(' ')
+                entry[:source] = chunks.join(" ")
 
                 if raise_if_invalid && (!entry[:valid] || !entry[:enabled])
                     raise ConfigError, "Invalid source line: #{entry[:source]}"
@@ -74,7 +74,7 @@ module Autoproj
 
             def add_source(source, file = nil)
                 file = if file
-                           File.join(sources_dir, 'sources.list.d', file)
+                           File.join(sources_dir, "sources.list.d", file)
                        else
                            autoproj_sources
                        end
@@ -95,8 +95,8 @@ module Autoproj
 
             def append_entry(contents, entry)
                 unless entry[:enabled]
-                    contents << '#'
-                    contents << ' ' unless entry[:source].start_with?('#')
+                    contents << "#"
+                    contents << " " unless entry[:source].start_with?("#")
                 end
 
                 contents << entry[:source]
@@ -105,17 +105,17 @@ module Autoproj
             end
 
             def enable_entry_in_file(file, enable_entry)
-                contents = ''
+                contents = ""
                 source_entries[file].each do |entry|
                     entry[:enabled] = true if enable_entry[:source] == entry[:source]
                     append_entry(contents, entry)
                 end
-                run_tee_command(['sudo', 'tee', file], contents)
+                run_tee_command(["sudo", "tee", file], contents)
                 true
             end
 
             def add_entry_to_file(file, entry)
-                run_tee_command(['sudo', 'tee', '-a', file], entry[:source])
+                run_tee_command(["sudo", "tee", "-a", file], entry[:source])
                 @source_entries[file] ||= []
                 @source_entries[file] << entry
                 true
@@ -123,7 +123,7 @@ module Autoproj
 
             def run_tee_command(command, contents)
                 contents = StringIO.new("#{contents}\n")
-                Autobuild::Subprocess.run('autoproj', 'osrepos', *command, input_streams: [contents])
+                Autobuild::Subprocess.run("autoproj", "osrepos", *command, input_streams: [contents])
             end
 
             def entry_exist?(new_entry)
@@ -140,7 +140,7 @@ module Autoproj
 
             def key_exist?(key)
                 exist = false
-                Open3.popen3({'LANG' => 'C'}, 'apt-key', 'export', key) do |_, _, stderr, wait_thr|
+                Open3.popen3({ "LANG" => "C" }, "apt-key", "export", key) do |_, _, stderr, wait_thr|
                     success = wait_thr.value.success?
                     stderr = stderr.read
                     has_error = stderr.match(/WARNING: nothing exported/)
@@ -151,36 +151,36 @@ module Autoproj
 
             def apt_update
                 Autobuild::Subprocess.run(
-                    'autoproj',
-                    'osrepos',
-                    'sudo',
-                    'apt-get',
-                    'update'
+                    "autoproj",
+                    "osrepos",
+                    "sudo",
+                    "apt-get",
+                    "update"
                 )
             end
 
             def add_apt_key(id, origin, type: :keyserver)
                 if type == :keyserver
                     Autobuild::Subprocess.run(
-                        'autoproj',
-                        'osrepos',
-                        'sudo',
-                        'apt-key',
-                        'adv',
-                        '--keyserver',
+                        "autoproj",
+                        "osrepos",
+                        "sudo",
+                        "apt-key",
+                        "adv",
+                        "--keyserver",
                         origin,
-                        '--recv-key',
+                        "--recv-key",
                         id
                     )
                 else
-                    open(origin) do |io|
+                    URI(origin).open do |io|
                         Autobuild::Subprocess.run(
-                            'autoproj',
-                            'osrepos',
-                            'sudo',
-                            'apt-key',
-                            'add',
-                            '-',
+                            "autoproj",
+                            "osrepos",
+                            "sudo",
+                            "apt-key",
+                            "add",
+                            "-",
                             input_streams: [io]
                         )
                     end
@@ -191,24 +191,24 @@ module Autoproj
 
             def filter_installed_definitions(definitions)
                 definitions = definitions.dup.reject do |definition|
-                    if definition['type'] == 'repo'
-                        _, entry = source_exist?(definition['repo'])
+                    if definition["type"] == "repo"
+                        _, entry = source_exist?(definition["repo"])
                         entry && entry[:enabled]
                     else
-                        key_exist?(definition['id'])
+                        key_exist?(definition["id"])
                     end
                 end
                 definitions
             end
 
             def print_installing_definitions(definitions)
-                repos = definitions.select { |definition| definition['type'] == 'repo' }
-                keys = definitions.select { |definition| definition['type'] == 'key' }
+                repos = definitions.select { |definition| definition["type"] == "repo" }
+                keys = definitions.select { |definition| definition["type"] == "key" }
 
                 unless repos.empty?
-                    Autoproj.message '  adding apt repositories:'
+                    Autoproj.message "  adding apt repositories:"
                     repos.each do |repo|
-                        if repo['file']
+                        if repo["file"]
                             Autoproj.message "    #{repo['repo']}, file: #{repo['file']}"
                         else
                             Autoproj.message "    #{repo['repo']}"
@@ -217,9 +217,9 @@ module Autoproj
                 end
                 return if keys.empty?
 
-                Autoproj.message '  adding apt keys:'
+                Autoproj.message "  adding apt keys:"
                 keys.each do |key|
-                    if key['keyserver']
+                    if key["keyserver"]
                         Autoproj.message "    id: #{key['id']}, keyserver: #{key['keyserver']}"
                     else
                         Autoproj.message "    id: #{key['id']}, url: #{key['url']}"
@@ -249,27 +249,61 @@ module Autoproj
             #     url: 'http://packages.osrfoundation.org/gazebo.key'
             #
             def validate_definitions(definitions)
-                invalid_string = 'Invalid apt repository definition'
                 definitions.each do |definition|
-                    raise ConfigError, "#{invalid_string} type: #{definition['type']}" unless %w[repo key].include?(definition['type'])
-
-                    if definition['type'] == 'repo'
-                        raise ConfigError, "#{invalid_string}: 'repo' key missing" if definition['repo'].nil?
-                        raise ConfigError, "#{invalid_string}: 'repo' should be a String" unless definition['repo'].is_a?(String)
-                        raise ConfigError, "#{invalid_string}: 'file' should be a String" if definition['file'] && !definition['file'].is_a?(String)
-                        if definition['file'] && Pathname.new(definition['file']).absolute?
-                            raise ConfigError, "#{invalid_string}: 'file' should be a relative to #{File.join(SOURCES_DIR, 'sources.list.d')}"
-                        end
+                    case definition["type"]
+                    when "repo"
+                        validate_repo_definition(definition)
+                    when "key"
+                        validate_key_definition(definition)
                     else
-                        raise ConfigError, "#{invalid_string}: 'id' key missing" if definition['id'].nil?
-                        raise ConfigError, "#{invalid_string}: 'id' should be a String" unless definition['id'].is_a?(String)
-                        raise ConfigError, "#{invalid_string}: 'url' conflicts with 'keyserver'" if definition['url'] && definition['keyserver']
-                        raise ConfigError, "#{invalid_string}: 'url' should be a String" if definition['url'] && !definition['url'].is_a?(String)
-                        raise ConfigError, "#{invalid_string}: 'keyserver' should be a String" if definition['keyserver'] && !definition['keyserver'].is_a?(String)
+                        raise ConfigError,
+                              "#{INVALID_REPO_MESSAGE} type: #{definition['type']}"
                     end
                 end
             end
 
+            INVALID_REPO_MESSAGE = "Invalid apt repository definition".freeze
+
+            # rubocop:disable Style/GuardClause
+
+            def validate_repo_definition(definition)
+                if definition["repo"].nil?
+                    raise ConfigError, "#{INVALID_REPO_MESSAGE}: 'repo' key missing"
+                elsif !definition["repo"].is_a?(String)
+                    raise ConfigError,
+                          "#{INVALID_REPO_MESSAGE}: 'repo' should be a String"
+                elsif definition["file"] && !definition["file"].is_a?(String)
+                    raise ConfigError,
+                          "#{INVALID_REPO_MESSAGE}: 'file' should be a String"
+                elsif definition["file"] && Pathname.new(definition["file"]).absolute?
+                    raise ConfigError,
+                          "#{INVALID_REPO_MESSAGE}: 'file' should be relative "\
+                          "to #{File.join(SOURCES_DIR, 'sources.list.d')}"
+                end
+
+                nil
+            end
+
+            def validate_key_definition(definition)
+                if definition["id"].nil?
+                    raise ConfigError, "#{INVALID_REPO_MESSAGE}: 'id' key missing"
+                elsif !definition["id"].is_a?(String)
+                    raise ConfigError, "#{INVALID_REPO_MESSAGE}: 'id' should be a String"
+                elsif definition["url"] && definition["keyserver"]
+                    raise ConfigError,
+                          "#{INVALID_REPO_MESSAGE}: 'url' conflicts with 'keyserver'"
+                elsif definition["url"] && !definition["url"].is_a?(String)
+                    raise ConfigError, "#{INVALID_REPO_MESSAGE}: 'url' should be a String"
+                elsif definition["keyserver"] && !definition["keyserver"].is_a?(String)
+                    raise ConfigError,
+                          "#{INVALID_REPO_MESSAGE}: 'keyserver' should be a String"
+                end
+
+                nil
+            end
+
+            # rubocop:enable Style/GuardClause
+
             def install(definitions)
                 super
                 validate_definitions(definitions)
@@ -277,12 +311,12 @@ module Autoproj
                 print_installing_definitions(definitions)
 
                 definitions.each do |definition|
-                    if definition['type'] == 'repo'
-                        add_source(definition['repo'], definition['file'])
+                    if definition["type"] == "repo"
+                        add_source(definition["repo"], definition["file"])
                     else
-                        type = definition['url'] ? 'url' : 'keyserver'
+                        type = definition["url"] ? "url" : "keyserver"
                         origin = definition[type]
-                        add_apt_key(definition['id'], origin, type: type.to_sym)
+                        add_apt_key(definition["id"], origin, type: type.to_sym)
                     end
                 end
                 apt_update unless definitions.empty?

data/lib/autoproj/repository_managers/unknown_os_manager.rb

@@ -9,9 +9,9 @@ module Autoproj
             end
 
             def osrepos_interaction_unknown_os
-                Autoproj.message 'The build process requires some repositories to be added on our operating system', :bold
-                Autoproj.message 'If they are already added, simply ignore this message', :bold
-                Autoproj.message 'Press ENTER to continue ', :bold
+                Autoproj.message "The build process requires some repositories to be added on our operating system", :bold
+                Autoproj.message "If they are already added, simply ignore this message", :bold
+                Autoproj.message "Press ENTER to continue ", :bold
 
                 STDIN.readline
                 nil

data/lib/autoproj/ros_condition_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "parslet"
+require "autoproj/exceptions"
+require "autoproj/variable_expansion"
+
+module Autoproj
+    # Parses a conditional expression
+    # Syntax and rules as defined in https://www.ros.org/reps/rep-0149.html#id20
+    class RosConditionParser < Parslet::Parser
+        def initialize(context)
+            @context = context
+            super()
+        end
+
+        def expand(var)
+            Autoproj.expand(var, @context)
+        rescue StandardError
+            ""
+        end
+
+        # Evaluates the Abstract Syntax Tree generated by the parser
+        class Transform < Parslet::Transform
+            rule(literal: simple(:x)) { String(x) }
+            rule(variable: simple(:x)) { expander.call(String(x)) }
+            rule(op: simple(:o), lhs: simple(:l), rhs: simple(:r)) { l.send(o, r) }
+            rule(op: "and", lhs: simple(:l), rhs: simple(:r)) { l && r }
+            rule(op: "or", lhs: simple(:l), rhs: simple(:r)) { l || r }
+        end
+
+        def evaluate(expr)
+            Transform.new.apply(parse(expr.strip), expander: method(:expand))
+        rescue Parslet::ParseFailed => e
+            raise Autoproj::ConfigError, e.message
+        end
+
+        def any_of(strings)
+            strings = strings.dup
+            strings.reduce(str(strings.shift)) { |acc, s| acc | str(s) }
+        end
+
+        def quoted_literal(quote)
+            str(quote) >> (
+                str(quote).absent? >> any
+            ).repeat.maybe.as(:literal) >> str(quote)
+        end
+
+        def chain(lhs, operator, operation)
+            (lhs.as(:lhs) >> operator >> operation.as(:rhs)) | lhs
+        end
+
+        RESERVED = %w[and or].freeze
+
+        rule(:space) { match['\s\t'].repeat(1) }
+        rule(:space?) { space.maybe }
+        rule(:lparen) { str("(") >> space? }
+        rule(:rparen) { str(")") >> space? }
+        rule(:comp_operator) { any_of(%w[== != >= <= > <]).as(:op) >> space? }
+        rule(:and_operator) { str("and").as(:op) >> space? }
+        rule(:or_operator)  { str("or").as(:op) >> space? }
+        rule(:literal) do
+            (any_of(RESERVED) >> space).absent? >>
+                (match('\w') | match["_-"]).repeat(1)
+                                           .as(:literal)
+        end
+        rule(:double_quote) { quoted_literal('"') }
+        rule(:single_quote) { quoted_literal("'") }
+        rule(:variable) do
+            (
+                str("$") >> match('\d').absent? >> (
+                    match('\w') | match["_"]
+                ).repeat(1)
+            ).as(:variable)
+        end
+
+        rule(:term) { (literal | single_quote | double_quote | variable) >> space? }
+        rule(:primary) { (lparen >> or_operation >> rparen) | term }
+        rule(:comp_operation) { chain(primary, comp_operator, comp_operation) }
+        rule(:and_operation) { chain(comp_operation, and_operator, and_operation) }
+        rule(:or_operation) { chain(and_operation, or_operator, or_operation) }
+
+        root(:or_operation)
+    end
+end

data/lib/autoproj/ros_package_manifest.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Autoproj
+    # Access to the information contained in a package's package.xml file
+    #
+    # Use PackageManifest.load to create
+    class RosPackageManifest < PackageManifest
+        attr_accessor :name
+        attr_writer :build_type
+
+        def build_type
+            @build_type || "catkin"
+        end
+
+        # @api private
+        #
+        # REXML stream parser object used to load the XML contents into a
+        # {PackageManifest} object
+        class Loader < PackageManifest::Loader
+            MANIFEST_CLASS = RosPackageManifest
+            SUPPORTED_MODES = %w[test doc].freeze
+            DEPEND_TAGS = %w[depend build_depend build_export_depend
+                             buildtool_depend buildtool_export_depend
+                             exec_depend test_depend run_depend doc_depend].to_set.freeze
+
+            def initialize(path, manifest)
+                super
+                @env = manifest.package.ws.env
+                @condition_parser = RosConditionParser.new(@env)
+            end
+
+            def tag_start(name, attributes)
+                super
+                exportlevel_tag_start(name, attributes) if @export_level
+            end
+
+            def tag_end(name)
+                super
+                exportlevel_tag_end(name) if @export_level
+                if @tag_level == 0 && name == "package" &&
+                   (!manifest.name || manifest.name.empty?)
+                    raise InvalidPackageManifest, "Package name missiing in #{path}"
+                end
+            end
+
+            def exportlevel_tag_start(name, attributes)
+                return unless name == "build_type"
+
+                @build_type_condition = attributes["condition"]
+                @tag_text = ""
+            end
+
+            def exportlevel_tag_end(name)
+                return unless name == "build_type"
+                return unless handle_condition(@build_type_condition)
+
+                manifest.build_type = @tag_text.strip
+            end
+
+            def toplevel_tag_start(name, attributes)
+                if DEPEND_TAGS.include?(name)
+                    @depend_condition = attributes["condition"]
+                    @tag_text = ""
+                elsif TEXT_FIELDS.include?(name)
+                    @tag_text = ""
+                elsif AUTHOR_FIELDS.include?(name)
+                    @author_email = attributes["email"]
+                    @tag_text = ""
+                elsif name == "name"
+                    @tag_text = ""
+                elsif name == "export"
+                    @export_level = true
+                else
+                    @tag_text = nil
+                end
+            end
+
+            def handle_condition(expr)
+                return true unless expr && !expr.empty?
+
+                @condition_parser.evaluate(expr)
+            end
+
+            def depend_tag_end(name)
+                return unless handle_condition(@depend_condition)
+
+                if @tag_text.strip.empty?
+                    raise InvalidPackageManifest, "found '#{name}' tag in #{path} "\
+                                                  "without content"
+                end
+
+                mode = []
+                if (m = /^(\w+)_depend$/.match(name))
+                    mode = SUPPORTED_MODES & [m[1]]
+                end
+
+                manifest.add_dependency(@tag_text, modes: mode)
+            end
+
+            def author_tag_end(name)
+                author_name = @tag_text.strip
+                email = @author_email ? @author_email.strip : nil
+                email = nil if email&.empty?
+                contact = PackageManifest::ContactInfo.new(author_name, email)
+                manifest.send("#{name}s").concat([contact])
+            end
+
+            def toplevel_tag_end(name)
+                if DEPEND_TAGS.include?(name)
+                    depend_tag_end(name)
+                elsif AUTHOR_FIELDS.include?(name)
+                    author_tag_end(name)
+                elsif TEXT_FIELDS.include?(name)
+                    field = @tag_text.strip
+                    manifest.send("#{name}=", field) unless field.empty?
+                elsif name == "name"
+                    manifest.name = @tag_text.strip
+                elsif name == "export"
+                    @export_level = false
+                end
+                @tag_text = nil
+            end
+        end
+    end
+end

data/lib/autoproj/shell_completion.rb

@@ -1,5 +1,5 @@
-require 'autoproj/cli/main'
-require 'erb'
+require "autoproj/cli/main"
+require "erb"
 
 module Autoproj
     # Generates shell completion for code for a given Thor subclass
@@ -11,14 +11,15 @@ module Autoproj
         # A hash describing the CLI
         attr_reader :cli_metadata
 
-        TEMPLATES_DIR = File.join(File.dirname(__FILE__), 'templates')
+        TEMPLATES_DIR = File.join(File.dirname(__FILE__), "templates")
 
-        def initialize(name = 'autoproj', cli: Autoproj::CLI::Main, command: nil)
+        def initialize(name = "autoproj", cli: Autoproj::CLI::Main, command: nil)
             @cli = cli
             @name = name
 
             generate_metadata
             return unless command
+
             @cli_metadata = subcommand_by_name(*command)
             @cli_metadata[:name] = "__#{name}"
         end
@@ -48,8 +49,8 @@ module Autoproj
             # leaving disabled for now
             # TODO: log subcommand needs a custom completer,
             # leaving disabled for now
-            ['bootstrap', 'envsh', 'reconfigure', 'reset', 'log', 'query',
-             'switch-config', %w[global register], %w[global status],
+            ["bootstrap", "envsh", "reconfigure", "reset", "log", "query",
+             "switch-config", %w[global register], %w[global status],
              %w[plugin install], %w[plugin remove], %w[plugin list]].each do |command|
                 disable_completion(subcommand_by_name(*command))
             end
@@ -58,7 +59,7 @@ module Autoproj
         def generate
             template_file = File.join(TEMPLATES_DIR, self.class::MAIN_FUNCTION_TEMPLATE)
             erb = File.read(template_file)
-            ::ERB.new(erb, nil, '-').result(binding)
+            ::ERB.new(erb, nil, "-").result(binding)
         end
 
         def subcommand_by_name(*name, metadata: cli_metadata)
@@ -73,7 +74,7 @@ module Autoproj
         end
 
         def populate_help_subcommands(command_metadata = cli_metadata)
-            help_subcommand = subcommand_by_name('help',
+            help_subcommand = subcommand_by_name("help",
                                                  metadata: command_metadata)
 
             if help_subcommand
@@ -82,9 +83,11 @@ module Autoproj
             end
 
             command_metadata[:subcommands].each do |subcommand|
-                next if subcommand[:name] == 'help'
+                next if subcommand[:name] == "help"
+
                 populate_help_subcommands(subcommand)
                 next unless help_subcommand
+
                 help_subcommand[:subcommands] << { name: subcommand[:name],
                                                    aliases: [],
                                                    description: subcommand[:description],
@@ -98,17 +101,17 @@ module Autoproj
             source = []
 
             prefix = (prefix + [subcommand[:name]])
-            function_name = prefix.join('_')
+            function_name = prefix.join("_")
             depth = prefix.size + 1
 
             template_file = File.join(TEMPLATES_DIR, self.class::SUBCOMMAND_FUNCTION_TEMPLATE)
-            erb = ::ERB.new(File.read(template_file), nil, '-')
+            erb = ::ERB.new(File.read(template_file), nil, "-")
 
             source << erb.result(binding)
             subcommand[:subcommands].each do |subcommand|
                 source << render_subcommand_function(subcommand, prefix: prefix)
             end
-            source.join("\n").strip + "\n"
+            "#{source.join("\n").strip}\n"
         end
 
         def subcommand_metadata(cli)
@@ -158,7 +161,7 @@ module Autoproj
         end
 
         def hyphenate(s)
-            s.to_s.tr('_', '-')
+            s.to_s.tr("_", "-")
         end
     end
 end