ceedling 1.0.1 → 1.1.0

data/plugins/gcov/lib/reportgenerator_reportinator.rb

@@ -1,23 +1,28 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
 require 'benchmark'
-require 'reportinator_helper'
 require 'ceedling/constants'
 require 'ceedling/exceptions'
+require 'ceedling/file_path_utils'
+require 'gcov_reportinator'
 
-class ReportGeneratorReportinator
+class ReportGeneratorReportinator < GcovReportinator
+
+  NAME = 'ReportGenerator'
+
+  def name; NAME; end
 
   attr_reader :artifacts_path
 
   def initialize(system_objects)
     @artifacts_path = GCOV_REPORT_GENERATOR_ARTIFACTS_PATH
+    @summary        = ''
     @ceedling = system_objects
-    @reportinator_helper = ReportinatorHelper.new(system_objects)
 
     # Validate the `reportgenerator` tool since it's used to generate reports
     @ceedling[:tool_validator].validate( 
@@ -33,90 +38,35 @@ class ReportGeneratorReportinator
     )
 
     # Convenient instance variable references
-    @loginator = @ceedling[:loginator]
-    @reportinator = @ceedling[:reportinator]
+    @loginator     = @ceedling[:loginator]
+    @reportinator  = @ceedling[:reportinator]
     @tool_executor = @ceedling[:tool_executor]
+    @configurator  = @ceedling[:configurator]
+    @batchinator   = @ceedling[:batchinator]
+
+    # Mutex that serializes each gcov subprocess + rename pair (see run_gcov).
+    @gcov_cwd_mutex = Mutex.new
   end
 
 
   # Generate the ReportGenerator report(s) specified in the options.
+  # Iterate coverage results using a listing of all .gcno files beneath GCOV_BUILD_OUTPUT_PATH.
   def generate_reports(opts)
     shell_result = nil
     total_time = Benchmark.realtime do
-      rg_opts = get_opts(opts)
-
-      msg = @reportinator.generate_heading( "Running ReportGenerator Coverage Reports" )
-      @loginator.log( msg )
-
-      opts[:gcov_reports].each do |report|
-        msg = @reportinator.generate_progress("Generating #{report} coverage report in '#{GCOV_REPORT_GENERATOR_ARTIFACTS_PATH}'")
-        @loginator.log( msg )
-      end
-
-      # Cleanup any existing .gcov files to avoid reporting old coverage results.
-      for gcov_file in Dir.glob("*.gcov")
-        File.delete(gcov_file)
-      end
+      rg_opts = collect_reportgenerator_opts(opts)
 
-      gcno_exclude_str = ""
-
-      # Avoid running gcov on custom specified .gcno files.
-      for gcno_exclude_expression in rg_opts[:gcov_exclude]
-        if !(gcno_exclude_expression.nil?) && !(gcno_exclude_expression.empty?)
-          # We want to filter .gcno files, not .gcov files.
-          # We will generate .gcov files from .gcno files.
-          gcno_exclude_expression = gcno_exclude_expression.chomp("\\.gcov")
-          gcno_exclude_expression = gcno_exclude_expression.chomp(".gcov")
-          # The .gcno extension will be added later as we create the regex.
-          gcno_exclude_expression = gcno_exclude_expression.chomp("\\.gcno")
-          gcno_exclude_expression = gcno_exclude_expression.chomp(".gcno")
-          # Append the custom expression.
-          gcno_exclude_str += "|#{gcno_exclude_expression}"
-        end
-      end
-
-      gcno_exclude_regex = /(\/|\\)(#{gcno_exclude_str})\.gcno/
-
-      # Generate .gcov files by running gcov on gcov notes files (*.gcno).
-      for gcno_filepath in Dir.glob(File.join(GCOV_BUILD_PATH, "**", "*.gcno"))
-        if not (gcno_filepath =~ gcno_exclude_regex) # Skip path that matches exclude pattern
-          # Ensure there is a matching gcov data file.
-          if File.file?(gcno_filepath.gsub(".gcno", ".gcda"))
-            run_gcov("\"#{gcno_filepath}\"")
-          end
-        end
-      end
-
-      if Dir.glob("*.gcov").length > 0
-        # Build the command line arguments.
-        args = args_builder(opts)
-
-        # Generate the report(s).
-        begin
-          shell_result = run(args)
-        rescue ShellException => ex
-          shell_result = ex.shell_result
-          # Re-raise
-          raise ex
-        ensure
-          # Cleanup .gcov files.
-          for gcov_file in Dir.glob("*.gcov")
-            File.delete(gcov_file)
-          end          
-        end
-      else
-        @loginator.log( "No matching .gcno coverage files found", Verbosity::COMPLAIN )
-      end
+      log_report_intentions(opts)
 
+      gcno_exclude_regex = build_gcno_exclude_regex(rg_opts)
+      generate_gcov_files(gcno_exclude_regex)
+      shell_result = run_reportgenerator(opts, rg_opts)
     end
 
     if shell_result
       shell_result[:time] = total_time
-      @reportinator_helper.print_shell_result(shell_result)
+      print_shell_exec_time(shell_result)
     end
-
-    # White space log line
-    @loginator.log( '' )
   end
 
 
@@ -147,74 +97,250 @@ class ReportGeneratorReportinator
 
   REPORT_GENERATOR_SETTING_PREFIX = "gcov_report_generator"
 
-  # Build the ReportGenerator arguments.
-  def args_builder(opts)
-    rg_opts = get_opts(opts)
-    report_type_count = 0
-
-    args = ""
-    args += "\"-reports:*.gcov\" "
-    args += "\"-targetdir:\"#{GCOV_REPORT_GENERATOR_ARTIFACTS_PATH}\"\" "
-
-    # Build the report types argument.
-    args += "\"-reporttypes:"
-
-    for report_type in opts[:gcov_reports]
-      rg_report_type = REPORT_TYPE_TO_REPORT_GENERATOR_REPORT_NAME[report_type.upcase]
-      if !(rg_report_type.nil?)
-        args += rg_report_type + ";"
-        report_type_count = report_type_count + 1
-      end
-    end
-
-    # Removing trailing ';' after the last report type.
-    args = args.chomp(";")
-
-    # Append a space separator after the report type.
-    args += "\" "
+  # Map configured report types to ReportGenerator names, silently skipping unknowns.
+  # Returns an array used to build both the -reporttypes: value and the report count.
+  def build_report_types(opts)
+    opts[:gcov_reports].filter_map { |r| REPORT_TYPE_TO_REPORT_GENERATOR_REPORT_NAME[r.upcase] }
+  end
 
-    # Build the source directories argument.
-    args += "\"-sourcedirs:.;#{opts[:collection_paths_source].join(';')}\" "
 
+  # Build the optional ${6} argument string for ReportGenerator.
+  # report_type_count drives the createSubdirectoryForAllReportTypes setting.
+  def build_optional_args(rg_opts, report_type_count)
+    args = ""
     args += "\"-historydir:#{rg_opts[:history_directory]}\" " unless rg_opts[:history_directory].nil?
     args += "\"-plugins:#{rg_opts[:plugins]}\" " unless rg_opts[:plugins].nil?
     args += "\"-assemblyfilters:#{rg_opts[:assembly_filters]}\" " unless rg_opts[:assembly_filters].nil?
     args += "\"-classfilters:#{rg_opts[:class_filters]}\" " unless rg_opts[:class_filters].nil?
-    args += "\"-filefilters:#{rg_opts[:file_filters]}\" " unless rg_opts[:file_filters].nil?
     args += "\"-verbosity:#{rg_opts[:verbosity]}\" " unless rg_opts[:verbosity].nil?
     args += "\"-tag:#{rg_opts[:tag]}\" " unless rg_opts[:tag].nil?
-    args += "\"settings:createSubdirectoryForAllReportTypes=true\" " unless report_type_count <= 1
+    args += "\"settings:createSubdirectoryForAllReportTypes=true\" " if report_type_count > 1
     args += "\"settings:numberOfReportsParsedInParallel=#{rg_opts[:num_parallel_threads]}\" " unless rg_opts[:num_parallel_threads].nil?
     args += "\"settings:numberOfReportsMergedInParallel=#{rg_opts[:num_parallel_threads]}\" " unless rg_opts[:num_parallel_threads].nil?
-
-    # Append custom arguments.
-    for custom_arg in rg_opts[:custom_args]
+    rg_opts[:custom_args].each do |custom_arg|
       args += "\"#{custom_arg}\" " unless custom_arg.nil? || custom_arg.empty?
     end
-
-    return args
+    args.strip
   end
 
 
   # Get the ReportGenerator options from the project options.
-  def get_opts(opts)
-    return opts[REPORT_GENERATOR_SETTING_PREFIX.to_sym]
+  def collect_reportgenerator_opts(opts)
+    _opts = opts[REPORT_GENERATOR_SETTING_PREFIX.to_sym]
+
+    # Auto-generate -filefilters: exclusion patterns for test paths and the build root.
+    # These exclude test files and all generated/framework files from coverage reports.
+    # User-provided :file_filters are placed first and take precedence.
+    auto_excludes = build_filefilter_exclusions
+    _opts[:file_filters] = ([_opts[:file_filters]] + auto_excludes)
+      .compact.join(';').then { |s| s.empty? ? nil : s }
+
+    # Insert an exclusion for Ceedling Partials that will merge with any other exclusions
+    if @configurator.project_use_partials
+      partials_exclude = '-' + PARTIAL_FILENAME_PREFIX + '*'
+      _opts[:file_filters] = [_opts[:file_filters], partials_exclude].compact.join(';').then { |s| s.empty? ? nil : s }
+    end
+
+    return _opts
   end
 
 
-  # Run ReportGenerator with the given arguments.
-  def run(args)
-    command = @tool_executor.build_command_line(TOOLS_GCOV_REPORTGENERATOR_REPORT, [], args)
+  # Log the report generation heading and one NOTICE line per configured report type.
+  def log_report_intentions(opts)
+    @loginator.log( @reportinator.generate_heading("Running ReportGenerator Coverage Reports") )
 
-    return @tool_executor.exec( command )
+    opts[:gcov_reports].each do |report|
+      msg = @reportinator.generate_progress(
+        "Generating #{report} coverage report in '#{GCOV_REPORT_GENERATOR_ARTIFACTS_PATH}/'"
+      )
+      @loginator.log( msg, Verbosity::NORMAL, LogLabels::NOTICE )
+    end
   end
 
 
-  # Run gcov with the given arguments.
-  def run_gcov(args)
-    command = @tool_executor.build_command_line(TOOLS_GCOV_REPORT, [], args)
+  # Build a Regexp that matches .gcno filepaths to be excluded from gcov processing,
+  # combining user-specified patterns with internally-generated ones.
+  # Returns nil when empty.
+  def build_gcno_exclude_regex(rg_opts)
+    gcno_exclusions = []
+
+    # Collect user-specified coverage results exclusions.
+    for gcno_exclude_expression in rg_opts[:gcov_exclude]
+      next if gcno_exclude_expression.nil? || gcno_exclude_expression.empty?
+      # Users may specify exclusion patterns ending in .gcov (matching gcov output files)
+      # or .gcno (matching the coverage notes files we iterate). Strip either suffix —
+      # both escaped regex form (\\.gcov) and plain (.gcov) — so the bare pattern remains.
+      gcno_exclude_expression = gcno_exclude_expression.chomp("\\#{EXTENSION_GCOV}").chomp(EXTENSION_GCOV)
+      # Strip any .gcno suffix as well; the regex built below appends \.gcno already,
+      # so including it in the pattern would double it and prevent any match.
+      gcno_exclude_expression = gcno_exclude_expression.chomp("\\#{EXTENSION_GCNO}").chomp(EXTENSION_GCNO)
+      gcno_exclusions << gcno_exclude_expression
+    end
+
+    # Auto-generated exclusions: test files, mocks, and test runners.
+    # These are never production source, so there's no need to run gcov on them.
+    gcno_exclusions += build_gcno_exclusions()
+
+    # Build a single regex from all exclusion patterns. (\/|\\\\) matches the path
+    # separator preceding the filename on both Unix and Windows, which prevents a
+    # fragment from accidentally matching mid-path. \.gcno anchors to the file extension.
+    # nil when the list is empty so callers can skip the regex check entirely.
+    gcno_exclusions.empty? ? nil :
+      Regexp.new("(\/|\\\\)(#{gcno_exclusions.join('|')})\\#{EXTENSION_GCNO}")
+  end
+
+
+  # Run gcov on every .gcno file found beneath GCOV_BUILD_OUTPUT_PATH, skipping those
+  # that match gcno_exclude_regex. Within each directory, non-partial source files are
+  # processed before their partial counterparts.
+  def generate_gcov_files(gcno_exclude_regex)
+    source_prefix = Dir.pwd + File::SEPARATOR
+
+    # Collect unique directories under GCOV_BUILD_OUTPUT_PATH that contain .gcno files.
+    # This covers both test-specific subdirs (tested sources) and the root dir itself
+    # (untested sources placed there by process_untested_sources).
+    # gcov handles a missing .gcda gracefully; it produces a .gcov with 0% coverage —
+    # so no .gcda guard needed.
+    gcno_dirs = Dir.glob(File.join(GCOV_BUILD_OUTPUT_PATH, "**", "*#{EXTENSION_GCNO}"))
+      .map { |f| File.dirname(f) }
+      .uniq
+      .sort
+
+    # Pre-compute the sorted, filtered file list for each dir before dispatching.
+    # filter_map drops empty dirs so Batchinator never queues no-op work items.
+    work_items = gcno_dirs.filter_map do |gcno_dir|
+      files = Dir.glob(File.join(gcno_dir, "*#{EXTENSION_GCNO}"))
+        .reject { |f| gcno_exclude_regex && f =~ gcno_exclude_regex }
+        # Sort to process non-partial source files before their partial counterparts.
+        # Processing the coverage compiled version of the original source creates .gcov
+        # files for more than the partial does (primarily header files),
+        # but the .gcov file for the partial contains the correct coverage information.
+        # So, we must process the original source first and then overwrite some of it
+        # what it generates with partial .gcov generation.
+        .sort_by { |f| File.basename(f).start_with?(PARTIAL_FILENAME_PREFIX) ? 1 : 0 }
+      files.empty? ? nil : { gcno_dir: gcno_dir, gcno_files: files }
+    end
+
+    # Process each dir's gcov work in parallel across the thread pool. Within each dir
+    # the sorted file list is walked sequentially, preserving partial/non-partial ordering.
+    @batchinator.exec(workload: :compile, things: work_items) do |item|
+      item[:gcno_files].each { |gcno_filepath| run_gcov(gcno_filepath, source_prefix) }
+    end
+  end
+
+
+  # Run ReportGenerator if .gcov files are present. Returns the shell result, or nil
+  # with a complaint log if no .gcov files were produced by the gcov step.
+  def run_reportgenerator(opts, rg_opts)
+    unless Dir.glob(File.join(GCOV_BUILD_OUTPUT_PATH, "**", "*#{EXTENSION_GCOV}")).length > 0
+      @loginator.log( "No matching .gcno coverage files found", Verbosity::COMPLAIN )
+      return nil
+    end
+
+    report_type_names = build_report_types(opts)
+    collapsed = FilePathUtils.collapse_to_common_parents(opts[:collection_paths_source])
+
+    command = @tool_executor.build_command_line(
+      TOOLS_GCOV_REPORTGENERATOR_REPORT, [],
+      "#{GCOV_BUILD_OUTPUT_PATH}/**/*#{EXTENSION_GCOV}",      # ${1} -reports:
+      GCOV_REPORT_GENERATOR_ARTIFACTS_PATH,                   # ${2} -targetdir:
+      report_type_names.join(';'),                            # ${3} -reporttypes:
+      ".;#{collapsed.join(';')}",                             # ${4} -sourcedirs:
+      # Always non-nil: collect_reportgenerator_opts unconditionally populates 
+      # it with at least the build-root exclusion from build_filefilter_exclusions.
+      rg_opts[:file_filters],                                 # ${5} -filefilters: 
+      build_optional_args(rg_opts, report_type_names.length)  # ${6} optional args
+    )
 
     return @tool_executor.exec( command )
   end
 
+
+  # Build glob-wildcard exclusion strings for ReportGenerator's -filefilters: argument.
+  # Excludes test source paths and the build root (which contains all generated and
+  # framework files: mocks, test runners, Unity, CMock, etc.).
+  def build_filefilter_exclusions
+    data = build_exclusion_data
+    patterns = []
+    data[:test_paths].each do |path|
+      patterns << "-./#{path}/**/*"
+    end
+    patterns << "-./#{data[:build_root]}/**/*"
+    patterns
+  end
+
+
+  # Build filename-fragment patterns for the .gcno scan exclusion regex.
+  # Excludes test files, generated mocks, and test runners from gcov processing.
+  # The '.*' suffix handles source extensions embedded in .gcno filenames (e.g. test_foo.c.gcno).
+  def build_gcno_exclusions
+    data = build_exclusion_data
+    # Use [^\/\\]* (no path separators) rather than .* to match filenames only.
+    # Ceedling names build output dirs after test files (e.g. build/gcov/out/test_foo/),
+    # so .* would greedily match test_foo/bar.c and exclude ALL production sources.
+    [
+      "#{data[:test_prefix]}[^\\/\\\\]*",  # test_foo.gcno
+      "#{data[:mock_prefix]}[^\\/\\\\]*",  # MockBar.gcno
+      "[^\\/\\\\]*_runner[^\\/\\\\]*",     # test_foo_runner.gcno
+      File.basename(UNITY_C_FILE, '.*'),   # unity.gcno
+      File.basename(CMOCK_C_FILE, '.*')    # cmock.gcno
+    ]
+  end
+
+
+  # Run gcov on gcno_filepath (full path) from the unaltered working directory.
+  # source_prefix is the absolute project root — passed as -s to strip absolute #line
+  # directive paths to relative so gcov's -r filter accepts project sources while
+  # system headers (which don't match the prefix) remain excluded.
+  # gcov writes .gcov files into the CWD; this method moves each one to the same
+  # directory as the .gcno file so coverage data stays co-located with its build output.
+  # Non-fatal: gcov exits non-zero for a missing .gcda (untested source); continue execution.
+  def run_gcov(gcno_filepath, source_prefix)
+    # gcov must run in the same working directory used during compilation so it can
+    # locate the .gcda data files produced at test-fixture execution time. However,
+    # parallel test builds share source files (e.g. src/utils.c may be compiled into
+    # every test executable that includes it), so each test's build directory holds its
+    # own utils.c.gcno. When two threads call gcov concurrently on those files, both
+    # write the same hash-named .gcov to the shared CWD (gcov uses --hash-filenames / -x
+    # to derive output names from the source path, so identical source paths always
+    # produce the same output filename). The second write clobbers the first before the
+    # rename to each test's build sub-directory can complete, silently losing coverage
+    # data. Serializing the exec+rename pair with a mutex eliminates the race at the cost
+    # of sequentializing only this step; the per-dir glob/filter/sort work in
+    # generate_gcov_files still runs in parallel across the Batchinator thread pool.
+    @gcov_cwd_mutex.synchronize do
+      command = @tool_executor.build_command_line(TOOLS_GCOV_REPORT, [], "\"#{gcno_filepath}\"", source_prefix)
+      command[:options][:boom] = false
+
+      shell_result = @tool_executor.exec( command )
+
+      if shell_result[:exit_code] != 0
+        @loginator.log(
+          "gcov could not process #{gcno_filepath} (exit #{shell_result[:exit_code]})",
+          Verbosity::COMPLAIN
+        )
+      end
+
+      # gcov logs each file it creates, e.g.: Creating 'a1b2c3d4.gcov'
+      # Scan for a space followed by any non-whitespace characters ending in EXTENSION_GCOV,
+      # then capture any non-whitespace character immediately after the extension.
+      # A space anchors the match to the start of the filename token in gcov's output.
+      # If a closing character follows the extension, it is assumed to be paired with an
+      # opening character directly before the filename; both are stripped, leaving only
+      # the bare filename (e.g. 'file.gcov' → file.gcov).
+      gcno_dir = File.dirname(gcno_filepath)
+
+      # Find filename in `gcov` output
+      shell_result[:output].scan(/ ([^\s]*#{Regexp.escape(EXTENSION_GCOV)})(\S?)/) do |gcov_token, closing_delim|
+        gcov_file = closing_delim.empty? ? gcov_token : gcov_token[1..]
+        dest = File.join(gcno_dir, File.basename(gcov_file))
+
+        # Move the generated file after extracting its filename from `gcov` output
+        File.rename(gcov_file, dest) if File.exist?(gcov_file) && gcov_file != dest
+      end
+
+      return shell_result
+    end
+  end
+
 end

data/plugins/module_generator/Rakefile

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-24 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/plugins/module_generator/assets/stubby1.h

@@ -1,7 +1,7 @@
 /* =========================================================================
     Ceedling - Test-Centered Build System for C
     ThrowTheSwitch.org
-    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 

data/plugins/module_generator/assets/stubby2.h

@@ -1,7 +1,7 @@
 /* =========================================================================
     Ceedling - Test-Centered Build System for C
     ThrowTheSwitch.org
-    Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 

data/plugins/module_generator/config/module_generator.yml

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/plugins/module_generator/example/project.yml

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -54,7 +54,6 @@
     #- command_hooks                  # write custom actions to be called at different points during the build process
     #- compile_commands_json_db          # generate a compile_commands.json file
     #- dependencies                   # automatically fetch 3rd party libraries, etc.
-    #- subprojects                    # managing builds and test for static libraries
     #- fake_function_framework        # use FFF instead of CMock
 
     # Report options (You'll want to choose one stdout option, but may choose multiple stored options if desired)
@@ -76,7 +75,6 @@
   :executable: .out
   #:testpass: .pass
   #:testfail: .fail
-  #:subprojects: .a
 
 # This is where Ceedling should look for your source and test files.
 # see documentation for the many options for specifying this.

data/plugins/module_generator/lib/module_generator.rb

@@ -1,11 +1,11 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-require 'ceedling/plugin'
+require 'ceedling/plugins/plugin'
 require 'ceedling/constants'
 require 'erb'
 require 'fileutils'

data/plugins/module_generator/module_generator.rake

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 

data/plugins/report_build_warnings_log/lib/report_build_warnings_log.rb

@@ -6,7 +6,7 @@
 # =========================================================================
 
 
-require 'ceedling/plugin'
+require 'ceedling/plugins/plugin'
 require 'ceedling/constants'
 
 class ReportBuildWarningsLog < Plugin
@@ -38,7 +38,7 @@ class ReportBuildWarningsLog < Plugin
     # After preprocessing, parse output, store warning if found
     process_output(
       arg_hash[:context],
-      arg_hash[:shell_result][:output],
+      arg_hash[:shell_result].nil? ? '' : arg_hash[:shell_result][:output],
       @warnings
     )
   end
@@ -48,7 +48,7 @@ class ReportBuildWarningsLog < Plugin
     # After preprocessing, parse output, store warning if found
     process_output(
       arg_hash[:context],
-      arg_hash[:shell_result][:output],
+      arg_hash[:shell_result].nil? ? '' : arg_hash[:shell_result][:output],
       @warnings
     )
   end
@@ -58,7 +58,7 @@ class ReportBuildWarningsLog < Plugin
     # After compiling, parse output, store warning if found
     process_output(
       arg_hash[:context],
-      arg_hash[:shell_result][:output],
+      arg_hash[:shell_result].nil? ? '' : arg_hash[:shell_result][:output],
       @warnings
     )
   end
@@ -68,19 +68,19 @@ class ReportBuildWarningsLog < Plugin
     # After linking, parse output, store warning if found
     process_output(
       arg_hash[:context],
-      arg_hash[:shell_result][:output],
+      arg_hash[:shell_result].nil? ? '' : arg_hash[:shell_result][:output],
       @warnings
     )
   end
 
   # `Plugin` build step hook
-  def post_build()
+  def post_build(_timestamp_s)
     # Write collected warnings to log(s)
     write_logs( @warnings, @log_filename )
   end
 
   # `Plugin` build step hook
-  def post_error()
+  def post_error(_timestamp_s)
     # Write collected warnings to log(s)
     write_logs( @warnings, @log_filename )
   end
@@ -105,25 +105,19 @@ class ReportBuildWarningsLog < Plugin
     msg = @reportinator.generate_heading( "Running Warnings Report" )
     @loginator.log( msg )
 
-    empty = false
-
-    @mutex.synchronize { empty = warnings.empty? }
-
-    if empty
+    if warnings.empty?
       @loginator.log( "Build produced no warnings.\n" )
       return
     end
 
-    @mutex.synchronize do
-      warnings.each do |context, hash|
-        log_filepath = form_log_filepath( context, filename )
+    warnings.each do |context, hash|
+      log_filepath = form_log_filepath( context, filename )
 
-        msg = @reportinator.generate_progress( "Generating artifact #{log_filepath}" )
-        @loginator.log( msg )
+      msg = @reportinator.generate_progress( "Generating artifact #{log_filepath}" )
+      @loginator.log( msg )
 
-        File.open( log_filepath, 'w' ) do |f|
-          hash[:collection].each { |warning| f << warning }
-        end
+      File.open( log_filepath, 'w' ) do |f|
+        hash[:collection].each { |warning| f << warning }
       end
     end
 

data/plugins/report_tests_gtestlike_stdout/assets/template.erb

@@ -1,7 +1,6 @@
 % ignored        = hash[:results][:counts][:ignored]
 % failed         = hash[:results][:counts][:failed]
 % stdout_count   = hash[:results][:counts][:stdout]
-% name_banner    = (" #{hash[:header]}" + (' ' * (9 - hash[:header].length)))[0..9]
 % results = {}
 % hash[:results][:successes].each do |testresult|
 %   results[ testresult[:source][:file] ] = testresult[:collection]
@@ -27,8 +26,9 @@
 %   end
 % end
 
-[==========]
-[<%=name_banner%>]
+% if hash[:context] != TEST_SYM
+Running testing tasks: <%=hash[:context].to_s.upcase%>
+% end
 [==========] Running <%=hash[:results][:counts][:total].to_s%> tests from <%=results.length.to_s%> test cases.
 [----------] Global test environment set-up.
 % results.each_pair do |modulename, moduledetails|

data/plugins/report_tests_gtestlike_stdout/config/report_tests_gtestlike_stdout.yml

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================