ceedling 1.1.10 → 1.2.1

data/plugins/cppcheck/lib/cppcheck.rb

@@ -7,6 +7,7 @@
 
 require 'ceedling/constants'
 require 'ceedling/plugins/plugin'
+require 'ceedling/exceptions'
 
 require 'cppcheck_constants'
 require 'cppcheck_reports'
@@ -24,30 +25,37 @@ class Cppcheck < Plugin
     @tool_validator = @ceedling[:tool_validator]
     
     @config = @ceedling[:setupinator].config_hash[CPPCHECK_SYM]
-    
+
     evaluate_config()
-    
+
+    validate_fail_build_severities()
+
+    @configurator.replace_flattened_config(
+      collect_suppressions(@configurator.project_config_hash)
+    )
+
+    # Reports are built lazily by build_reports. Their constructors validate the
+    # tools they need, and TOOLS_CPPCHECK_HTMLREPORT is one of them. Building here
+    # would make that tool a hard dependency of every build this plugin is merely
+    # enabled for, rather than only a build that actually generates an HTML report.
+    @reports = nil
+  end
+
+  # Confirms Cppcheck is actually installed.
+  # Called externally by the plugin Rakefile's :cppcheck_deps task, which every
+  # cppcheck: task depends on.
+  #
+  # Validation is deliberately not done in setup(). setup() runs for every Ceedling
+  # command this plugin is merely enabled for, so validating there makes Cppcheck a
+  # hard dependency of plain `test:all`. It also made `ceedling files:cppcheck`,
+  # which only lists suppression files, require the executable.
+  def validate_environment!
     @tool_validator.validate(
       tool: TOOLS_CPPCHECK,
       boom: true
     )
-    
-    @configurator.replace_flattened_config(
-      collect_suppressions(@configurator.project_config_hash)
-    )
-    
-    @reports = {}
-    @config[:reports].uniq.map(&:to_sym).each do |type|
-      next if @reports.key?(type)
-      if type == :html
-        @reports[:xml] ||= new_report(:xml)
-        @reports[:html] = new_report(:html, @reports[:xml].artifact_filepath)
-      elsif (report = new_report(type))
-        @reports[type] = report
-      end
-    end
   end
-  
+
   def generate_reports()
     using_project_file = !(@config[:project].nil? || @config[:project].empty?)
     include_paths = using_project_file ? [] : COLLECTION_PATHS_INCLUDE
@@ -59,12 +67,28 @@ class Cppcheck < Plugin
       source_paths
     ]
     
-    reports_to_do = if @reports.key?(:html)
-        @reports.values_at(:xml, :html) + @reports.except(:xml, :html).values
+    reports = build_reports()
+
+    # Cppcheck only runs as part of generating a report. With no report configured
+    # this task analyzed nothing and said nothing, which reads like a successful run.
+    if reports.empty?
+      @loginator.log(
+        "No Cppcheck reports are configured, so no analysis ran.\n" \
+        "Add a report to :cppcheck ↳ :reports, or enable :cppcheck ↳ :fail_build.",
+        Verbosity::COMPLAIN,
+        LogLabels::WARNING
+      )
+      return
+    end
+
+    reports_to_do = if reports.key?(:html)
+        reports.values_at(:xml, :html) + reports.except(:xml, :html).values
       else
-        @reports.values
+        reports.values
       end
     reports_to_do.each {|report| report.generate(opts, *args)}
+
+    report_findings( reports[:xml] )
   end
   
   def analyze_file(filepath)
@@ -81,16 +105,131 @@ class Cppcheck < Plugin
   end
   
   private
-  
+
+  # Builds the configured reports, memoized.
+  #
+  # :fail_build implies an XML report. Findings are counted from cppcheck's own XML
+  # output, so that report has to exist. This mirrors how :html already implies :xml.
+  def build_reports()
+    return @reports unless @reports.nil?
+
+    @reports = {}
+
+    types = @config[:reports].uniq.map(&:to_sym)
+    types << :xml if fail_build_enabled? and !types.include?(:xml)
+
+    types.each do |type|
+      next if @reports.key?(type)
+      if type == :html
+        @reports[:xml] ||= new_report(:xml)
+        @reports[:html] = new_report(:html, @reports[:xml].artifact_filepath)
+      elsif (report = new_report(type))
+        @reports[type] = report
+      end
+    end
+
+    return @reports
+  end
+
+  def fail_build_enabled?
+    return @config[:fail_build] == true
+  end
+
+  def fail_build_severities
+    return Array( @config[:fail_build_severities] ).map(&:to_s)
+  end
+
+  # Rejects an unrecognized :fail_build_severities value at setup rather than letting
+  # it silently never match a finding.
+  def validate_fail_build_severities()
+    unrecognized = fail_build_severities - CPPCHECK_SEVERITIES
+
+    return if unrecognized.empty?
+
+    list = CPPCHECK_SEVERITIES.map { |severity| "'#{severity}'" }.join(', ')
+    msg = "Plugin configuration :cppcheck ↳ :fail_build_severities ➡️ " \
+          "#{unrecognized.map(&:inspect).join(', ')} not recognized. Valid severities are {#{list}}."
+    raise CeedlingException.new(msg)
+  end
+
+  # Tallies findings from the XML report and reports them.
+  #
+  # Cppcheck exits zero even when it finds defects, so its exit code carries no
+  # signal. The XML report is the only machine-readable record of what was found.
+  def report_findings(xml_report)
+    return if xml_report.nil?
+
+    counts = tally_findings( xml_report.artifact_filepath )
+    return if counts.nil?
+
+    if counts.empty?
+      @loginator.log( "Cppcheck found no issues.", Verbosity::NORMAL )
+    else
+      summary = counts.sort.map { |severity, count| "#{count} #{severity}" }.join(', ')
+      @loginator.log( "Cppcheck findings: #{summary}", Verbosity::NORMAL )
+    end
+
+    return unless fail_build_enabled?
+
+    failing = counts.select { |severity, _| fail_build_severities.include?( severity ) }
+    return if failing.empty?
+
+    total  = failing.values.sum
+    detail = failing.sort.map { |severity, count| "#{count} #{severity}" }.join(', ')
+
+    @ceedling[:plugin_manager].register_build_failure(
+      CPPCHECK_SYM,
+      "Cppcheck found #{total} #{total == 1 ? 'finding' : 'findings'} " \
+      "matching :cppcheck ↳ :fail_build_severities (#{detail}). " \
+      "See the report in #{CPPCHECK_ARTIFACTS_PATH}."
+    )
+
+    fail_build()
+  end
+
+  # Surfaces a registered failure and sets a non-zero exit code.
+  #
+  # Ceedling's end-of-run handler prints registered plugin failures and fails the
+  # build only for namespaces it treats as build tasks. It identifies those by
+  # scanning Rake files for test and release pipeline invocations. A cppcheck: task
+  # drives neither, so a failure registered above would otherwise never reach the
+  # user and never change the exit code.
+  def fail_build()
+    @ceedling[:plugin_manager].print_plugin_failures
+    @ceedling[:application].register_build_failure
+  end
+
+  # Returns a severity => count hash, or nil when the report could not be read.
+  def tally_findings(filepath)
+    unless @file_wrapper.exist?( filepath )
+      @loginator.log(
+        "Cppcheck wrote no XML report at #{filepath}. Findings could not be counted.",
+        Verbosity::COMPLAIN,
+        LogLabels::WARNING
+      )
+      return nil
+    end
+
+    counts = Hash.new(0)
+
+    # One <error> element per finding, each carrying a severity attribute.
+    @file_wrapper.read( filepath ).scan( /<error\b[^>]*\bseverity="([^"]+)"/ ) do |match|
+      counts[ match[0] ] += 1
+    end
+
+    return counts
+  end
+
   def traverse_config_eval_strings(config)
     case config
       when String
         config.replace(@ruby_expandinator.expand(config, source: "cppcheck plugin configuration"))
       when Array
-        if config.all? {|item| item.is_a?(String)}
-          config.each do |item|
-            item.replace(@ruby_expandinator.expand(item, source: "cppcheck plugin configuration"))
-          end
+        # Each String element is expanded on its own. Requiring every element to be a
+        # String meant one non-String entry silently disabled expansion for all of them.
+        config.each do |item|
+          next unless item.is_a?(String)
+          item.replace(@ruby_expandinator.expand(item, source: "cppcheck plugin configuration"))
         end
       when Hash
         config.each_value {|value| traverse_config_eval_strings(value)}
@@ -110,6 +249,16 @@ class Cppcheck < Plugin
       if @file_wrapper.exist?(path) && !@file_wrapper.directory?(path)
         all_suppressions.include(path)
       else
+        # A path that does not exist globs to nothing. Warn rather than leave a typo
+        # looking identical to a directory holding no suppression files.
+        unless @file_wrapper.exist?(path)
+          @loginator.log(
+            "Cppcheck suppressions path '#{path}' does not exist. No suppressions collected from it.",
+            Verbosity::COMPLAIN,
+            LogLabels::WARNING
+          )
+        end
+
         all_suppressions.include(File.join(path, '*.xml'))
         all_suppressions.include(File.join(
           path,

data/plugins/cppcheck/lib/cppcheck_constants.rb

@@ -14,6 +14,18 @@ CPPCHECK_BUILD_PATH          = File.join(PROJECT_BUILD_ROOT, CPPCHECK_ROOT_NAME)
 CPPCHECK_ARTIFACTS_PATH      = File.join(PROJECT_BUILD_ARTIFACTS_ROOT, CPPCHECK_ROOT_NAME)
 CPPCHECK_ARTIFACTS_HTML_PATH = File.join(CPPCHECK_ARTIFACTS_PATH, 'html')
 
+# Severity values Cppcheck tags each <error> element with. Used to validate
+# :fail_build_severities so an unrecognized value is rejected rather than silently
+# never matching a finding.
+CPPCHECK_SEVERITIES = [
+  'error',
+  'warning',
+  'style',
+  'performance',
+  'portability',
+  'information'
+].freeze
+
 CPPCHECK_ARTIFACTS_BASENAME   = 'CppcheckReport'.freeze
 CPPCHECK_ARTIFACTS_FILE_SARIF = CPPCHECK_ARTIFACTS_BASENAME.ext('.sarif').freeze
 CPPCHECK_ARTIFACTS_FILE_TEXT  = CPPCHECK_ARTIFACTS_BASENAME.ext('.txt').freeze

data/plugins/cppcheck/lib/cppcheck_reports.rb

@@ -61,8 +61,12 @@ class CppcheckHtmlReport < CppcheckReport
   def initialize(system_objects, config, xml_artifact_filepath)
     super(system_objects, config)
 
+    # respect_optional honors this tool's own `:optional => true` default. Validating
+    # without it contradicted that default and turned a missing cppcheck-htmlreport
+    # into a hard failure.
     @tool_validator.validate(
       tool: TOOLS_CPPCHECK_HTMLREPORT,
+      respect_optional: true,
       boom: true
     )
 
@@ -136,7 +140,7 @@ class CppcheckXmlReport < CppcheckReport
       '.xml'
     )
 
-    @xml_version = @config[:xml_report_version] || 3
+    @xml_version = @config[:xml_report_version] || 2
     validate_version(@xml_version)
   end
 

data/plugins/dependencies/Rakefile

@@ -8,6 +8,7 @@
 require 'rake'
 
 require 'rbconfig'
+require 'open3'
 
 def windows?()
   return (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
@@ -50,8 +51,18 @@ def assert_file_not_exist(path)
   end
 end
 
+# Runs Ceedling, failing on a nonzero exit status. Output includes stderr, where Ceedling
+# reports its own errors.
+def run_ceedling(cmd)
+  output, status = Open3.capture2e( "#{CEEDLING_CLI_EXEC} #{cmd}" )
+  return output if status.success?
+
+  puts output # Debug logging
+  raise "`ceedling #{cmd}` exited with status #{status.exitstatus}"
+end
+
 def assert_cmd_return(cmd, expected)
-  retval = `#{CEEDLING_CLI_EXEC} #{cmd}`
+  retval = run_ceedling( cmd )
   if (retval.include? expected)
     puts "Testing included `#{expected}`"
   else
@@ -61,10 +72,11 @@ def assert_cmd_return(cmd, expected)
 end
 
 def assert_cmd_not_return(cmd, expected)
-  retval = `#{CEEDLING_CLI_EXEC} #{cmd}`
+  retval = run_ceedling( cmd )
   if (!retval.include? expected)
     puts "Testing didn't included `#{expected}`"
   else
+    puts retval # Debug logging
     raise "Testing included `#{expected}`, which was unexpected."
   end
 end

data/plugins/dependencies/config/defaults.yml

@@ -13,16 +13,18 @@
   :deps_compiler:  
     :executable: gcc
     :name: 'Dependencies compiler'
+    :optional: true  # Checked when :build_lib compiles, not by every Ceedling command
     :arguments:  
       - -g  
-      - -I"$": COLLECTION_PATHS_DEPS  
-      - -D$: COLLECTION_DEFINES_DEPS  
+      - -I"${5}"  # Search paths: header directories under the source path
+      - -D${6}    # The dependency's :defines
       - -c "${1}"  
       - -o "${2}"  
 
   :deps_linker:
     :executable: ar  
     :name: 'Dependencies archiver'
+    :optional: true  # Checked when :build_lib archives, not by every Ceedling command
     :arguments:  
       - rcs  
       - ${2}  
@@ -40,11 +42,12 @@
     :executable: tar
     :name: 'Dependencies tar gzip unarchiver'
     :optional: true
+    # The archive arrives on standard input. GNU tar reads a path beginning `D:` as a
+    # remote host named D, so a Windows path given to -f fails.
     :arguments:
-      - -xvzf
-      - ${1}  # Filepath
-      - -C
-      - ./
+      - -xvzf -
+      - -C ./
+      - < "${1}"  # Filepath
 
   :deps_git_clone:
     :executable: git

data/plugins/dependencies/dependencies.rake

@@ -5,27 +5,18 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-DEPENDENCIES_DEPS.each do |deplib|
-
-  # Look up the name of this dependency library
-  deplib_name = @ceedling[DEPENDENCIES_SYM].get_name(deplib)
-
-  # Make sure the required working directories exists
-  # (don't worry about the subdirectories. That's the job of the dep's build tool)
-  paths = @ceedling[DEPENDENCIES_SYM].get_working_paths(deplib)
-  paths.each {|path| directory(path) }
-  task :directories => paths
-
-  all_deps = @ceedling[DEPENDENCIES_SYM].get_static_libraries_for_dependency(deplib) +
-             @ceedling[DEPENDENCIES_SYM].get_dynamic_libraries_for_dependency(deplib) +
-             @ceedling[DEPENDENCIES_SYM].get_include_directories_for_dependency(deplib) +
-             @ceedling[DEPENDENCIES_SYM].get_include_files_for_dependency(deplib) +
-             @ceedling[DEPENDENCIES_SYM].get_source_files_for_dependency(deplib)
-
-  # Add a rule for building the actual libraries from dependency list
-  (@ceedling[DEPENDENCIES_SYM].get_static_libraries_for_dependency(deplib) +
-   @ceedling[DEPENDENCIES_SYM].get_dynamic_libraries_for_dependency(deplib)
-  ).each do |libpath|
+@ceedling[DEPENDENCIES_SYM].specs.each do |dep|
+
+  # The plugin creates each working path as fetching and building need it. Created any
+  # earlier, a build path inside the fetch path would make an unfetched dependency look
+  # fetched and stop a git clone into it.
+
+  collector = @ceedling[DEPENDENCIES_SYM].path_collector
+  headers_and_sources = dep.include_directories( collector ) + dep.include_files + dep.source_paths
+  all_deps = dep.static_libraries + dep.dynamic_libraries + headers_and_sources
+
+  # Add a rule for building the actual libraries and executables from dependency list
+  (dep.static_libraries + dep.dynamic_libraries + dep.executables).each do |libpath|
     file libpath do |filetask|
       path = filetask.name
 
@@ -34,29 +25,21 @@ DEPENDENCIES_DEPS.each do |deplib|
       if (File.exist?(path))
         @ceedling[:loginator].lazy( Verbosity::OBNOXIOUS ) { "Nothing to do for dependency #{path}" }
       else
-        # Set Environment Variables, Fetch, and Build
-        @ceedling[DEPENDENCIES_SYM].set_env_if_required(path)
-        @ceedling[DEPENDENCIES_SYM].fetch_if_required(path)
-        @ceedling[DEPENDENCIES_SYM].build_if_required(path)
+        @ceedling[DEPENDENCIES_SYM].make_if_required(path)
       end
     end
   end
 
   # Add a rule for building the source and includes from dependency list
-  (@ceedling[DEPENDENCIES_SYM].get_include_directories_for_dependency(deplib) +
-   @ceedling[DEPENDENCIES_SYM].get_include_files_for_dependency(deplib) +
-   @ceedling[DEPENDENCIES_SYM].get_source_files_for_dependency(deplib)
-  ).each do |libpath|
+  # A task's name is the project path the dependency is found by
+  headers_and_sources.each do |libpath|
     task libpath do |filetask|
-      path = File.expand_path(filetask.name)
+      path = filetask.name
 
-      if (File.file?(path) || File.directory?(path))
+      if File.exist?( path )
         @ceedling[:loginator].lazy( Verbosity::OBNOXIOUS ) { "Nothing to do for dependency #{path}" }
       else
-        # Set Environment Variables, Fetch, and Build
-        @ceedling[DEPENDENCIES_SYM].set_env_if_required(path)
-        @ceedling[DEPENDENCIES_SYM].fetch_if_required(path)
-        @ceedling[DEPENDENCIES_SYM].build_if_required(path)
+        @ceedling[DEPENDENCIES_SYM].make_if_required(path)
       end
     end
   end
@@ -65,93 +48,80 @@ DEPENDENCIES_DEPS.each do |deplib|
   namespace DEPENDENCIES_SYM do
     namespace :deploy do
       # Add task to directly just build this dependency
-      task(deplib_name => @ceedling[DEPENDENCIES_SYM].get_dynamic_libraries_for_dependency(deplib)) do |t,args|
-        @ceedling[DEPENDENCIES_SYM].deploy_if_required(deplib_name)
+      task(dep.task_name => dep.dynamic_libraries + dep.executables) do |_t,_args|
+        @ceedling[DEPENDENCIES_SYM].deploy_if_required(dep.task_name)
       end
     end
 
     namespace :make do
       # Add task to directly just build this dependency
-      task(deplib_name => all_deps)
+      task(dep.task_name => all_deps + dep.executables)
     end
 
     namespace :clean do
       # Add task to directly clobber this dependency
-      task(deplib_name) do
-        @ceedling[DEPENDENCIES_SYM].clean_if_required(deplib_name)
+      task(dep.task_name) do
+        @ceedling[DEPENDENCIES_SYM].clean_if_required(dep.task_name)
       end
     end
 
     namespace :fetch do
       # Add task to directly clobber this dependency
-      task(deplib_name => @ceedling[DEPENDENCIES_SYM].get_source_path(deplib)) do
-        @ceedling[DEPENDENCIES_SYM].fetch_if_required(deplib_name)
+      task(dep.task_name) do
+        @ceedling[DEPENDENCIES_SYM].fetch_if_required(dep.task_name)
       end
     end
   end
 
 
-  # grab our own reference to the main configuration hash
-  project_config = @ceedling[:configurator].project_config_hash
-
   # Add source files to our list of things to build during release
-  source_files = @ceedling[DEPENDENCIES_SYM].get_source_files_for_dependency(deplib)
-  task PROJECT_RELEASE_BUILD_TARGET => source_files
+  task PROJECT_RELEASE_BUILD_TARGET => dep.source_paths
 
   # Finally, add the static libraries to our RELEASE build dependency list
-  static_libs = @ceedling[DEPENDENCIES_SYM].get_static_libraries_for_dependency(deplib)
-  task RELEASE_SYM => static_libs
+  task RELEASE_SYM => dep.static_libraries
 
   # Add the dynamic libraries to our RELEASE task dependency list so that they will be copied automatically
-  dynamic_libs = @ceedling[DEPENDENCIES_SYM].get_dynamic_libraries_for_dependency(deplib)
-  task RELEASE_SYM => dynamic_libs
-
-  # Paths to Libraries need to be Added to the Lib Path List
-  all_libs = static_libs + dynamic_libs
-  PATHS_LIBRARIES ||= []
-  all_libs.each {|lib| PATHS_LIBRARIES << File.dirname(lib) }
-  PATHS_LIBRARIES.uniq!
-  PATHS_LIBRARIES.reject!{|s| s.empty?}
-
-  # Libraries Need to be Added to the Library List
-  LIBRARIES_SYSTEM ||= []
-  all_libs.each {|lib| LIBRARIES_SYSTEM << File.basename(lib,'.*').sub(/^lib/,'') }
-  LIBRARIES_SYSTEM.uniq!
-  LIBRARIES_SYSTEM.reject!{|s| s.empty?}
+  task RELEASE_SYM => dep.dynamic_libraries
+
+  # A release may ship a dependency's executables, which no test build links
+  task RELEASE_SYM => dep.executables
 
   task :prepare => all_deps
 end
 
+# Dependency libraries join the library names and paths test and release builds link with
+link_libraries = @ceedling[DEPENDENCIES_SYM].link_libraries
+PATHS_LIBRARIES ||= []
+PATHS_LIBRARIES.concat( link_libraries[:paths] ).uniq!
+LIBRARIES_SYSTEM ||= []
+LIBRARIES_SYSTEM.concat( link_libraries[:names] ).uniq!
+
 # Add any artifact:include or :source folders to our release & test includes paths so linking and mocking work.
 @ceedling[DEPENDENCIES_SYM].add_headers_and_sources()
 
 # Add tasks for building or cleaning ALL depencies
 namespace DEPENDENCIES_SYM do
+  task_names = @ceedling[DEPENDENCIES_SYM].specs.map( &:task_name )
+
   desc "Deploy missing dependencies."
-  task :deploy => DEPENDENCIES_DEPS.map{|deplib| "#{DEPENDENCIES_SYM}:deploy:#{@ceedling[DEPENDENCIES_SYM].get_name(deplib)}"}
+  task :deploy => task_names.map { |name| "#{DEPENDENCIES_SYM}:deploy:#{name}" }
 
   desc "Build any missing dependencies."
-  task :make => DEPENDENCIES_DEPS.map{|deplib| "#{DEPENDENCIES_SYM}:make:#{@ceedling[DEPENDENCIES_SYM].get_name(deplib)}"}
+  task :make => task_names.map { |name| "#{DEPENDENCIES_SYM}:make:#{name}" }
 
   desc "Clean all dependencies."
-  task :clean => DEPENDENCIES_DEPS.map{|deplib| "#{DEPENDENCIES_SYM}:clean:#{@ceedling[DEPENDENCIES_SYM].get_name(deplib)}"}
+  task :clean => task_names.map { |name| "#{DEPENDENCIES_SYM}:clean:#{name}" }
 
   desc "Fetch all dependencies."
-  task :fetch => DEPENDENCIES_DEPS.map{|deplib| "#{DEPENDENCIES_SYM}:fetch:#{@ceedling[DEPENDENCIES_SYM].get_name(deplib)}"}
+  task :fetch => task_names.map { |name| "#{DEPENDENCIES_SYM}:fetch:#{name}" }
 end
 
 namespace :files do
-  desc "List all collected dependency libraries."
+  desc "List all collected dependency libraries and executables."
   task :dependencies do
     puts "dependency files:"
-    deps = []
-    DEPENDENCIES_DEPS.each do |deplib|
-      deps << @ceedling[DEPENDENCIES_SYM].get_static_libraries_for_dependency(deplib)
-      deps << @ceedling[DEPENDENCIES_SYM].get_dynamic_libraries_for_dependency(deplib)
-    end
-    deps.flatten!
+    deps = @ceedling[DEPENDENCIES_SYM].specs.flat_map { |dep| dep.static_libraries + dep.dynamic_libraries + dep.executables }
     deps.sort.each {|dep| puts " - #{dep}"}
     puts "file count: #{deps.size}"
   end
 end
-

data/plugins/dependencies/example/boss/project.yml

@@ -204,7 +204,7 @@
 :libraries:
   :placement: :end
   :flag: "-l${1}"
-  :path_flag: "-L ${1}"
+  :path_flag: "-L \"${1}\""
   :system: []    # for example, you might list 'm' to grab the math library
   :test: []
   :release: []

data/plugins/dependencies/example/supervisor/project.yml

@@ -145,7 +145,7 @@
 :libraries:
   :placement: :end
   :flag: "-l${1}"
-  :path_flag: "-L ${1}"
+  :path_flag: "-L \"${1}\""
   :system: []    # for example, you might list 'm' to grab the math library
   :test: []
   :release: []