ceedling 1.1.10 → 1.2.1

data/lib/ceedling/config/configurator_validator.rb

@@ -5,157 +5,72 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-require 'rubygems'
-require 'rake' # for ext()
 require 'ceedling/constants'
 require 'ceedling/file_path_utils'  # for glob handling class methods
+require 'ceedling/config/config_matchinator'
 
 
 class ConfiguratorValidator
-  
-  constructor :config_walkinator, :file_wrapper, :loginator, :system_wrapper, :reportinator, :tool_validator
+
+  constructor :config_walkinator, :file_wrapper, :loginator, :reportinator, :tool_validator
 
   # Walk into config hash verify existence of data at key depth
   def exists?(config, *keys)
-    hash, _  = @config_walkinator.fetch_value( *keys, hash:config )
-    exist = !hash.nil?
+    hash, _ = @config_walkinator.fetch_value( *keys, hash:config )
+    return true unless hash.nil?
 
-    if (not exist)
-      walk = @reportinator.generate_config_walk( keys )
-      @loginator.log( "Required config file entry #{walk} does not exist.", Verbosity::ERRORS )    
-    end
-    
-    return exist
+    log_error( "Required config file entry #{@reportinator.generate_config_walk( keys )} does not exist." )
+    return false
   end
 
   # Walk into config hash. verify existence of path(s) at given key depth.
   # Paths are either full simple paths or a simple portion of a path up to a glob.
   def validate_path_list(config, *keys)
-    exist = true
     list, depth = @config_walkinator.fetch_value( *keys, hash:config )
+    return false if list.nil?
 
-    # Return early if we couldn't walk into hash and find a value
-    return false if (list.nil?)
-    
-    list.each do |path|
-      # Trim add/subtract notation & glob specifiers
-      _path = FilePathUtils::no_decorators( path )
-
-      next if _path.empty? # Path begins with or is entirely a glob, skip it
-
-      # If (partial) path does not exist, complain
-      if (not @file_wrapper.exist?( _path ))
-        walk = @reportinator.generate_config_walk( keys, depth )
-        @loginator.log( "Config path #{walk} => '#{_path}' does not exist in the filesystem.", Verbosity::ERRORS ) 
-        exist = false
-      end 
-    end
-    
-    return exist
+    # Trimming add/subtract notation and glob specifiers leaves nothing of a path that
+    # begins with a glob, so there is nothing to check. An entry YAML read as something
+    # other than a string is left to the entries validation, which reports it.
+    paths   = list.grep( String ).map { |path| FilePathUtils::no_decorators( path ) }
+    missing = paths.reject { |path| path.empty? or @file_wrapper.exist?( path ) }
+
+    walk = @reportinator.generate_config_walk( keys, depth )
+    missing.each { |path| log_error( "Config path #{walk} => '#{path}' does not exist in the filesystem." ) }
+
+    return missing.empty?
   end
 
 
   # Validate :paths entries, exercising each entry as Ceedling directory glob (variation of Ruby glob)
   def validate_paths_entries(config, key)
-    valid = true
-    keys = [:paths, key]
-    walk = @reportinator.generate_config_walk( keys )
-
-    list, _ = @config_walkinator.fetch_value( *keys, hash:config )
+    list, _ = @config_walkinator.fetch_value( :paths, key, hash:config )
+    return false if list.nil?
 
-    # Return early if we couldn't walk into hash and find a value
-    return false if (list.nil?)
-    
-    list.each do |path|
-      dirs = [] # Working list
-
-      # Trim add/subtract notation
-      _path = FilePathUtils::no_aggregation_decorators( path )
-
-      if @file_wrapper.exist?( _path ) and !@file_wrapper.directory?( _path )
-        # Path is a simple filepath (not a directory)
-        warning = "#{walk} => '#{_path}' is a filepath and will be ignored (FYI :paths is directory-oriented while :files is file-oriented)"
-        @loginator.log( warning, Verbosity::COMPLAIN )
-
-        next # Skip to next path
-      end
-
-      # Expand paths using Ruby's Dir.glob()
-      #  - A simple path will yield that path
-      #  - A path glob will expand to one or more paths
-      _reformed = FilePathUtils::reform_subdirectory_glob( _path )
-      @file_wrapper.directory_listing( _reformed ).each do |entry|
-        # For each result, add it to the working list *if* it's a directory
-        dirs << entry if @file_wrapper.directory?(entry)
-      end
-      
-      # Handle edge case of subdirectories glob but not subdirectories
-      # (Containing parent directory will still exist)
-      next if dirs.empty? and _path =~ /\/\*{1,2}$/
-
-      # Path did not work -- must be malformed glob or glob referencing path that does not exist.
-      # (An earlier step validates all simple directory paths).
-      if dirs.empty?
-        error = "#{walk} => '#{_path}' yielded no directories -- matching glob is malformed or directories do not exist"
-        @loginator.log( error, Verbosity::ERRORS )
-        valid = false
-      end
-    end
-    
-    return valid
+    walk = @reportinator.generate_config_walk( [:paths, key] )
+    return list.map { |path| usable_entry?( path, walk ) && valid_paths_entry?( FilePathUtils::no_aggregation_decorators( path ), walk ) }.all?
   end
 
 
   # Validate :files entries, exercising each entry as FileList glob
   def validate_files_entries(config, key)
-    valid = true
-    keys = [:files, key]
-    walk = @reportinator.generate_config_walk( keys )
-
-    list, _ = @config_walkinator.fetch_value( *keys, hash:config )
-
-    # Return early if we couldn't walk into hash and find a value
-    return false if (list.nil?)
-    
-    list.each do |path|
-      # Trim add/subtract notation
-      _path = FilePathUtils::no_aggregation_decorators( path )
-
-      if @file_wrapper.exist?( _path ) and @file_wrapper.directory?( _path )
-        # Path is a simple directory path (and is naturally ignored by FileList without a glob pattern)
-        warning = "#{walk} => '#{_path}' is a directory path and will be ignored (FYI :files is file-oriented while :paths is directory-oriented)"
-        @loginator.log( warning, Verbosity::COMPLAIN )
-
-        next # Skip to next path
-      end      
-
-      filelist = @file_wrapper.instantiate_file_list(_path)
-
-      # If file list is empty, complain
-      if (filelist.size == 0)
-        error = "#{walk} => '#{_path}' yielded no files -- matching glob is malformed or files do not exist"
-        @loginator.log( error, Verbosity::ERRORS ) 
-        valid = false
-      end 
-    end
-    
-    return valid
+    list, _ = @config_walkinator.fetch_value( :files, key, hash:config )
+    return false if list.nil?
+
+    walk = @reportinator.generate_config_walk( [:files, key] )
+    return list.map { |path| usable_entry?( path, walk ) && valid_files_entry?( FilePathUtils::no_aggregation_decorators( path ), walk ) }.all?
   end
 
 
   # Simple path verification
   def validate_filepath_simple(path, *keys)
-    validate_path = path
-    
-    if (not @file_wrapper.exist?(validate_path))
-      walk = @reportinator.generate_config_walk( keys, keys.size )
-      @loginator.log("Config path '#{validate_path}' associated with #{walk} does not exist in the filesystem.", Verbosity::ERRORS ) 
-      return false
-    end 
-    
-    return true
+    return true if @file_wrapper.exist?( path )
+
+    walk = @reportinator.generate_config_walk( keys, keys.size )
+    log_error( "Config path '#{path}' associated with #{walk} does not exist in the filesystem." )
+    return false
   end
-   
+
   def validate_tool(config:, key:, respect_optional:true)
     # Get tool
     walk = [:tools, key]
@@ -167,37 +82,94 @@ class ConfiguratorValidator
       extension: config[:extension][:executable],
       respect_optional: respect_optional
     }
-  
+
     return @tool_validator.validate( **arg_hash )
   end
 
 
+  # Raises with the reason a matcher is malformed
   def validate_matcher(matcher)
-    case matcher
-    
-    # Handle regex-based matcher
-    when /\/.+\//
-      # Ensure regex is well-formed by trying to compile it
-      begin
-        Regexp.compile( matcher[1..-2] )
-      rescue Exception => ex
-        # Re-raise with our own message formatting
-        raise "invalid regular expression:: #{ex.message}"
-      end
-    
-    # Handle wildcard / substring matchers
-    else
-      # Strip out allowed characters
-      invalid = matcher.gsub( /[a-z0-9 \/\.\-_\*]/i, '' )
-
-      # If there's any characters left, then we found invalid characters
-      if invalid.length() > 0
-        # Format invalid characters into a printable list with no duplicates
-        _invalid = invalid.chars.uniq.map{|c| "'#{c}'"}.join( ', ')
-
-        raise "invalid substring or wilcard characters #{_invalid}"
+    return validate_regex_matcher( matcher ) if ConfigMatchinator.regex_form?( matcher )
+
+    # A substring or wildcard matcher allows only these characters
+    invalid = matcher.gsub( /[a-z0-9 \/\.\-_\*]/i, '' ).chars.uniq
+    return if invalid.empty?
+
+    raise "invalid substring or wildcard characters #{invalid.map { |char| "'#{char}'" }.join( ', ' )}"
+  end
+
+  ### Private ###
+
+  private
+
+  # A :paths or :files entry that names no path, or wraps its path in quotes, usually
+  # quotes only the path after its decoration. YAML keeps those quote marks as part of
+  # the value, so the hint points at quoting the whole entry. YAML also reads an unquoted
+  # decoration with nothing after it (`- -:`) as a one-key mapping rather than a string.
+  ENTRY_QUOTING_HINT = 'Quote the whole entry, decoration included (e.g. "-:path/to/file.c"), ' +
+                       'not only the path after its +: or -: decoration.'
+
+  def usable_entry?(entry, walk)
+    path = entry.is_a?( String ) ? FilePathUtils::no_aggregation_decorators( entry ) : ''
+
+    problem =
+      if !entry.nil? and !entry.is_a?( String ) then "is not a path (YAML read it as a #{entry.class})"
+      elsif path.empty? then 'names no path'
+      elsif path.start_with?( '"', "'" ) then 'wraps its path in quotes'
       end
+    return true if problem.nil?
+
+    log_error( "#{walk} => '#{entry}' #{problem}" )
+    log_error( ENTRY_QUOTING_HINT )
+    return false
+  end
+
+  # A path naming a file is ignored with a warning. Any other entry must yield directories,
+  # except a subdirectories glob of a directory that has none.
+  def valid_paths_entry?(path, walk)
+    if @file_wrapper.exist?( path ) and !@file_wrapper.directory?( path )
+      log_complaint( "#{walk} => '#{path}' is a filepath and will be ignored (FYI :paths is directory-oriented while :files is file-oriented)" )
+      return true
     end
+
+    return true if globbed_directories?( path ) or path =~ /\/\*{1,2}$/
+
+    log_error( "#{walk} => '#{path}' yielded no directories -- matching glob is malformed or directories do not exist" )
+    return false
+  end
+
+  # #104 -- FilePathUtils.subdirectory_glob escapes literal brackets in the path, so they
+  # are matched rather than read as a glob character class
+  def globbed_directories?(path)
+    return @file_wrapper.directory_listing( FilePathUtils.subdirectory_glob( path ) ).any? { |entry| @file_wrapper.directory?( entry ) }
+  end
+
+  # A path naming a directory is ignored with a warning. Any other entry must yield files.
+  def valid_files_entry?(path, walk)
+    if @file_wrapper.exist?( path ) and @file_wrapper.directory?( path )
+      log_complaint( "#{walk} => '#{path}' is a directory path and will be ignored (FYI :files is file-oriented while :paths is directory-oriented)" )
+      return true
+    end
+
+    # #104 -- literal brackets are escaped so they are matched rather than read as a glob
+    return true unless @file_wrapper.instantiate_file_list( FilePathUtils.escape_glob_brackets( path ) ).size.zero?
+
+    log_error( "#{walk} => '#{path}' yielded no files -- matching glob is malformed or files do not exist" )
+    return false
+  end
+
+  def validate_regex_matcher(matcher)
+    Regexp.compile( matcher[1..-2] )
+  rescue RegexpError => ex
+    raise "invalid regular expression: #{ex.message}"
+  end
+
+  def log_error(message)
+    @loginator.log( message, Verbosity::ERRORS )
+  end
+
+  def log_complaint(message)
+    @loginator.log( message, Verbosity::COMPLAIN )
   end
 
 end

data/lib/ceedling/config/line_marker_suppressors.rb

@@ -0,0 +1,67 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Finds the preprocessor options that suppress line markers wherever configuration hands
+# them to test preprocessing. Test preprocessing reads line markers to find a file's
+# #includes, its mockable functions, and its test cases. A preprocessor given either
+# option still succeeds, so nothing later would report the problem. Each finding is a
+# pair: the configuration keys leading to the entry, and the entry itself.
+class LineMarkerSuppressors
+
+  OPTIONS = ['-P', '--no-line-commands'].freeze
+
+  # Flag operations that reach the preprocessor. Test preprocessing uses :compile flags
+  # wherever no :preprocess flags apply.
+  OPERATIONS = [:preprocess, :compile].freeze
+
+  # Preprocessor tools whose output is read through its line markers. A bare-includes
+  # make rule has none to lose.
+  TOOLS = [:test_file_full_preprocessor, :test_file_directives_only_preprocessor].freeze
+
+  # Only lists and matcher lists are read, never matcher keys. A malformed section is
+  # validate_flags' to report.
+  def self.in_flags(flags, contexts)
+    return contexts.product( OPERATIONS ).flat_map do |context, operation|
+      in_entries( [:flags, context, operation], value_at( flags, [context, operation] ) )
+    end
+  end
+
+  # A :tools_<name> shortcut's arguments are merged into its tool, but the shortcut is
+  # where they were written
+  def self.in_tools(config)
+    return TOOLS.flat_map do |name|
+      shortcut = Array( value_at( config, [:"tools_#{name}", :arguments] ) )
+      suppressing( Array( value_at( config, [:tools, name, :arguments] ) ) ).map do |entry|
+        [shortcut.include?( entry ) ? [:"tools_#{name}", :arguments] : [:tools, name, :arguments], entry]
+      end
+    end
+  end
+
+  def self.in_entries(walk_keys, entries)
+    return suppressing( entries ).map { |entry| [walk_keys, entry] } if entries.is_a?( Array )
+    return [] unless entries.is_a?( Hash )
+
+    return entries.flat_map { |matcher, list| list.is_a?( Array ) ? in_entries( walk_keys + [matcher], list ) : [] }
+  end
+
+  def self.suppressing(entries)
+    return entries.flatten.grep( String ).select { |entry| suppresses?( entry ) }
+  end
+
+  # An entry may hold several options, and -Wp, hands the preprocessor a comma-separated list
+  def self.suppresses?(entry)
+    tokens = entry.split.flat_map { |token| token.start_with?( '-Wp,' ) ? token.split( ',' ).drop( 1 ) : [token] }
+    return !(tokens & OPTIONS).empty?
+  end
+
+  def self.value_at(hash, keys)
+    return keys.reduce( hash ) { |value, key| value.is_a?( Hash ) ? value[key] : nil }
+  end
+
+  private_class_method :in_entries, :suppressing, :suppresses?, :value_at
+
+end

data/lib/ceedling/constants.rb

@@ -41,6 +41,7 @@ class LogLabels
   DOCUMENTATION = 12  # decorator only
   COMMERCIAL    = 13  # decorator only
   REQUEST       = 14  # decorator only
+  BUILT         = 15  # decorator only
 
   # Verbosity levels ERRORS – DEBUG default to certain labels or lack thereof
   # The above label constants are available to override Loginator's default AUTO level as needed
@@ -75,12 +76,34 @@ EXTENSION_NONWIN_EXE  = '.out'
 EXTENSION_CORE_HEADER = '.h'
 EXTENSION_CORE_SOURCE = '.c'
 
+# Ceedling's own internal cache files are always .yml, independent of a project's
+# configurable :extension ↳ :yaml setting (which governs files a project author
+# might actually want to name differently, not Ceedling's own bookkeeping).
+EXTENSION_CORE_YAML = '.yml'
+
 CEEDLING_HEADER_FILENAME = 'ceedling.h'
 CEEDLING_HEADER_FILEPATH = CEEDLING_HEADER_FILENAME # lib/ceedling/
 PARTIAL_FILENAME_PREFIX  = 'ceedling_partial_'
+# One suffix per kind of file generated for a Partialized module. The builders that append
+# these and the reverse that strips one share this single definition, so neither can drift
+# from the other. No suffix is a suffix of another, so a generated name ends in exactly one.
+PARTIAL_SUFFIX_INTERFACE = '_interface'
+PARTIAL_SUFFIX_TYPES     = '_types'
+PARTIAL_SUFFIX_IMPL      = '_impl'
+PARTIAL_FILENAME_SUFFIXES = [
+  PARTIAL_SUFFIX_INTERFACE,
+  PARTIAL_SUFFIX_TYPES,
+  PARTIAL_SUFFIX_IMPL
+].freeze
 
 class PATTERNS
-  GLOB = /[\*\?\{\}\[\]]/
+  # #104 -- `[`/`]` deliberately excluded: they're legal filename characters
+  # (common on Windows especially) but never a documented Ceedling glob feature
+  # (unlike `*`/`?`/`{`/`}`, Ceedling's own real wildcard syntax) -- including them
+  # here meant a literal bracket in a real directory name was silently treated as
+  # "where the glob starts," truncating path validation to the wrong ancestor
+  # directory. See FilePathUtils.no_decorators, this regex's one consumer.
+  GLOB = /[\*\?\{\}]/
 
   RUBY_STRING_REPLACEMENT = /#\{.+\}/
   TOOL_EXECUTOR_ARGUMENT_REPLACEMENT = /(\$\{(\d+)\})/
@@ -115,14 +138,24 @@ MIXIN_SIGIL_INLINE_YAML = '='
 MIXIN_SIGIL_FILEPATH    = '@'
 
 DEFAULT_PROJECT_FILENAME = 'project.yml'
+# #1250 -- self-documenting alternative to the generic DEFAULT_PROJECT_FILENAME, tried
+# during default discovery only (Projectinator#load) when no --project/-p or
+# CEEDLING_PROJECT_FILE was given. Neither name is "preferred" over the other -- either
+# alone is used as found; both present is an error (see Projectinator#load).
+ALTERNATE_PROJECT_FILENAME = 'ceedling.yml'
 DEFAULT_BUILD_LOGS_PATH = 'logs'
 
 DOCS_SITE_LOCAL_PATH = 'site-local'
 
 GENERATED_DIR_PATH = [['vendor', 'ceedling'], 'src', "test", ['test', 'support'], 'build'].each{|p| File.join(*p)}
 
-# String used in generated include guards
-CEEDLING_GENERATED = 'CEEDLING_GENERATED'
+# Generated include guards take the form GEN<hash>_<STEM>_H_CEEDLING (see
+# FileWrapper.generate_include_guard). The pattern recognizes one wherever it appears in a
+# line of text by its fixed head and tail, each at an identifier boundary.
+GENERATED_INCLUDE_GUARD_PREFIX      = 'GEN'
+GENERATED_INCLUDE_GUARD_SUFFIX      = '_CEEDLING'
+GENERATED_INCLUDE_GUARD_HASH_LENGTH = 8
+GENERATED_INCLUDE_GUARD_PATTERN     = /\b#{GENERATED_INCLUDE_GUARD_PREFIX}[0-9A-F]{#{GENERATED_INCLUDE_GUARD_HASH_LENGTH}}_\w+#{GENERATED_INCLUDE_GUARD_SUFFIX}\b/
 
 PREPROCESS_SYM = :preprocess
 
@@ -166,6 +199,13 @@ UTILS_ROOT_NAME   = 'utils'                unless defined?(UTILS_ROOT_NAME)
 UTILS_TASK_ROOT   = UTILS_ROOT_NAME + ':'  unless defined?(UTILS_TASK_ROOT)
 UTILS_SYM         = UTILS_ROOT_NAME.to_sym unless defined?(UTILS_SYM)
 
+GEN_ROOT_NAME = 'gen'                unless defined?(GEN_ROOT_NAME)
+GEN_TASK_ROOT = GEN_ROOT_NAME + ':'  unless defined?(GEN_TASK_ROOT)
+GEN_SYM       = GEN_ROOT_NAME.to_sym unless defined?(GEN_SYM)
+
+GENERATE_MOCKS_TASK_ROOT       = GEN_TASK_ROOT + 'mocks:'       unless defined?(GENERATE_MOCKS_TASK_ROOT)
+GENERATE_TEST_RUNNER_TASK_ROOT = GEN_TASK_ROOT + 'test_runner:' unless defined?(GENERATE_TEST_RUNNER_TASK_ROOT)
+
 OPERATION_PREPROCESS_SYM  = :preprocess unless defined?(OPERATION_PREPROCESS_SYM)
 OPERATION_COMPILE_SYM     = :compile    unless defined?(OPERATION_COMPILE_SYM)
 OPERATION_ASSEMBLE_SYM    = :assemble   unless defined?(OPERATION_ASSEMBLE_SYM)
@@ -175,6 +215,7 @@ PREPROCESS_STANDINS_DIR  = 'standins'
 PREPROCESS_FULL_EXPANSION_DIR  = 'full_expansion'
 PREPROCESS_DIRECTIVES_ONLY_DIR = 'directives_only'
 PREPROCESS_RAW_DIRECTIVES_ONLY_DIR = 'directives_only/raw'
+PREPROCESS_FALLBACK_EXPANSION_DIR = 'fallback_expansion'
 
 BUILD_OUT_DIR          = 'out'
 BUILD_RESULTS_DIR      = 'results'
@@ -196,6 +237,19 @@ UNITY_TEST_RESULTS_TEMPLATE = <<~UNITY_TEST_RESULTS
   %{result}
 UNITY_TEST_RESULTS
 
-
-
-
+# Names Windows' Installer Detection treats as an installer's, requiring administrator rights
+WINDOWS_INSTALLER_KEYWORDS = /install|setup|update|patch/i
+
+# Requests the invoker's own rights, which turns Installer Detection off for a test executable
+TEST_EXECUTABLE_MANIFEST = <<~XML.freeze
+  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+  <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+      <security>
+        <requestedPrivileges>
+          <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+        </requestedPrivileges>
+      </security>
+    </trustInfo>
+  </assembly>
+XML

data/lib/ceedling/defaults.rb

@@ -339,7 +339,7 @@ DEFAULT_CEEDLING_PROJECT_CONFIG = {
 
   :libraries => {
     :flag => '-l${1}',
-    :path_flag => '-L ${1}',
+    :path_flag => '-L "${1}"',
     :test => [],
     :release => []
     },
@@ -355,13 +355,14 @@ DEFAULT_CEEDLING_PROJECT_CONFIG = {
     :list => '.lst',
     :testpass => '.pass',
     :testfail => '.fail',
-    :dependencies => '.d',
-    :yaml => '.yml'
+    :dependencies => '.d'
+    # :yaml, for mixin files, is read only from the project file itself (see bin/projectinator.rb)
     },
 
   :unity => {
     :defines => [],
-    :use_param_tests => false
+    :use_param_tests => false,
+    :shuffle_tests => false
     },
 
   :cmock => {
@@ -374,6 +375,8 @@ DEFAULT_CEEDLING_PROJECT_CONFIG = {
     #  (B) Test runner generator uses these same configuration values
     :mock_prefix => 'Mock',
     :mock_suffix => '',
+    # Names each mock by the folder its #include names so same-named headers stay distinct
+    :mock_name_include_folder => true,
     # CMock's default duplicated here.
     # We need a value present so preprocessing logic can safely reference it.
     :treat_inlines => :exclude,
@@ -395,6 +398,14 @@ DEFAULT_CEEDLING_PROJECT_CONFIG = {
   # All tools populated while building up config / defaults structure
   :tools => {},
 
+  :plugins => {
+    # Hidden setting, for plugins alone and absent from project configuration docs.
+    # Plugins declare, in their own defaults, which build contexts are peers of :test,
+    # whose :defines and :flags may then hold matcher hashes. A project setting it
+    # replaces every plugin's declaration.
+    :test_build_contexts => []
+    },
+
   }.freeze
 
 
@@ -419,11 +430,11 @@ CEEDLING_RUNTIME_CONFIG = {
 
 
 DEFAULT_TESTS_RESULTS_REPORT_TEMPLATE = %q{
-% ignored        = hash[:results][:counts][:ignored]
-% failed         = hash[:results][:counts][:failed]
-% stdout_count   = hash[:results][:counts][:stdout]
-% header_prepend = ((hash[:context] != TEST_SYM) ? "#{hash[:context].to_s.upcase}: " : '')
-% banner_width   = 25 + header_prepend.length # widest message
+% preamble       = @ceedling[:plugin_reportinator].test_report_preamble(hash)
+% ignored        = preamble[:ignored]
+% failed         = preamble[:failed]
+% stdout_count   = preamble[:stdout_count]
+% header_prepend = preamble[:header_prepend]
 
 % if (stdout_count > 0)
 <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'TEST OUTPUT')%>
@@ -438,9 +449,10 @@ DEFAULT_TESTS_RESULTS_REPORT_TEMPLATE = %q{
 <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'IGNORED TEST SUMMARY')%>
 %   hash[:results][:ignores].each do |ignore|
 %     ignore[:collection].each do |item|
-<%=ignore[:source][:file]%>:<%=item[:line]%>:<%=item[:test]%>
+%       prefix = "#{ignore[:source][:file]}:#{item[:line]}:#{item[:test]}"
+<%=prefix%>
 % if (item[:message].length > 0)
-: "<%=item[:message]%>"
+: "<%=@ceedling[:plugin_reportinator].reflow_message(item[:message], "#{prefix}: ")%>"
 % else
 <%="\n"%>
 % end
@@ -452,9 +464,10 @@ DEFAULT_TESTS_RESULTS_REPORT_TEMPLATE = %q{
 <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'FAILED TEST SUMMARY')%>
 %   hash[:results][:failures].each do |failure|
 %     failure[:collection].each do |item|
-<%=failure[:source][:file]%>:<%=item[:line]%>:<%=item[:test]%>
+%       prefix = "#{failure[:source][:file]}:#{item[:line]}:#{item[:test]}"
+<%=prefix%>
 % if (item[:message].length > 0)
-: "<%=item[:message]%>"
+: "<%=@ceedling[:plugin_reportinator].reflow_message(item[:message], "#{prefix}: ")%>"
 % else
 <%="\n"%>
 % end
@@ -464,7 +477,8 @@ DEFAULT_TESTS_RESULTS_REPORT_TEMPLATE = %q{
 % end
 % total_string = hash[:results][:counts][:total].to_s
 % format_string = "%#{total_string.length}i"
-<%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'OVERALL TEST SUMMARY')%>
+% banner_text = @ceedling[:plugin_reportinator].decorate_summary_banner('OVERALL TEST SUMMARY', failed)
+<%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + banner_text)%>
 % if (hash[:results][:counts][:total] > 0)
 TESTED:  <%=hash[:results][:counts][:total].to_s%>
 PASSED:  <%=sprintf(format_string, hash[:results][:counts][:passed])%>

data/lib/ceedling/defineinator.rb

@@ -38,7 +38,11 @@ class Defineinator
 
   # Defaults to inspecting configurations beneath top-level :defines
   # (But, we can also lookup defines symbol lists within framework configurations--:unity, :cmock, :cexception)
-  def defines(topkey:@topkey, subkey:, filepath:nil, default:[])
+  #
+  # no_match_default: see ConfigMatchinator#matches? -- passed through untouched
+  # for callers that want a filepath matching no entry in a Hash-shaped
+  # `subkey` to fall back to a specific value rather than an empty list.
+  def defines(topkey:@topkey, subkey:, filepath:nil, default:[], no_match_default: nil)
     defines = @config_matchinator.get_config(primary:topkey, secondary:subkey)
 
     if defines == nil then return default
@@ -49,7 +53,8 @@ class Defineinator
         hash: defines,
         filepath: filepath,
         section: topkey,
-        context: subkey
+        context: subkey,
+        no_match_default: no_match_default
       }
 
       return @config_matchinator.matches?(**arg_hash)
@@ -70,8 +75,8 @@ class Defineinator
       # Replace any non-ASCII characters with underscores
       test_def = test_def.clean_encoding('_')
 
-      # Replace all non-alphanumeric characters (including spaces/punctuation but excluding underscores) with underscores
-      test_def.gsub!(/[^0-9a-z_]/i, '_')
+      # Replace all non-alphanumeric characters (including spaces/punctuation but excluding underscores and dashes) with underscores
+      test_def.gsub!(/[^0-9a-z_-]/i, '_')
 
       # Convert to all caps
       test_def.upcase!